328 lines
8.4 KiB
C
328 lines
8.4 KiB
C
//////////////////////////////////////
|
|
// Cunren Liang, NASA JPL/Caltech
|
|
// Copyright 2017
|
|
//////////////////////////////////////
|
|
|
|
|
|
//a program for taking looks for single band file
|
|
|
|
#include "resamp.h"
|
|
|
|
int look(char *inputfile, char *outputfile, long nrg, int nrlks, int nalks, int ft, int sum, int avg){
|
|
|
|
FILE *infp;
|
|
FILE *outfp;
|
|
|
|
signed char *in0;
|
|
int *in1;
|
|
float *in2;
|
|
double *in3;
|
|
fcomplex *in4;
|
|
dcomplex *in5;
|
|
|
|
signed char *out0;
|
|
int *out1;
|
|
float *out2;
|
|
double *out3;
|
|
fcomplex *out4;
|
|
dcomplex *out5;
|
|
|
|
int sum_nz;
|
|
double sum1, sum2;
|
|
|
|
long index;
|
|
|
|
long naz;
|
|
long nrg1, naz1;
|
|
//int nrlks, nalks;
|
|
|
|
//int ft, sum, avg;
|
|
|
|
int i, j;
|
|
int ii, jj;
|
|
|
|
|
|
// if(argc < 4){
|
|
// fprintf(stderr, "\nUsage: %s infile outfile nrg [nrlks] [nalks] [ft] [sum] [avg]\n", argv[0]);
|
|
// fprintf(stderr, " infile: input file\n");
|
|
// fprintf(stderr, " outfile: output file\n");
|
|
// fprintf(stderr, " nrg: file width\n");
|
|
// fprintf(stderr, " nrlks: number of looks in range (default: 4)\n");
|
|
// fprintf(stderr, " nalks: number of looks in azimuth (default: 4)\n");
|
|
// fprintf(stderr, " ft: file type (default: 0)\n");
|
|
// fprintf(stderr, " 0: signed char\n");
|
|
// fprintf(stderr, " 1: int\n");
|
|
// fprintf(stderr, " 2: float\n");
|
|
// fprintf(stderr, " 3: double\n");
|
|
// fprintf(stderr, " 4: complex (real and imagery: float)\n");
|
|
// fprintf(stderr, " 5: complex (real and imagery: double)\n");
|
|
// fprintf(stderr, " sum: sum method (default: 0)\n");
|
|
// fprintf(stderr, " 0: simple sum\n");
|
|
// fprintf(stderr, " 1: power sum (if complex, do this for each channel seperately)\n");
|
|
// fprintf(stderr, " avg: take average (default: 0)\n");
|
|
// fprintf(stderr, " 0: no\n");
|
|
// fprintf(stderr, " 1: yes\n\n");
|
|
|
|
// exit(1);
|
|
// }
|
|
|
|
infp = openfile(inputfile, "rb");
|
|
outfp = openfile(outputfile, "wb");
|
|
|
|
//nrg = atoi(argv[3]);
|
|
|
|
//if(argc > 4)
|
|
// nrlks = atoi(argv[4]);
|
|
//else
|
|
// nrlks = 4;
|
|
|
|
//if(argc > 5)
|
|
// nalks = atoi(argv[5]);
|
|
//else
|
|
// nalks = 4;
|
|
|
|
//if(argc > 6)
|
|
// ft = atoi(argv[6]);
|
|
//else
|
|
// ft = 0;
|
|
|
|
//if(argc > 7)
|
|
// sum = atoi(argv[7]);
|
|
//else
|
|
// sum = 0;
|
|
|
|
//if(argc > 8)
|
|
// avg = atoi(argv[8]);
|
|
//else
|
|
// avg = 0;
|
|
|
|
nrg1 = nrg / nrlks;
|
|
|
|
if(ft == 0){
|
|
in0 = array1d_char(nrg*nalks);
|
|
out0 = array1d_char(nrg1);
|
|
naz = file_length(infp, nrg, sizeof(signed char));
|
|
}
|
|
else if(ft == 1){
|
|
in1 = array1d_int(nrg*nalks);
|
|
out1 = array1d_int(nrg1);
|
|
naz = file_length(infp, nrg, sizeof(int));
|
|
}
|
|
else if(ft == 2){
|
|
in2 = array1d_float(nrg*nalks);
|
|
out2 = array1d_float(nrg1);
|
|
naz = file_length(infp, nrg, sizeof(float));
|
|
}
|
|
else if(ft == 3){
|
|
in3 = array1d_double(nrg*nalks);
|
|
out3 = array1d_double(nrg1);
|
|
naz = file_length(infp, nrg, sizeof(double));
|
|
}
|
|
else if(ft == 4){
|
|
in4 = array1d_fcomplex(nrg*nalks);
|
|
out4 = array1d_fcomplex(nrg1);
|
|
naz = file_length(infp, nrg, sizeof(fcomplex));
|
|
}
|
|
else if(ft == 5){
|
|
in5 = array1d_dcomplex(nrg*nalks);
|
|
out5 = array1d_dcomplex(nrg1);
|
|
naz = file_length(infp, nrg, sizeof(dcomplex));
|
|
}
|
|
else{
|
|
fprintf(stderr, "Error: file type not supported.\n\n");
|
|
exit(1);
|
|
}
|
|
|
|
naz1 = naz / nalks;
|
|
|
|
for(i = 0; i < naz1; i++){
|
|
|
|
if((i + 1) % 100 == 0)
|
|
fprintf(stderr,"processing line: %6d of %6d\r", i+1, naz1);
|
|
|
|
//read data
|
|
if(ft == 0){
|
|
readdata((signed char *)in0, (size_t)nalks * (size_t)nrg * sizeof(signed char), infp);
|
|
}
|
|
else if(ft == 1){
|
|
readdata((int *)in1, (size_t)nalks * (size_t)nrg * sizeof(int), infp);
|
|
}
|
|
else if(ft == 2){
|
|
readdata((float *)in2, (size_t)nalks * (size_t)nrg * sizeof(float), infp);
|
|
}
|
|
else if(ft == 3){
|
|
readdata((double *)in3, (size_t)nalks * (size_t)nrg * sizeof(double), infp);
|
|
}
|
|
else if(ft == 4){
|
|
readdata((fcomplex *)in4, (size_t)nalks * (size_t)nrg * sizeof(fcomplex), infp);
|
|
}
|
|
else if(ft == 5){
|
|
readdata((dcomplex *)in5, (size_t)nalks * (size_t)nrg * sizeof(dcomplex), infp);
|
|
}
|
|
|
|
//process data
|
|
for(j = 0; j < nrg1; j++){
|
|
//get sum
|
|
sum_nz = 0;
|
|
sum1 = 0.0;
|
|
sum2 = 0.0;
|
|
for(ii = 0; ii < nalks; ii++){
|
|
for(jj = 0; jj < nrlks; jj++){
|
|
index = ii * nrg + j * nrlks + jj;
|
|
if(ft == 0){
|
|
if(in0[index] != 0){
|
|
if(sum == 0)
|
|
sum1 += in0[index];
|
|
else
|
|
sum1 += in0[index] * in0[index];
|
|
sum_nz += 1;
|
|
}
|
|
}
|
|
else if(ft == 1){
|
|
if(in1[index] != 0){
|
|
if(sum == 0)
|
|
sum1 += in1[index];
|
|
else
|
|
sum1 += in1[index] * in1[index];
|
|
sum_nz += 1;
|
|
}
|
|
}
|
|
else if(ft == 2){
|
|
if(in2[index] != 0){
|
|
if(sum == 0)
|
|
sum1 += in2[index];
|
|
else
|
|
sum1 += in2[index] * in2[index];
|
|
sum_nz += 1;
|
|
}
|
|
}
|
|
else if(ft == 3){
|
|
if(in3[index] != 0){
|
|
if(sum == 0)
|
|
sum1 += in3[index];
|
|
else
|
|
sum1 += in3[index] * in3[index];
|
|
sum_nz += 1;
|
|
}
|
|
}
|
|
else if(ft == 4){
|
|
if(in4[index].re != 0 || in4[index].im != 0){
|
|
if(sum ==0){
|
|
sum1 += in4[index].re;
|
|
sum2 += in4[index].im;
|
|
}
|
|
else{
|
|
sum1 += in4[index].re * in4[index].re;
|
|
sum2 += in4[index].im * in4[index].im;
|
|
}
|
|
sum_nz += 1;
|
|
}
|
|
}
|
|
else if(ft == 5){
|
|
if(in5[index].re != 0 || in5[index].im != 0){
|
|
if(sum == 0){
|
|
sum1 += in5[index].re;
|
|
sum2 += in5[index].im;
|
|
}
|
|
else{
|
|
sum1 += in5[index].re * in5[index].re;
|
|
sum2 += in5[index].im * in5[index].im;
|
|
}
|
|
sum_nz += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//preprocessing
|
|
if(avg == 1){
|
|
if(sum_nz != 0){
|
|
sum1 /= sum_nz;
|
|
if(ft == 4 || ft == 5)
|
|
sum2 /= sum_nz;
|
|
}
|
|
}
|
|
if(sum == 1){
|
|
if(sum_nz != 0){
|
|
sum1 = sqrt(sum1);
|
|
if(ft == 4 || ft ==5)
|
|
sum2 = sqrt(sum2);
|
|
}
|
|
}
|
|
|
|
//get data
|
|
if(ft == 0){
|
|
out0[j] = (signed char)(roundfi(sum1));
|
|
}
|
|
else if(ft == 1){
|
|
out1[j] = (int)(roundfi(sum1));
|
|
}
|
|
else if(ft == 2){
|
|
out2[j] = sum1;
|
|
}
|
|
else if(ft == 3){
|
|
out3[j] = sum1;
|
|
}
|
|
else if(ft == 4){
|
|
out4[j].re = sum1;
|
|
out4[j].im = sum2;
|
|
}
|
|
else if(ft == 5){
|
|
out5[j].re = sum1;
|
|
out5[j].im = sum2;
|
|
}
|
|
}
|
|
|
|
//write data
|
|
if(ft == 0){
|
|
writedata((signed char *)out0, nrg1 * sizeof(signed char), outfp);
|
|
}
|
|
else if(ft == 1){
|
|
writedata((int *)out1, nrg1 * sizeof(int), outfp);
|
|
}
|
|
else if(ft == 2){
|
|
writedata((float *)out2, nrg1 * sizeof(float), outfp);
|
|
}
|
|
else if(ft == 3){
|
|
writedata((double *)out3, nrg1 * sizeof(double), outfp);
|
|
}
|
|
else if(ft == 4){
|
|
writedata((fcomplex *)out4, nrg1 * sizeof(fcomplex), outfp);
|
|
}
|
|
else if(ft == 5){
|
|
writedata((dcomplex *)out5, nrg1 * sizeof(dcomplex), outfp);
|
|
}
|
|
}
|
|
fprintf(stderr,"processing line: %6d of %6d\n", naz1, naz1);
|
|
|
|
//clear up
|
|
if(ft == 0){
|
|
free_array1d_char(in0);
|
|
free_array1d_char(out0);
|
|
}
|
|
else if(ft == 1){
|
|
free_array1d_int(in1);
|
|
free_array1d_int(out1);
|
|
}
|
|
else if(ft == 2){
|
|
free_array1d_float(in2);
|
|
free_array1d_float(out2);
|
|
}
|
|
else if(ft == 3){
|
|
free_array1d_double(in3);
|
|
free_array1d_double(out3);
|
|
}
|
|
else if(ft == 4){
|
|
free_array1d_fcomplex(in4);
|
|
free_array1d_fcomplex(out4);
|
|
}
|
|
else if(ft == 5){
|
|
free_array1d_dcomplex(in5);
|
|
free_array1d_dcomplex(out5);
|
|
}
|
|
fclose(infp);
|
|
fclose(outfp);
|
|
|
|
return 0;
|
|
}
|