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; }