int asf_logscale(const char *inFile, const char *outFile)
{
int ii, jj, kk;
meta_parameters *meta = meta_read(inFile);
int band_count = meta->general->band_count;
int sample_count = meta->general->sample_count;
int line_count = meta->general->line_count;
float *bufIn = (float *) MALLOC(sizeof(float)*sample_count);
float *bufOut = (float *) MALLOC(sizeof(float)*sample_count);
char *input = appendExt(inFile, ".img");
char *output = appendExt(outFile, ".img");
FILE *fpIn = FOPEN(input, "rb");
FILE *fpOut = FOPEN(output, "wb");
for (kk=0; kk<band_count; kk++) {
for (ii=0; ii<line_count; ii++) {
get_band_float_line(fpIn, meta, kk, ii, bufIn);
for (jj=0; jj<sample_count; jj++) {
if (FLOAT_EQUIVALENT(bufIn[jj], 0.0))
bufOut[jj] = 0.0;
else
bufOut[jj] = 10.0 * log10(bufIn[jj]);
}
put_band_float_line(fpOut, meta, kk, ii, bufOut);
asfLineMeter(ii, line_count);
}
}
meta_write(meta, outFile);
meta_free(meta);
FCLOSE(fpIn);
FCLOSE(fpOut);
FREE(bufIn);
FREE(bufOut);
FREE(input);
FREE(output);
return FALSE;
}
int sr2gr_pixsiz(const char *infile, const char *outfile, float grPixSize)
{
int in_np, in_nl; /* input number of pixels,lines */
int out_np, out_nl; /* output number of pixels,lines */
int ii,line,band;
float oldX,oldY;
float sr2gr[MAX_IMG_SIZE];
float ml2gr[MAX_IMG_SIZE];
int a_lower[MAX_IMG_SIZE];
int lower[MAX_IMG_SIZE], upper[MAX_IMG_SIZE];
float a_ufrac[MAX_IMG_SIZE], a_lfrac[MAX_IMG_SIZE];
float ufrac[MAX_IMG_SIZE], lfrac[MAX_IMG_SIZE];
float *ibuf1,*ibuf2,*obuf;
char infile_name[512],inmeta_name[512];
char outfile_name[512],outmeta_name[512];
FILE *fpi, *fpo;
meta_parameters *in_meta;
meta_parameters *out_meta;
create_name (infile_name, infile, ".img");
create_name (outfile_name, outfile, ".img");
create_name (inmeta_name, infile, ".meta");
create_name (outmeta_name, outfile, ".meta");
in_meta = meta_read(inmeta_name);
out_meta = meta_copy(in_meta);
in_nl = in_meta->general->line_count;
in_np = in_meta->general->sample_count;
if (in_meta->sar->image_type != 'S')
{
asfPrintError("sr2gr only works with slant range images!\n");
}
oldX = in_meta->general->x_pixel_size * in_meta->sar->sample_increment;
oldY = in_meta->general->y_pixel_size * in_meta->sar->line_increment;
/* If user didn't specify a pixel size, make the pixels square & leave
the y pixel size unchanged */
if (grPixSize < 0)
grPixSize = oldY;
/*Update metadata for new pixel size*/
out_meta->sar->time_shift += ((in_meta->general->start_line)
* in_meta->sar->azimuth_time_per_pixel);
out_meta->sar->slant_shift -= ((in_meta->general->start_sample)
* in_meta->general->x_pixel_size);
out_meta->general->start_line = 0.0;
out_meta->general->start_sample = 0.0;
out_meta->sar->azimuth_time_per_pixel *= grPixSize
/ in_meta->general->y_pixel_size;
out_meta->sar->line_increment = 1.0;
out_meta->sar->sample_increment = 1.0;
if (out_meta->transform)
out_meta->transform->target_pixel_size = grPixSize;
/*Create ground/slant and azimuth conversion vectors*/
out_meta->sar->image_type = 'G';
out_meta->general->x_pixel_size = grPixSize;
out_meta->general->y_pixel_size = grPixSize;
sr2gr_vec(out_meta,oldX,grPixSize,sr2gr);
ml_vec(oldY,grPixSize,ml2gr);
out_np = MAX_IMG_SIZE;
out_nl = MAX_IMG_SIZE;
for (ii=MAX_IMG_SIZE-1; ii>0; ii--)
if ((int)sr2gr[ii] > in_np)
out_np = ii;
for (ii=MAX_IMG_SIZE-1; ii>0; ii--)
if ((int)ml2gr[ii] > in_nl)
out_nl = ii;
out_meta->general->line_count = out_nl;
out_meta->general->line_scaling *= (double)in_nl/(double)out_nl;
out_meta->general->sample_scaling = 1;
out_meta->general->sample_count = out_np;
if (out_meta->projection) {
out_meta->projection->perX = grPixSize;
out_meta->projection->perY = grPixSize;
}
meta_write(out_meta,outmeta_name);
fpi = fopenImage(infile_name,"rb");
fpo = fopenImage(outfile_name,"wb");
for (ii=0; ii<MAX_IMG_SIZE; ii++)
{
lower[ii] = (int) sr2gr[ii];
upper[ii] = lower[ii] + 1;
ufrac[ii] = sr2gr[ii] - (float) lower[ii];
lfrac[ii] = 1.0 - ufrac[ii];
a_lower[ii] = (int) ml2gr[ii];
a_ufrac[ii] = ml2gr[ii] - (float) a_lower[ii];
a_lfrac[ii] = 1.0 - a_ufrac[ii];
}
ibuf1 = (float *) MALLOC ((in_np+FUDGE_FACTOR)*sizeof(float));
ibuf2 = (float *) MALLOC ((in_np+FUDGE_FACTOR)*sizeof(float));
obuf = (float *) MALLOC (out_np*sizeof(float));
/* Initialize input arrays to 0 */
for (ii=0;ii<in_np+FUDGE_FACTOR;ii++) {
ibuf1[ii]=ibuf2[ii]=0.0;
}
/* Get the band info */
int bc = in_meta->general->band_count;
char **band_name = extract_band_names(in_meta->general->bands, bc);
/* Work dat magic! */
for (band=0; band<bc; ++band) {
asfPrintStatus("Working on band: %s\n", band_name[band]);
for (line=0; line<out_nl; line++)
{
if (a_lower[line]+1 < in_nl)
{
get_band_float_line(fpi,in_meta,band,a_lower[line], ibuf1);
get_band_float_line(fpi,in_meta,band,a_lower[line]+1,ibuf2);
}
for (ii=0; ii<out_np; ii++)
{
int val00,val01,val10,val11,tmp1,tmp2;
val00 = ibuf1[lower[ii]];
val01 = ibuf1[upper[ii]];
val10 = ibuf2[lower[ii]];
val11 = ibuf2[upper[ii]];
tmp1 = val00*lfrac[ii] + val01*ufrac[ii];
tmp2 = val10*lfrac[ii] + val11*ufrac[ii];
obuf[ii] = tmp1*a_lfrac[line] + tmp2*a_ufrac[line];
}
put_band_float_line(fpo,out_meta,band,line,obuf);
asfLineMeter(line, out_nl);
}
}
for (band=0; band<bc; ++band)
FREE(band_name[band]);
FREE(band_name);
meta_free(in_meta);
meta_free(out_meta);
FCLOSE(fpi);
FCLOSE(fpo);
return TRUE;
}
int clip(char *inFile, char *maskFile, char *outFile)
{
meta_parameters *metaIn, *metaMask;
metaIn = meta_read(inFile);
metaMask = meta_read(maskFile);
// Check whether mask file looks legitimate. The only indication that we
// have is that it should be BYTE and have one band.
if (metaMask->general->data_type != ASF_BYTE)
asfPrintStatus("Mask image does not have data type 'BYTE'!\n");
if (metaMask->general->band_count != 1)
asfPrintStatus("Mask image should have only one band!\n");
// Check whether input and mask file have the same projection parameters
if (metaIn->projection && metaMask->projection) {
// Create temporary processing directory (move outside this loop once
// we have non-projected case covered)
char *tmpDir = (char *) MALLOC(sizeof(char)*(strlen(outFile)+25));
sprintf(tmpDir, "%s-", outFile);
strcat(tmpDir, time_stamp_dir());
create_clean_dir(tmpDir);
char *mask = (char *) MALLOC(sizeof(char)*(strlen(tmpDir)+20));
sprintf(mask, "%s/mask", tmpDir);
// Check whether mask needs to be re-projected
if (metaIn->projection->type != metaMask->projection->type) {
asfPrintWarning("Mask needs to be re-projected!\n");
project_parameters_t *pp =
(project_parameters_t *) MALLOC(sizeof(project_parameters_t));
*pp = metaIn->projection->param;
/*
asf_geocode(pp, metaIn->projection->type, FALSE,
RESAMPLE_NEAREST_NEIGHBOR, metaIn->projection->height,
metaIn->projection->datum, metaIn->projection->perX,
NULL, inFile, mask, metaIn->general->no_data, FALSE);
*/
FREE(pp);
}
else {
// Check whether mask needs to be resampled
if ((metaIn->projection->perX != metaMask->projection->perX ||
metaIn->projection->perY != metaMask->projection->perY) &&
proj_params_match(metaIn, metaMask)) {
asfPrintWarning("Mask needs to be resampled!\n");
resample(inFile, mask, metaIn->projection->perX,
fabs(metaIn->projection->perY));
}
else if (!proj_params_match(metaIn, metaMask)) {
asfPrintWarning("Mask needs to be re-projected!\n");
project_parameters_t *pp =
(project_parameters_t *) MALLOC(sizeof(project_parameters_t));
*pp = metaIn->projection->param;
/*
asf_geocode(pp, metaIn->projection->type, FALSE,
RESAMPLE_NEAREST_NEIGHBOR, metaIn->projection->height,
metaIn->projection->datum, metaIn->projection->perX,
NULL, inFile, mask, metaIn->general->no_data, FALSE);
*/
FREE(pp);
}
else
copyImgAndMeta(maskFile, mask);
}
meta_free(metaMask);
// Now we should have matching projections in both input files
// Let's figure out the overlapping part of the two input files
metaMask = meta_read(mask);
int nl = metaMask->general->line_count;
int ns = metaMask->general->sample_count;
int startLine = (int)
((metaMask->projection->startY - metaIn->projection->startY + 0.5) /
metaMask->projection->perY) - metaMask->general->start_line;
int startSample = (int)
((metaMask->projection->startX - metaIn->projection->startX + 0.5) /
metaMask->projection->perX) - metaMask->general->start_sample;
int endLine = startLine + metaMask->general->line_count;
int endSample = startSample + metaMask->general->sample_count;
double coverage =
(endLine-startLine) * (endSample-startSample) * 100.0 / (ns*nl);
printf("startLine: %i, startSample: %i\n", startLine, startSample);
printf("endLine: %i, endSample: %i\n", endLine, endSample);
printf("Converage: %.1f %%\n", coverage);
// Fail when there is no overlap
if (startLine > metaIn->general->line_count || endLine < 0 ||
startSample > metaIn->general->sample_count || endSample < 0) {
asfPrintStatus("Mask image does not cover the input image!\n");
return (1);
}
// Setup files and memory
char *inImg = appendExt(inFile, ".img");
char *maskImg = appendExt(maskFile, ".img");
char *outImg = appendExt(outFile, ".img");
float *inBuf =
(float *) MALLOC(sizeof(float)*metaIn->general->sample_count);
unsigned char *maskBuf = (unsigned char *) MALLOC(sizeof(char)*ns);
float *outBuf = (float *) MALLOC(sizeof(float)*ns);
char **band_name = extract_band_names(metaIn->general->bands,
metaIn->general->band_count);
FILE *fpIn = FOPEN(inImg, "rb");
FILE *fpMask = FOPEN(maskImg, "rb");
FILE *fpOut = FOPEN(outImg, "wb");
// Write metadata for output
meta_parameters *metaOut = meta_read(maskFile);
metaOut->general->band_count = metaIn->general->band_count;
metaOut->general->data_type = metaIn->general->data_type;
meta_write(metaOut, outFile);
// Rock and roll
int ii, jj, kk;
for (ii=0; ii<nl; ii++) {
get_byte_line(fpMask, metaMask, ii, maskBuf);
for (kk=0; kk<metaIn->general->band_count; kk++) {
if ((startLine+ii) >= 0 && ii < endLine)
get_band_float_line(fpIn, metaIn, kk, startLine+ii, inBuf);
else
for (jj=0; jj<ns; jj++)
inBuf[jj] = 0.0;
for (jj=0; jj<ns; jj++) {
if (maskBuf[jj] == 0 || inBuf[startSample+jj] == 0 ||
(startSample+jj) < 0 || jj > endSample)
outBuf[jj] = metaIn->general->no_data;
else
outBuf[jj] = inBuf[startSample+jj]*maskBuf[jj];
}
put_band_float_line(fpOut, metaOut, kk, ii, outBuf);
}
asfLineMeter(ii, nl);
}
FCLOSE(fpIn);
FCLOSE(fpMask);
FCLOSE(fpOut);
// Clean up
for (ii=0; ii<metaIn->general->band_count; ii++)
FREE(band_name[ii]);
FREE(band_name);
FREE(inBuf);
FREE(maskBuf);
FREE(outBuf);
meta_free(metaIn);
meta_free(metaMask);
meta_free(metaOut);
remove_dir(tmpDir);
FREE(tmpDir);
}
else
asfPrintError("Non-projected case not covered yet!\n");
return 0;
}
// if png_flag is true, outputs a PNG. if false, outputs a jpeg
static void patchToRGBImage(char *outname, int png_flag)
{
update_status("Generating %s", outname);
if (!quietflag)
printf(" Outputting Debugging image '%s'...\n",outname);
// input name is just the output name with ".img"
char *polar_name = MALLOC((strlen(outname)+20)*sizeof(char));
sprintf(polar_name, "%s_polar.img", outname);
// will multilook, as well as conver to polar, generates a 2-band
// file (amplitude is band 1, phase is band 2)
c2p(outname,polar_name,FALSE,TRUE);
// prepare for RGB conversion
int i,j;
meta_parameters *meta = meta_read(polar_name);
int nl = meta->general->line_count;
int ns = meta->general->sample_count;
float *amp = MALLOC(sizeof(float)*ns);
float *phase = MALLOC(sizeof(float)*ns);
unsigned char *red = MALLOC(sizeof(unsigned char)*ns);
unsigned char *grn = MALLOC(sizeof(unsigned char)*ns);
unsigned char *blu = MALLOC(sizeof(unsigned char)*ns);
FILE *fp = fopenImage(polar_name, "rb");
const double TWOPI=2.*PI;
const double PIOVER3=PI/3.;
int n=0;
// first/second passes are stats gathering
asfPrintStatus("Gathering stats...\n");
double avg=0, stddev=0;
for (i=0; i<nl; i+=3) {
get_float_line(fp,meta,i,amp);
for (j=0; j<ns; j+=3) {
avg += amp[j];
++n;
}
asfPercentMeter((float)i/((float)nl*2.));
}
avg /= (double)n;
for (i=0; i<nl; i+=3) {
get_float_line(fp,meta,i,amp);
for (j=0; j<ns; j+=3) {
stddev += (amp[j]-avg)*(amp[j]-avg);
}
asfPercentMeter((float)(i+nl)/((float)nl*2.));
}
asfPercentMeter(1);
stddev = sqrt(stddev/(double)n);
double min = avg - 2*stddev;
double max = avg + 2*stddev;
// open up PNG/JPEG output file
FILE *ofp=NULL;
struct jpeg_compress_struct cinfo;
png_structp png_ptr;
png_infop png_info_ptr;
char *jpgname = NULL;
char *pngname = NULL;
if (png_flag) {
asfPrintStatus("Generating debug image (PNG)...\n");
pngname = appendExt(outname, ".png");
initialize_png_file(pngname,meta,&ofp,&png_ptr,&png_info_ptr,TRUE);
}
else {
asfPrintStatus("Generating debug image (JPEG)...\n");
jpgname = appendExt(outname, ".jpg");
initialize_jpeg_file(jpgname,meta,&ofp,&cinfo,TRUE);
}
// now read in the polar image, calculate RGB values, write to jpeg/png
for (i=0; i<nl; ++i) {
get_band_float_line(fp,meta,0,i,amp);
get_band_float_line(fp,meta,1,i,phase);
for (j=0; j<ns; ++j) {
// scale to 2-sigma, to get brightness of the pixel
unsigned char intensity;
//=(unsigned char)(amp[j] * 128./(float)avg * 41./255.);
if (amp[j]<=min)
intensity=0;
else if (amp[j]>=max)
intensity=255;
else
intensity=(unsigned char)((amp[j]-min)/(max-min)*255.);
// color of the pixel is determined by the phase
unsigned char r=0,g=0,b=0;
if (phase[j]<-PI) phase[j]+=TWOPI; // ensure [-PI, PI)
if (phase[j]>=PI) phase[j]-=TWOPI;
int range = (int)((phase[j]+PI)/PIOVER3); // will be 0-6 (and rarely 6)
switch (range) {
case 0: r=1; break;
case 1: r=1; g=1; break;
case 2: g=1; break;
case 3: g=1; b=1; break;
case 4: b=1; break;
case 5: r=1; b=1; break;
case 6: break; // left black
default:
printf("phase: %f, range: %d\n", phase[j], range);
assert(FALSE); break;
}
red[j] = r*intensity;
grn[j] = g*intensity;
blu[j] = b*intensity;
}
// write the line
if (png_flag)
write_rgb_png_byte2byte(ofp,red,grn,blu,png_ptr,png_info_ptr,ns);
else
write_rgb_jpeg_byte2byte(ofp,red,grn,blu,&cinfo,ns);
// keep the user interested!
asfPercentMeter((float)i/((float)nl));
}
asfPercentMeter(1.0);
// clean up
FCLOSE(fp);
FREE(amp);
FREE(phase);
FREE(red);
FREE(grn);
FREE(blu);
meta_free(meta);
if (png_flag)
finalize_png_file(ofp,png_ptr,png_info_ptr);
else
finalize_jpeg_file(ofp,&cinfo);
FREE(jpgname);
FREE(pngname);
clean(polar_name);
FREE(polar_name);
}
static void add_pixels(BandedFloatImage *out, char *file,
int size_x, int size_y,
double start_x, double start_y,
double per_x, double per_y)
{
meta_parameters *meta = meta_read(file);
if (!meta) {
asfPrintError("Couldn't read metadata for: %s!\n", file);
}
// figure out where in the giant image these pixels will go
int start_line, start_sample;
// this should work even if per_x / per_y are negative...
start_sample = (int) ((meta->projection->startX - start_x) / per_x + .5);
start_line = (int) ((meta->projection->startY - start_y) / per_y + .5);
int ns = meta->general->sample_count;
int nl = meta->general->line_count;
int nb = meta->general->band_count;
char **bands = extract_band_names(meta->general->bands, nb);
asfPrintStatus(" Location in combined is S:%d-%d, L:%d-%d\n",
start_sample, start_sample + ns,
start_line, start_line + nl);
if (start_sample + ns > out->images[0]->size_x ||
start_line + nl > out->images[0]->size_y) {
asfPrintError("Image extents were not calculated correctly!\n");
}
FILE *img = fopenImage(file, "rb");
if (!img) {
asfPrintError("Couldn't open image file: %s!\n", file);
}
float *line = MALLOC(sizeof(float)*ns);
int z;
for (z=0; z<nb; ++z) {
asfPrintStatus(" Band: %s\n", bands[z]);
int y;
for (y=0; y<nl; ++y) {
get_band_float_line(img, meta, z, y, line);
int x;
for (x=0; x<ns; ++x) {
float v = line[x];
// don't write out "no data" values
if (v != meta->general->no_data)
banded_float_image_set_pixel(out, z,
x+start_sample, y+start_line, v);
}
asfLineMeter(y, nl);
}
}
fclose(img);
free(line);
meta_free(meta);
}
int asf_calibrate(const char *inFile, const char *outFile,
radiometry_t outRadiometry, int wh_scaleFlag)
{
meta_parameters *metaIn = meta_read(inFile);
meta_parameters *metaOut = meta_read(inFile);
if (!metaIn->calibration) {
asfPrintError("This data cannot be calibrated, missing calibration block.\n");
}
// Check for valid output radiometry
if (outRadiometry == r_AMP || outRadiometry == r_POWER)
asfPrintError("Invalid radiometry (%s) passed into calibration function!\n",
radiometry2str(outRadiometry));
// Check whether output radiometry fits with Woods Hole scaling flag
if (wh_scaleFlag && outRadiometry >= r_SIGMA && outRadiometry <= r_GAMMA)
outRadiometry += 3;
// This can only work if the image is in some SAR geometry
if (metaIn->projection && metaIn->projection->type != SCANSAR_PROJECTION)
asfPrintError("Can't apply calibration factors to map projected images\n"
"(Amplitude or Power only)\n");
radiometry_t inRadiometry = metaIn->general->radiometry;
asfPrintStatus("Calibrating %s image to %s image\n\n",
radiometry2str(inRadiometry), radiometry2str(outRadiometry));
// FIXME: This function should be able to remap between different
// radiometry projections.
if (metaIn->general->radiometry != r_AMP)
asfPrintError("Currently only AMPLITUDE as radiometry is supported!\n");
metaOut->general->radiometry = outRadiometry;
int dbFlag = FALSE;
if (outRadiometry >= r_SIGMA && outRadiometry <= r_GAMMA)
metaOut->general->no_data = 0.0001;
if (outRadiometry >= r_SIGMA_DB && outRadiometry <= r_GAMMA_DB) {
metaOut->general->no_data = -40.0;
dbFlag = TRUE;
}
if (metaIn->general->image_data_type != POLARIMETRIC_IMAGE) {
if (outRadiometry == r_SIGMA || outRadiometry == r_SIGMA_DB)
metaOut->general->image_data_type = SIGMA_IMAGE;
else if (outRadiometry == r_BETA || outRadiometry == r_BETA_DB)
metaOut->general->image_data_type = BETA_IMAGE;
else if (outRadiometry == r_GAMMA || outRadiometry == r_GAMMA_DB)
metaOut->general->image_data_type = GAMMA_IMAGE;
}
if (wh_scaleFlag)
metaOut->general->data_type = ASF_BYTE;
char *input = appendExt(inFile, ".img");
char *output = appendExt(outFile, ".img");
FILE *fpIn = FOPEN(input, "rb");
FILE *fpOut = FOPEN(output, "wb");
int dualpol = strncmp_case(metaIn->general->mode, "FBD", 3) == 0 ? 1 : 0;
int band_count = metaIn->general->band_count;
int sample_count = metaIn->general->sample_count;
int line_count = metaIn->general->line_count;
char **bands =
extract_band_names(metaIn->general->bands, band_count);
float *bufIn = (float *) MALLOC(sizeof(float)*sample_count);
float *bufOut = (float *) MALLOC(sizeof(float)*sample_count);
float *bufIn2 = NULL, *bufOut2 = NULL, *bufOut3 = NULL;
if (dualpol && wh_scaleFlag) {
bufIn2 = (float *) MALLOC(sizeof(float)*sample_count);
bufOut2 = (float *) MALLOC(sizeof(float)*sample_count);
bufOut3 = (float *) MALLOC(sizeof(float)*sample_count);
metaOut->general->band_count = 3;
sprintf(metaOut->general->bands, "%s,%s,%s-%s",
bands[0], bands[1], bands[0], bands[1]);
}
int ii, jj, kk;
float cal_dn, cal_dn2;
double incid;
if (dualpol && wh_scaleFlag) {
metaOut->general->image_data_type = RGB_STACK;
for (ii=0; ii<line_count; ii++) {
get_band_float_line(fpIn, metaIn, 0, ii, bufIn);
get_band_float_line(fpIn, metaIn, 1, ii, bufIn2);
for (jj=0; jj<sample_count; jj++) {
// Taking the remapping of other radiometries out for the moment
//if (inRadiometry >= r_SIGMA && inRadiometry <= r_BETA_DB)
//bufIn[jj] = cal2amp(metaIn, incid, jj, bands[kk], bufIn[jj]);
incid = meta_incid(metaIn, ii, jj);
cal_dn =
get_cal_dn(metaOut, incid, jj, bufIn[jj], bands[0], dbFlag);
cal_dn2 =
get_cal_dn(metaOut, incid, jj, bufIn2[jj], bands[1], dbFlag);
if (FLOAT_EQUIVALENT(cal_dn, metaIn->general->no_data) ||
cal_dn == cal_dn2) {
bufOut[jj] = 0;
bufOut2[jj] = 0;
bufOut3[jj] = 0;
}
else {
bufOut[jj] = (cal_dn + 31) / 0.15 + 1.5;
bufOut2[jj] = (cal_dn2 + 31) / 0.15 + 1.5;
bufOut3[jj] = bufOut[jj] - bufOut2[jj];
}
}
put_band_float_line(fpOut, metaOut, 0, ii, bufOut);
put_band_float_line(fpOut, metaOut, 1, ii, bufOut2);
put_band_float_line(fpOut, metaOut, 2, ii, bufOut3);
asfLineMeter(ii, line_count);
}
}
else {
for (kk=0; kk<band_count; kk++) {
for (ii=0; ii<line_count; ii++) {
get_band_float_line(fpIn, metaIn, kk, ii, bufIn);
for (jj=0; jj<sample_count; jj++) {
// Taking the remapping of other radiometries out for the moment
//if (inRadiometry >= r_SIGMA && inRadiometry <= r_BETA_DB)
//bufIn[jj] = cal2amp(metaIn, incid, jj, bands[kk], bufIn[jj]);
if (strstr(bands[kk], "PHASE") == NULL) {
incid = meta_incid(metaIn, ii, jj);
cal_dn =
get_cal_dn(metaOut, incid, jj, bufIn[jj], bands[kk], dbFlag);
if (wh_scaleFlag) {
if (FLOAT_EQUIVALENT(cal_dn, metaIn->general->no_data))
bufOut[jj] = 0;
else
bufOut[jj] = (cal_dn + 31) / 0.15 + 1.5;
}
else
bufOut[jj] = cal_dn;
}
else // PHASE band, do nothing
bufOut[jj] = bufIn[jj];
}
put_band_float_line(fpOut, metaOut, kk, ii, bufOut);
asfLineMeter(ii, line_count);
}
if (kk==0)
sprintf(metaOut->general->bands, "%s-%s",
radiometry2str(outRadiometry), bands[kk]);
else {
char tmp[255];
sprintf(tmp, ",%s-%s", radiometry2str(outRadiometry), bands[kk]);
strcat(metaOut->general->bands, tmp);
}
}
}
meta_write(metaOut, outFile);
meta_free(metaIn);
meta_free(metaOut);
FREE(bufIn);
FREE(bufOut);
if (dualpol) {
FREE(bufIn2);
FREE(bufOut2);
FREE(bufOut3);
}
for (kk=0; kk<band_count; ++kk)
FREE(bands[kk]);
FREE(bands);
FCLOSE(fpIn);
FCLOSE(fpOut);
FREE(input);
FREE(output);
return FALSE;
}
