/* DebugWritePatch: Outputs the current patch trans array, and converts it to amplitude and phase. */ void debugWritePatch(const patch *p,char *basename) { FILE *fp; char name[1024],outname[1024]; meta_parameters *meta; int i; strcpy(outname,g.out); strcat(strcat(outname,"_"),basename); strcat(strcpy(name,outname),".img"); meta = meta_read(g.in1); meta->general->line_count = p->n_range; meta->general->sample_count = p->n_az; meta->general->data_type = COMPLEX_REAL32; meta->general->image_data_type = COMPLEX_IMAGE; meta_write(meta, name); fp = fopenImage(name,"wb"); for (i=0; i<p->n_range; ++i) put_complexFloat_line(fp, meta, i, p->trans+i*p->n_az); FCLOSE(fp); meta_free(meta); patchToRGBImage(outname, TRUE); }
END_TEST /* Test routine which writes new-style meta files. */ START_TEST(test_meta_read_write_new_format) { /* Get something to write. */ char in_file[512]; meta_parameters *meta; meta_parameters *meta_reread; /* For re-read structure. */ sprintf(in_file,"%s/test_file_new_style.meta",_TEST_DATA_DIR); meta = meta_read(in_file); meta_write(meta, "test_output/test_output_file.meta"); meta_reread = meta_read("test_output/test_output_file.meta"); /* Test a few random or not-so-random fields for equality. */ fail_unless(!strcmp(meta->general->sensor, meta_reread->general->sensor), "sensor elements from original and written-then-reread metadata structures don't match"); fail_unless(meta->projection->type == meta_reread->projection->type, "projection->type fields from original and written-then-reread metadata structures not equal"); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.atct.rlocal, meta_reread->projection ->param.atct.rlocal), "projection->param.atct.rlocal fields from original and written-then-reread metadata structures not equal"); if ( unlink("test_output/test_output_file.meta") == -1 ) { perror("failed to delete intra-test temporary file test_output_file.meta"); fail(""); } }
int main(int argc, char **argv) { char las_name[256]; char meta_name[256]; meta_parameters *meta; /* Parse command line */ currArg=1; if (argc-currArg < 2) {printf("Insufficient arguments.\n"); usage(argv[0]);} if (argc-currArg > 2) {printf("Excessive arguments.\n"); usage(argv[0]);} strcpy(las_name, argv[currArg]); strcpy(meta_name,argv[currArg+1]); /* Read .ddr & .meta file info & put into meta structures */ meta = meta_read(las_name); meta->general->image_data_type = IMAGE; /* write it out new style */ meta_write(meta, meta_name); /* Clean and report */ meta_free(meta); printf("***Wrote %s.meta from %s.ddr and %s.meta.\n", meta_name,las_name,las_name); return 0; }
void debugWritePatch_Line(int lineNo, complexFloat *line, char *basename, int n_range, int n_az) { FILE *fp; meta_parameters *meta; char outname[320],name[320]; char *mode; strcpy(outname,g.out); strcat(strcat(outname,"_"),basename); strcat(strcpy(name,outname),".img"); if (lineNo == 0) { meta = meta_read(g.in1); meta->general->line_count = n_range; meta->general->sample_count = n_az; meta->general->data_type = COMPLEX_REAL32; meta->general->image_data_type = COMPLEX_IMAGE; meta_write(meta, name); } else { meta = meta_read(name); } mode = lineNo == 0 ? "wb" : "ab"; fp = fopenImage(name,mode); put_complexFloat_line(fp, meta, lineNo, line); FCLOSE(fp); if (lineNo == meta->general->line_count - 1) patchToRGBImage(outname, TRUE); meta_free(meta); }
END_TEST START_TEST(test_ps) /* Polar Stereo */ { char error_string[256]; char in_file[512]; meta_parameters *meta; sprintf(in_file,"%s/new_style_ps.meta",_TEST_DATA_DIR); meta = meta_read(in_file); meta_write(meta,"test_output/out_ps.meta"); /* look at a couple fields real quick */ sprintf(error_string,"meta->sar->dopRangeQuad is %-16.11g, should be 0.0001246",meta->sar->range_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->range_doppler_coefficients[2],0.0001246),error_string); sprintf(error_string,"meta->sar->dopAzQuad is %-16.11g, should be 2e-07",meta->sar->azimuth_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->azimuth_doppler_coefficients[2],2e-07),error_string); /* look at the good stuff */ sprintf(error_string,"meta->projection->param.ps.slat is %-16.11g, should be 72.374152778",meta->projection->param.ps.slat); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.ps.slat,72.374152778),error_string); sprintf(error_string,"meta->geo->proj->param.ps.slat is %-16.11g, should be 72.374152778",meta->geo->proj->param.ps.slat); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.ps.slat,72.374152778),error_string); sprintf(error_string,"meta->projection->param.ps.slon is %-16.11g, should be -158.3591",meta->projection->param.ps.slon); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.ps.slon,-158.3591),error_string); sprintf(error_string,"meta->geo->proj->param.ps.slon is %-16.11g, should be -158.3591",meta->geo->proj->param.ps.slon); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.ps.slon,-158.3591),error_string); meta_free(meta); }
void floats_to_bytes_from_file_ext(const char *inFile, const char *outFile, char *band, float mask, scale_t scaling, float scale_factor) { FILE *fp; meta_parameters *meta; float *float_data; unsigned char *byte_data; int ii, band_number; long long pixel_count; long offset; meta = meta_read(inFile); band_number = (!band || strlen(band) == 0 || strcmp(band, "???")==0) ? 0 : get_band_number(meta->general->bands, meta->general->band_count, band); pixel_count = meta->general->line_count * meta->general->sample_count; offset = meta->general->line_count * band_number; float_data = (float *) MALLOC(sizeof(float) * pixel_count); fp = FOPEN(inFile, "rb"); get_float_lines(fp, meta, offset, meta->general->line_count, float_data); FCLOSE(fp); byte_data = floats_to_bytes_ext(float_data, pixel_count, mask, scaling, scale_factor); for (ii=0; ii<pixel_count; ii++) float_data[ii] = (float) byte_data[ii]; meta->general->data_type = ASF_BYTE; meta_write(meta, outFile); fp = FOPEN(outFile, "wb"); put_float_lines(fp, meta, offset, meta->general->line_count, float_data); FCLOSE(fp); FREE(float_data); FREE(byte_data); meta_free(meta); }
int main(int argc, char **argv) { char meta_name[255]; char envi_name[255]; meta_parameters *meta=NULL; envi_header *envi=NULL; extern int currArg; /* from cla.h in asf.h... initialized to 1 */ logflag = 0; if (argc > 1) { check_for_help(argc, argv); handle_license_and_version_args(argc, argv, TOOL_NAME); } if (argc < 3) { asfPrintStatus("\nNot enough arguments.\n"); usage(); return 1; } /* Parse command line args */ while (currArg < (argc-2)) { char *key=argv[currArg++]; if (strmatch(key,"-log")) { sprintf(logFile, "%s", argv[currArg]); logflag = 1; } else { printf("\n ***Invalid option: %s\n\n", argv[currArg-1]); usage(argv[0]); } } if ((argc-currArg) < 2) { printf("Insufficient arguments.\n"); usage(argv[0]); } create_name(envi_name, argv[currArg], ".hdr"); create_name(meta_name, argv[currArg+1], ".meta"); asfSplashScreen(argc, argv); // Read ENVI header envi = read_envi(envi_name); // Fill metadata structure with valid data meta = envi2meta(envi); // Write metadata file meta_write(meta, meta_name); // Clean and report meta_free(meta); asfPrintStatus(" Converted ENVI header (%s) to metadata file (%s)\n\n", envi_name, meta_name); return 0; }
int main(int argc, char *argv[]) { // Allocate some memory char *inFile = (char *) MALLOC(sizeof(char)*512); char *outFile = (char *) MALLOC(sizeof(char)*512); // Parse command line if (argc < 3) { printf("Insufficient arguments.\n"); usage(argv[0]); } strcpy(inFile, argv[1]); strcpy(outFile, argv[2]); int grid_line_count = atoi(argv[3]); asfSplashScreen (argc, argv); // Deal with metadata meta_parameters *metaIn = meta_read(inFile); meta_parameters *metaOut = meta_read(inFile); int nl = metaIn->general->line_count; int ns = metaIn->general->sample_count; metaOut->general->data_type = ASF_BYTE; meta_write(metaOut, outFile); // Replace image with grid float on_grid = 0.0; float off_grid = 255.0; float *outLine = (float *) MALLOC(sizeof(float)*ns); float *inLine = (float *) MALLOC(sizeof(float)*ns); FILE *fpIn = FOPEN(appendExt(inFile, ".img"), "rb"); FILE *fpOut = FOPEN(appendExt(outFile, ".img"), "wb"); int ii, kk;; for (ii=0; ii<nl; ii++) { get_float_line(fpIn, metaIn, ii, inLine); for (kk=0; kk<ns; kk++) { if (ii == 0 || ii == nl -1 || ii % (ns/grid_line_count) == 0) outLine[kk] = on_grid; else if (kk % (ns/grid_line_count) == 0) outLine[kk] = on_grid; else outLine[kk] = off_grid; } outLine[0] = outLine[ns-1] = on_grid; put_float_line(fpOut, metaOut, ii, outLine); asfLineMeter(ii, nl); } // Clean up FREE(inFile); FREE(outFile); meta_free(metaIn); meta_free(metaOut); exit(0); }
static void ingest_polarimetry_data(char *inFile, char *inBaseName, char *outFile, char band, int create) { FILE *fpIn, *fpOut; meta_parameters *meta = NULL; char tmp[10]; int ii, kk; float *power = NULL; char *byteBuf = NULL; fpIn = FOPEN(inFile, "rb"); append_ext_if_needed(outFile, ".img", NULL); if (create) fpOut = FOPEN(outFile, "wb"); else fpOut = FOPEN(outFile, "ab"); if (create) { meta = import_airsar_meta(inFile, inBaseName, TRUE); meta->general->data_type = REAL32; meta->general->band_count = 1; sprintf(meta->general->bands, "AMP-%c", band); meta->general->image_data_type = IMAGE_LAYER_STACK; } else { meta = meta_read(outFile); meta->general->band_count += 1; sprintf(tmp, ",AMP-%c", band); strcat(meta->general->bands, tmp); } power = (float *) MALLOC(sizeof(float)*meta->general->sample_count); byteBuf = (char *) MALLOC(sizeof(char)*10); airsar_header *header = read_airsar_header(inFile); long offset = header->first_data_offset; FSEEK(fpIn, offset, SEEK_SET); for (ii=0; ii<meta->general->line_count; ii++) { for (kk=0; kk<meta->general->sample_count; kk++) { FREAD(byteBuf, sizeof(char), 10, fpIn); power[kk] = sqrt(((float)byteBuf[1]/254.0 + 1.5) * pow(2, byteBuf[0])); } put_float_line(fpOut, meta, ii, power); asfLineMeter(ii, meta->general->line_count); } FCLOSE(fpIn); FCLOSE(fpOut); meta_write(meta, outFile); if (power) FREE(power); if (byteBuf) FREE(byteBuf); if (meta) meta_free(meta); }
int main (int argc, char *argv[]) { const char *const_str = "ThisStringIsUsedToTestWriteOfMetadata"; char *str; uint8_t size, type; struct bitio *bd; bd = bopen("metadata_test.dat", 'w'); if (bd == NULL) goto error; meta_write(bd, 1, (void*)const_str, strlen(const_str) + 1); meta_write(bd, 2, (void*)const_str, 2); meta_finalize(bd); bclose(bd); bd = bopen("metadata_test.dat", 'r'); if (bd == NULL) goto error; str = meta_read(bd, &type, &size); if (strcmp(str, const_str) != 0 || type != 1 || size != strlen(str) + 1) goto error; str = meta_read(bd, &type, &size); if (str[0] != const_str[0] || str[1] != const_str[1] || type != 2 || size != 2) goto error; bclose(bd); unlink("metadata_test.dat"); exit(EXIT_SUCCESS); error: bclose(bd); unlink("metadata_test.dat"); exit(EXIT_FAILURE); }
int dem_to_mask(char *inDemFile, char *outMaskFile, float cutoff) { meta_parameters *inDemMeta = meta_read(inDemFile); meta_parameters *outDemMeta = meta_read(inDemFile); // out metadata will differ from in only in the data type outDemMeta->general->data_type = ASF_BYTE; int x_size = inDemMeta->general->sample_count; int y_size = inDemMeta->general->line_count; float *maskbuffer = MALLOC(sizeof(float) * x_size); float *floatbuffer = MALLOC(sizeof(float) * x_size); FILE *in = fopenImage(inDemFile, "rb"); FILE *out = fopenImage(outMaskFile, "wb"); float mv = masked_value(); float umv = unmasked_value(); int y,x; for (y=0; y<y_size; y++) { get_float_line(in, inDemMeta, y, floatbuffer); for (x=0; x < x_size; x++) maskbuffer[x] = floatbuffer[x] <= cutoff ? mv : umv; put_float_line(out, outDemMeta, y, maskbuffer); asfLineMeter(y, y_size); } FCLOSE(in); FCLOSE(out); FREE(floatbuffer); FREE(maskbuffer); meta_write(outDemMeta, outMaskFile); meta_free(inDemMeta); meta_free(outDemMeta); asfPrintStatus("Created Mask file '%s' from DEM '%s'.\n", outMaskFile, inDemFile); return 0; }
int combine(char **infiles, int n_inputs, char *outfile) { int ret, ii, size_x, size_y; double start_x, start_y; double per_x, per_y; // Determine image parameters determine_extents(infiles, n_inputs, &size_x, &size_y, &start_x, &start_y, &per_x, &per_y); asfPrintStatus("\nCombined image size: %dx%d LxS\n", size_y, size_x); asfPrintStatus(" Start X,Y: %f,%f\n", start_x, start_y); asfPrintStatus(" Per X,Y: %lg,%lg\n", per_x, per_y); // float_image will handle cacheing of the large output image FloatImage *out = float_image_new(size_x, size_y); // loop over the input images, last to first, so that the files listed // first have their pixels overwrite files listed later on the command line for (ii=n_inputs-1; ii>=0; ii--) { asfPrintStatus("\nProcessing %s... \n", infiles[ii]); // Add this image's pixels add_pixels(out, infiles[ii], start_x, start_y, per_x, per_y); } asfPrintStatus("Writing metadata.\n"); meta_parameters *meta_out = meta_read(infiles[0]); meta_out->projection->startX = start_x; meta_out->projection->startY = start_y; meta_out->general->line_count = size_y; meta_out->general->sample_count = size_x; meta_write(meta_out, outfile); meta_free(meta_out); char *outfile_full = appendExt(outfile, ".img"); asfPrintStatus("Saving image (%s).\n", outfile_full); ret = float_image_store(out, outfile_full, fibo_be); if (ret!=0) asfPrintError("Error storing output image!\n"); float_image_free(out); free(outfile_full); return ret; }
void import_gridfloat(char *inBaseName, char *outBaseName) { int i, j; int column_count, row_count; char *flt_file = appendExt(inBaseName, ".flt"); // create the metadata char *meta_filename = appendExt(outBaseName, ".meta"); asfPrintStatus("Building %s ...\n", meta_filename); meta_parameters *meta = read_meta_gridfloat_ext(inBaseName, flt_file, &column_count, &row_count); meta_write(meta, meta_filename); // Now read/write the actual data. Read as INT16, cast to // floats so we can use put_float_line (which will write // INT16 data, since we asked for it in the metadata) char *data_filename = appendExt(outBaseName, ".img"); asfPrintStatus("Reading %s, writing %s ...\n", flt_file, data_filename); float *floats = MALLOC(sizeof(float)*column_count); FILE *fp = FOPEN(flt_file, "rb"); FILE *out = FOPEN(data_filename, "wb"); for (i=0; i<row_count; ++i) { FREAD(floats, sizeof(float), column_count, fp); //if (msbfirst) { for (j=0; j<column_count; ++j) { big32(floats[j]); } //} put_float_line(out, meta, i, floats); asfLineMeter(i,row_count); } fclose(fp); fclose(out); free(data_filename); free(floats); free(flt_file); }
int main (int argc, char **argv) { char ceosName[256]; char metaName[256]; meta_parameters *meta; /* Parse command line */ if (argc-currArg < 2) {printf("Insufficient arguments.\n"); usage(argv[0]);} if (argc-currArg > 2) {printf("Excessive arguments.\n"); usage(argv[0]);} strcpy(ceosName,argv[currArg]); strcpy(metaName,argv[currArg+1]); meta = meta_create(ceosName); meta_write(meta,metaName); meta_free(meta); exit(EXIT_SUCCESS); }
END_TEST /******************************************************** * Test all possible projections */ START_TEST(test_atct) /* along track cross track */ { char error_string[256]; char in_file[512]; meta_parameters *meta; sprintf(in_file,"%s/new_style_atct.meta",_TEST_DATA_DIR); meta = meta_read(in_file); meta_write(meta,"test_output/out_atct.meta"); /* look at a couple fields real quick */ sprintf(error_string,"meta->sar->dopRangeQuad is %-16.11g, should be 0.0001246",meta->sar->range_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->range_doppler_coefficients[2],0.0001246),error_string); sprintf(error_string,"meta->sar->dopAzQuad is %-16.11g, should be 2e-07",meta->sar->azimuth_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->azimuth_doppler_coefficients[2],2e-07),error_string); /* look at the good stuff */ sprintf(error_string,"meta->projection->param.atct.rlocal is %-16.11g, should be 6000000.0",meta->projection->param.atct.rlocal); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.atct.rlocal,6000000.0),error_string); sprintf(error_string,"meta->geo->proj->param.atct.rlocal is %-16.11g, should be 6000000.0",meta->geo->proj->param.atct.rlocal); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.atct.rlocal,6000000.0),error_string); sprintf(error_string,"meta->projection->param.atct.alpha1 is %-16.11g, should be 0.6",meta->projection->param.atct.alpha1); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.atct.alpha1,0.6),error_string); sprintf(error_string,"meta->geo->proj->param.atct.alpha1 is %-16.11g, should be 0.6",meta->geo->proj->param.atct.alpha1); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.atct.alpha1,0.6),error_string); sprintf(error_string,"meta->projection->param.atct.alpha2 is %-16.11g, should be -0.44",meta->projection->param.atct.alpha2); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.atct.alpha2,-0.44),error_string); sprintf(error_string,"meta->geo->proj->param.atct.alpha2 is %-16.11g, should be -0.44",meta->geo->proj->param.atct.alpha2); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.atct.alpha2,-0.44),error_string); sprintf(error_string,"meta->projection->param.atct.alpha3 is %-16.11g, should be 0.6",meta->projection->param.atct.alpha3); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.atct.alpha3,0.6),error_string); sprintf(error_string,"meta->geo->proj->param.atct.alpha3 is %-16.11g, should be 0.6",meta->geo->proj->param.atct.alpha3); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.atct.alpha3,0.6),error_string); meta_free(meta); }
END_TEST START_TEST(test_utm) /* universal transverse mercator */ { char error_string[256]; char in_file[512]; meta_parameters *meta; sprintf(in_file,"%s/new_style_utm.meta",_TEST_DATA_DIR); meta = meta_read(in_file); meta_write(meta,"test_output/out_utm.meta"); /* look at a couple fields real quick */ sprintf(error_string,"meta->sar->dopRangeQuad is %-16.11g, should be 0.0001246",meta->sar->range_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->range_doppler_coefficients[2],0.0001246),error_string); sprintf(error_string,"meta->sar->dopAzQuad is %-16.11g, should be 2e-07",meta->sar->azimuth_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->azimuth_doppler_coefficients[2],2e-07),error_string); /* look at the good stuff */ sprintf(error_string,"meta->projection->param.utm.zone is %d, should be 6",meta->projection->param.utm.zone); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.utm.zone,6),error_string); sprintf(error_string,"meta->geo->proj->param.utm.zone is %d, should be 6",meta->geo->proj->param.utm.zone); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.utm.zone,6),error_string); meta_free(meta); }
END_TEST START_TEST(test_lamcc) /* Lambert conformal conic */ { char error_string[256]; char in_file[512]; meta_parameters *meta; sprintf(in_file,"%s/new_style_lamcc.meta",_TEST_DATA_DIR); meta = meta_read(in_file); meta_write(meta,"test_output/out_lamcc.meta"); /* look at a couple fields real quick */ sprintf(error_string,"meta->sar->dopRangeQuad is %-16.11g, should be 0.0001246",meta->sar->range_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->range_doppler_coefficients[2],0.0001246),error_string); sprintf(error_string,"meta->sar->dopAzQuad is %-16.11g, should be 2e-07",meta->sar->azimuth_doppler_coefficients[2]); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->sar->azimuth_doppler_coefficients[2],0.0000002),error_string); /* look at the good stuff */ sprintf(error_string,"meta->projection->param.lamcc.plat1 is %-16.11g, should be 73.123",meta->projection->param.lamcc.plat1); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.lamcc.plat1,73.123),error_string); sprintf(error_string,"meta->geo->proj->param.lamcc.plat1 is %-16.11g, should be 73.123",meta->geo->proj->param.lamcc.plat1); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.lamcc.plat1,73.123),error_string); sprintf(error_string,"meta->projection->param.lamcc.plat2 is %-16.11g, should be 71.123",meta->projection->param.lamcc.plat2); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.lamcc.plat2,71.123),error_string); sprintf(error_string,"meta->geo->proj->param.lamcc.plat2 is %-16.11g, should be 71.123",meta->geo->proj->param.lamcc.plat2); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.lamcc.plat2,71.123),error_string); sprintf(error_string,"meta->projection->param.lamcc.lat0 is %-16.11g, should be 72.123",meta->projection->param.lamcc.lat0); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.lamcc.lat0,72.123),error_string); sprintf(error_string,"meta->geo->proj->param.lamcc.lat0 is %-16.11g, should be 72.123",meta->geo->proj->param.lamcc.lat0); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.lamcc.lat0,72.123),error_string); sprintf(error_string,"meta->projection->param.lamcc.lon0 is %f; should be -158.123",meta->projection->param.lamcc.lon0); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->projection->param.lamcc.lon0,-158.123),error_string); sprintf(error_string,"meta->geo->proj->param.lamcc.lon0 is %f; should be -158.123",meta->geo->proj->param.lamcc.lon0); fail_unless(UNIT_TESTS_FLOAT_COMPARE(meta->geo->proj->param.lamcc.lon0,-158.123),error_string); meta_free(meta); }
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 main(int argc, char *argv[]) { char *baseFile; meta_parameters *meta; baseline base; int wid, len, /* Width and Length of input scene */ ss, sl; /* Offsets of input scene in original */ int x,y; double xScale,yScale; float percent=5.0; FILE *fin, *fout; char szInPhase[255], szInAmp[255], szOutPhase[255], szOutAmp[255]; float *data; double *sflat,*cflat; double derampDirection=1.0;/*1.0=forward deramping. -1.0=backward deramping.*/ logflag=0; /* process command line args */ currArg=1; /* from cla.h in asf.h */ /* optional args */ while (currArg < (argc-3)) { char *key = argv[currArg++]; if (strmatch(key,"-log")) { CHECK_ARG(1); strcpy(logFile,GET_ARG(1)); fLog = FOPEN(logFile, "a"); logflag=1; } else if (strmatch(key,"-backward")) { derampDirection = -1.0; } else {printf("**Invalid option: %s\n",argv[currArg-1]); usage(argv[0]);} } if ((argc-currArg) < 3) {printf("Insufficient arguments.\n"); usage(argv[0]);} /* required args */ create_name(szInAmp, argv[currArg], "_amp.img"); create_name(szInPhase, argv[currArg], "_phase.img"); baseFile = argv[currArg+1]; asfSplashScreen(argc, argv); /* Get input scene size and windowing info, check validity */ meta = meta_read(szInPhase); wid = meta->general->sample_count; len = meta->general->line_count; ss = meta->general->start_sample - 1; sl = meta->general->start_line - 1; xScale = meta->sar->sample_increment; yScale = meta->sar->line_increment; create_name(szOutAmp,argv[currArg+2],"_amp.img"); meta_write(meta, szOutAmp); create_name(szOutPhase,argv[currArg+2],"_phase.img"); meta_write(meta, szOutPhase); /*Link over ".amp" file, if it exists.*/ if (fileExists(szInAmp)&&!fileExists(szOutAmp)) { char command[1024]; sprintf(command,"ln -s %s %s\n", szInAmp, szOutAmp); system(command); } /* buffer mallocs, read data file */ data = (float *)MALLOC(sizeof(float)*wid); sflat = (double *)MALLOC(sizeof(double)*wid); cflat = (double *)MALLOC(sizeof(double)*wid); fin = fopenImage(szInPhase,"rb"); fout = fopenImage(szOutPhase,"wb"); /* read in CEOS parameters & convert to meters */ base=read_baseline(baseFile); /* calculate slant ranges and look angles - Ian's thesis eqn 3.10 */ for (x = 0; x < wid; x++) { double flat=meta_flat(meta,0.0,x*xScale+ss); sflat[x]=sin(flat); cflat[x]=cos(flat); } /* Deramp 'data' array */ /* printf("\n starting in-place deramp of input data \n\n");*/ for (y = 0; y < len; y++) { double Bn_y,Bp_y; double twok=derampDirection*2.0*meta_get_k(meta); meta_interp_baseline(meta,base,y*(int)yScale+sl,&Bn_y,&Bp_y); /* read in the next row of data */ get_float_line(fin, meta, y, data); /* calculate flat-earth range phase term & remove it */ for (x = 0; x < wid; x++) { double d=data[x]; if (d!=0.0) /*Ignore points which didn't phase unwrap.*/ d -= twok*(Bp_y*cflat[x]-Bn_y*sflat[x]); /*Was: d-=ceos_flat_phase(ceos,base,x,y);*/ data[x]=d; } /* write out this row of data */ put_float_line(fout, meta, y, data); if (y*100/len==percent) { printf(" Completed %3.0f percent\n", percent); percent+=5.0; } } /* printf("\nDone with deramp\n\n");*/ /* save and scram */ FCLOSE(fin); FCLOSE(fout); FREE(data); FREE(sflat);FREE(cflat); printf(" Completed 100 percent\n\n"); if (logflag) { sprintf(logbuf, " Wrote %lld bytes of data\n\n", (long long)(len*wid*4)); printLog(logbuf); } return 0; }
static int save_as_asf(ImageInfo *ii, const char *out_file, int what_to_save, int strict_boundary, int load) { // See if we can open the output file up front FILE *outFp = fopen(out_file, "wb"); if (!outFp) { // failed to open the output file! char errbuf[1024]; snprintf(errbuf, 1024, "Failed to open %s: %s", out_file, strerror(errno)); message_box(errbuf); strcat(errbuf, "\n"); printf("%s", errbuf); return FALSE; // failure } assert (g_poly->n > 0); assert (crosshair_line > 0 && crosshair_samp > 0); meta_parameters *meta = ii->meta; // figure out where to chop int line_min, line_max, samp_min, samp_max, nl, ns; compute_extent(meta, &line_min, &line_max, &samp_min, &samp_max, &nl, &ns); // generate metadata char *out_metaname = appendExt(out_file, ".meta"); printf("Generating %s...\n", out_metaname); // data will be saved as floating point, except scaled pixel values, // which we can make bytes. data_type_t data_type = REAL32; if (what_to_save == SCALED_PIXEL_VALUE) data_type = ASF_BYTE; meta_parameters *out_meta = build_metadata(meta, out_file, nl, ns, line_min, samp_min, data_type, what_to_save); // put_float_line() will always dump BYTE data if the optical block // is present... we want to be in control of the data type, so we must // wipe out this block if (out_meta->optical) { FREE(out_meta->optical); out_meta->optical=NULL; } if (what_to_save == LAT_LON_2_BAND) { out_meta->general->band_count = 2; strcpy(out_meta->general->bands, "LAT,LON"); } // define clipping region, if necessary double xp[MAX_POLY_LEN+2], yp[MAX_POLY_LEN+2]; int i,j,n=0; if (strict_boundary) define_clipping_region(meta, &n, xp, yp); float ndv = 0; if (meta_is_valid_double(out_meta->general->no_data)) ndv = out_meta->general->no_data; else if (strict_boundary) // need to set a no data value in this case out_meta->general->no_data = 0.; meta_write(out_meta, out_metaname); // now actually write the data printf("Generating %s...\n", out_file); if (what_to_save == LAT_LON_2_BAND) { // dump a 2-band image, lat & lon data float *lats = MALLOC(sizeof(float)*ns); float *lons = MALLOC(sizeof(float)*ns); for (i=0; i<nl; ++i) { int l = line_min+i; for (j=0; j<ns; ++j) { int s = samp_min+j; if (!strict_boundary || pnpoly(n, xp, yp, s, l)) { double lat, lon; meta_get_latLon(meta, l, s, 0, &lat, &lon); lats[j] = (float)lat; lons[j] = (float)lon; } else { lats[j] = ndv; lons[j] = ndv; } } put_band_float_line(outFp, out_meta, 0, i, lats); put_band_float_line(outFp, out_meta, 1, i, lons); asfLineMeter(i,nl); } free(lats); free(lons); } else { // normal case float *buf = MALLOC(sizeof(float)*ns); for (i=0; i<nl; ++i) { int l = line_min+i; for (j=0; j<ns; ++j) { int s = samp_min+j; float val; if (!strict_boundary || pnpoly(n, xp, yp, s, l)) { val = get_data(ii, what_to_save, l, s); } else { val = ndv; } buf[j] = val; } put_float_line(outFp, out_meta, i, buf); asfLineMeter(i,nl); } free(buf); } fclose(outFp); meta_free(out_meta); // load the generated file if we were told to if (load) load_file(out_file); return TRUE; }
int main(int argc, char *argv[]) { int extentFlag = FALSE, multiband = FALSE; char *extent = (char *) MALLOC(sizeof(char)*1024); char *outfile = (char *) MALLOC(sizeof(char)*1024); handle_common_asf_args(&argc, &argv, ASF_NAME_STRING); if (argc>1 && (strcmp(argv[1], "-help")==0 || strcmp(argv[1],"--help")==0)) help(); if (argc<3) usage(); double background_val=0; extract_double_options(&argc, &argv, &background_val, "-background", "--background", "-b", NULL); if (extract_string_options(&argc, &argv, extent, "-extent", "--extent", NULL)) extentFlag = TRUE; if (extract_string_options(&argc, &argv, outfile, "-output", "--output", NULL)) multiband = TRUE; char *infile = argv[1]; int i, size_x, size_y, n_inputs=0, start=0, n_bands; double start_x, start_y; double per_x, per_y; asfSplashScreen(argc, argv); char *line = (char *) MALLOC(sizeof(char)*512); FILE *fpList = FOPEN(infile, "r"); while (fgets(line, 512, fpList)) if (strlen(line) > 0) n_inputs++; FCLOSE(fpList); if (extentFlag) { n_inputs++; start = 1; } char **infiles = (char **) MALLOC(sizeof(char *)*n_inputs); if (extentFlag) { infiles[0] = (char *) MALLOC(sizeof(char)*512); strcpy(infiles[0], extent); } fpList = FOPEN(infile, "r"); for (i=start; i<n_inputs; i++) { fgets(line, 512, fpList); chomp(line); infiles[i] = (char *) MALLOC(sizeof(char)*512); strcpy(infiles[i], line); } FCLOSE(fpList); FREE(line); if (multiband) asfPrintStatus("Stacking %d files to produce: %s\n", n_inputs, outfile); else asfPrintStatus("Putting %d files in image stack\n", n_inputs); asfPrintStatus("Input files:\n"); for (i=start; i<n_inputs; ++i) asfPrintStatus(" %d: %s%s\n", i+1, infiles[i], i==0 ? " (reference)" : ""); determine_extents(infiles, n_inputs, &size_x, &size_y, &n_bands, &start_x, &start_y, &per_x, &per_y, extentFlag); asfPrintStatus("\nStacked image size: %dx%d LxS\n", size_y, size_x); asfPrintStatus(" Start X,Y: %f,%f\n", start_x, start_y); asfPrintStatus(" Per X,Y: %.2f,%.2f\n", per_x, per_y); meta_parameters *meta_out = meta_read(infiles[0]); if (multiband) meta_out->general->image_data_type = IMAGE_LAYER_STACK; meta_out->projection->startX = start_x; meta_out->projection->startY = start_y; meta_out->general->line_count = size_y; meta_out->general->sample_count = size_x; meta_out->general->no_data = background_val; update_location_block(meta_out); //char *outfile_full = appendExt(outfile, ".img"); char *outfile_full = (char *) MALLOC(sizeof(char)*1024); if (multiband) { sprintf(outfile_full, "%s.img", stripExt(outfile)); meta_write(meta_out, outfile_full); } for (i=start; i<n_inputs; i++) { asfPrintStatus("\nProcessing band %d (%s) ... \n", i, infiles[i]); if (!multiband) { sprintf(outfile_full, "%s_stack.img", stripExt(infiles[i])); meta_write(meta_out, outfile_full); } add_to_stack(outfile_full, i, infiles[i], size_x, size_y, start_x, start_y, per_x, per_y, multiband); } meta_free(meta_out); FREE(outfile_full); for (i=0; i<n_inputs; i++) FREE(infiles[i]); FREE(infiles); FREE(extent); FREE(outfile); asfPrintStatus("Done.\n"); return 0; }
static void add_to_stack(char *out, int band, char *file, int size_x, int size_y, double start_x, double start_y, double per_x, double per_y, int multiband) { meta_parameters *metaIn = meta_read(file); meta_parameters *metaOut = meta_read(out); char *base = (char *) MALLOC(sizeof(char)*512); int start_line, start_sample; // this should work even if per_x / per_y are negative... start_sample = (int) ((start_x - metaIn->projection->startX) / per_x + .5); start_line = (int) ((start_y - metaIn->projection->startY) / per_y + .5); int ns = metaIn->general->sample_count; int nl = metaIn->general->line_count; asfPrintStatus(" Location in stacked image is S:%d-%d, L:%d-%d\n", start_sample, start_sample + size_x, start_line, start_line + size_y); if (start_sample + size_x > ns || start_line + size_y > nl) { asfPrintError("Image extents were not calculated correctly!\n"); } FILE *fpIn = FOPEN(file, "rb"); FILE *fpOut; char *metaFile = appendExt(out, ".meta"); if (band > 0 || !multiband) { fpOut = FOPEN(out, "ab"); sprintf(base, ",%s", get_basename(file)); strcat(metaOut->general->bands, base); } else { fpOut = FOPEN(out, "wb"); sprintf(base, "%s", get_basename(file)); strcpy(metaOut->general->bands, base); } if (multiband) metaOut->general->band_count = band + 1; else metaOut->general->band_count = 1; meta_write(metaOut, metaFile); float *line = MALLOC(sizeof(float)*size_x); int y; for (y=start_line; y<start_line+size_y; ++y) { get_partial_float_line(fpIn, metaIn, y, start_sample, size_x, line); if (multiband) put_band_float_line(fpOut, metaOut, band, y-start_line, line); else put_float_line(fpOut, metaOut, y-start_line, line); asfLineMeter(y, start_line+size_y); } FCLOSE(fpIn); FCLOSE(fpOut); FREE(line); FREE(metaFile); FREE(base); meta_free(metaIn); meta_free(metaOut); }
int update_state_vectors(char *outBaseName, char *file) { int ret = FALSE; char *odrFile = NULL; meta_parameters *meta = meta_read(outBaseName); const char *sensor = meta->general->sensor; if (strcmp_case(sensor, "E1") == 0 || strcmp_case(sensor, "ERS1") == 0) { sensor = "ERS-1"; } if (strcmp_case(sensor, "E2") == 0 || strcmp_case(sensor, "ERS2") == 0) { sensor = "ERS-2"; } if (strcmp_case(sensor, "ERS-1") != 0 && strcmp_case(sensor, "ERS-2") != 0) { // not ERS data meta_free(meta); return ret; } asfPrintStatus("\nChecking for %s precision state vectors...\n", sensor); if (!file || strlen(file) == 0) { file = get_arclist_from_settings(sensor); } if (!file || strlen(file) == 0) { return ret; } if (is_dir(file)) { char *arclist = MALLOC(sizeof(char)*(strlen(file) + 128)); if (file[strlen(file)-1] == DIR_SEPARATOR) sprintf(arclist, "%sarclist", file); else sprintf(arclist, "%s%carclist", file, DIR_SEPARATOR); if (isArcList(sensor, arclist)) odrFile = findInArcList(meta->general->acquisition_date, arclist); else asfPrintError("No arclist file found in %s\n", file); FREE(arclist); } else if (isArcList(sensor, file)) odrFile = findInArcList(meta->general->acquisition_date, file); else if (!fileExists(file)) asfPrintError("Not found: %s\n", file); else // assume file is just a regular ODR file odrFile = STRDUP(file); if (!odrFile || !fileExists(odrFile)) asfPrintError("Precision state vector file (%s) does not exist!\n", odrFile ? odrFile : "null"); asfPrintStatus("Refining %s orbits using ODR file: %s\n", sensor, odrFile); FILE *fpIn = FOPEN(odrFile, "rb"); // Check for new version of ODR file: xODR char spec[5]; FREAD(&spec, 1, 4, fpIn); spec[4] = '\0'; if (strcmp_case(spec, "xODR") != 0) asfPrintError("Unsupported precision state vector file (%s) type\n", odrFile); // Determine image center time for reference julian_date jd; jd.year = meta->state_vectors->year; jd.jd = meta->state_vectors->julDay; double ref_secs = meta->state_vectors->second; double ref_time = date2seconds(&jd, ref_secs); int stVec_count = meta->state_vectors->vector_count; ref_time += meta->state_vectors->vecs[stVec_count/2].time; // Initialize structure for updated state vector structure meta_state_vectors *prcVec = meta_state_vectors_init(9); int year = meta->state_vectors->year; prcVec->year = year; int julDay = meta->state_vectors->julDay; prcVec->julDay = julDay; double second = meta->state_vectors->second; prcVec->second = second; prcVec->vector_count = 9; // Read header information char satellite[9]; int begin, repeat_cycle, arc, nRecords, version; FREAD(&satellite, 1, 8, fpIn); satellite[8] = '\0'; FREAD(&begin, 1, 4, fpIn); ieee_big32(begin); FREAD(&repeat_cycle, 1, 4, fpIn); ieee_big32(repeat_cycle); FREAD(&arc, 1, 4, fpIn); ieee_big32(arc); FREAD(&nRecords, 1, 4, fpIn); ieee_big32(nRecords); FREAD(&version, 1, 4, fpIn); ieee_big32(version); // Read state vectors doris_prc_polar *stVec = (doris_prc_polar *) MALLOC(sizeof(doris_prc_polar)*nRecords); int ii, kk, closest = 0, time, nLat, nLon, nHeight; double diff = DAY2SEC*100; for (ii=0; ii<nRecords; ii++) { FREAD(&time, 1, 4, fpIn); ieee_big32(time); FREAD(&nLat, 1, 4, fpIn); ieee_big32(nLat); FREAD(&nLon, 1, 4, fpIn); ieee_big32(nLon); FREAD(&nHeight, 1, 4, fpIn); ieee_big32(nHeight); stVec[ii].time = time; stVec[ii].lat = (double)nLat/10000000.0; stVec[ii].lon = (double)nLon/10000000.0; stVec[ii].height = (double)nHeight/1000.0; if (fabs((double)time - ref_time) < diff) { closest = ii; diff = fabs(time - ref_time); } } FCLOSE(fpIn); if (closest > 0) { asfPrintStatus("Updating orbit information with precision state vectors.\n\n"); ret = TRUE; // Generating state vectors in earth-fixed coordinates doris_prc_polar polarVec; doris_prc_cartesian cartVec, velOne, velTwo; ref_time = date2seconds(&jd, ref_secs); for (ii=closest-4; ii<=closest+4; ii++) { geocentric_latlon(stVec[ii], &polarVec); polar2cartesian(polarVec, &cartVec); // Approximate state vector velocity according to getorb FAQs // (http://www.deos.tudelft.nl/ers/precorbs/faq.shtml#004001): // XYZvel(t) = XYZpos(t + 0.5sec) - XYZpos(t - 0.5sec) // Approximating velocities is fine since we will use an interpolation // scheme later that does not require these. interpolate_prc_vectors(stVec, cartVec.time-0.5, closest-4, closest+4, &velOne); interpolate_prc_vectors(stVec, cartVec.time+0.5, closest-4, closest+4, &velTwo); // Fill in the orbit information into metadata state vector structure kk = ii - closest + 4; prcVec->vecs[kk].time = cartVec.time - ref_time; prcVec->vecs[kk].vec.pos.x = cartVec.x; prcVec->vecs[kk].vec.pos.y = cartVec.y; prcVec->vecs[kk].vec.pos.z = cartVec.z; prcVec->vecs[kk].vec.vel.x = velTwo.x - velOne.x; prcVec->vecs[kk].vec.vel.y = velTwo.y - velOne.y; prcVec->vecs[kk].vec.vel.z = velTwo.z - velOne.z; } FREE(meta->state_vectors); meta->state_vectors = prcVec; meta_write(meta, outBaseName); meta_free(meta); FREE(stVec); } else asfPrintStatus("\nCould not update orbit information with precision state" " vectors\nOrbit information not available in orbit file " "(%s).\n\n", odrFile); return ret; }
void deskew(const char *infile, const char *outfile) { meta_parameters *meta = meta_read(infile); int nl = meta->general->line_count; int np = meta->general->sample_count; int nb = meta->general->band_count; char **band_name = extract_band_names(meta->general->bands, nb); int band, line, samp, deskewed = meta->sar->deskewed != 0; if (!meta->sar) asfPrintError("Cannot deskew data without a sar block!\n"); char *tmp_outfile; int do_rename = FALSE; if (strcmp(infile, outfile) == 0 && nb>1) { // user wants to deskew in-place // we can't actually do that on multi-band data, too much to keep in memory // use a temporary file, then clobber input file tmp_outfile = appendToBasename(outfile, "_tmp"); do_rename = TRUE; } else { // normal case: either // 1) single-band in-place deskew // 2) not in-place deskew (single or multi) tmp_outfile = STRDUP(outfile); } // calculate the amount of shift necessary double fac = calc_shift(meta, 0, 0); // Not sure if we need this or not... //fac *= meta->general->x_pixel_size / meta->general->y_pixel_size; // the "lower" array stores the required shifts, indexed by column // (the amount of shift is row-independent) int *lower = MALLOC(np * sizeof(int)); for (samp=0; samp<np; ++samp) lower[samp] = (int) floor(fac*(double)samp); if (meta->sar->deskewed) { asfPrintStatus("Data is already deskewed.\n"); } else { asfPrintStatus("Far-range shift amount: "); if (lower[np-1] > 0) asfPrintStatus("%d pixels down.\n", lower[np-1]); else asfPrintStatus("%d pixels up.\n", -lower[np-1]); } float *ibuf = MALLOC(np * sizeof(float)); float *obuf = CALLOC(np*nl, sizeof(float)); FILE *fpi = fopenImage(infile, "rb"); for (band=0; band<nb; ++band) { if (nb>1) asfPrintStatus("Deskewing band: %s\n", band_name[band]); // apply deskewing to this band for (line=0; line<nl; ++line) { get_float_line(fpi, meta, line + nl*band, ibuf); for (samp=0; samp<np; ++samp) { int out_line = deskewed ? line : line + lower[samp]; if (out_line >= 0 && out_line < nl) obuf[out_line*np+samp] = ibuf[samp]; } asfLineMeter(line,nl); } // write out this band FILE *fpo = fopenImage(tmp_outfile, band>0 ? "ab" : "wb"); put_float_lines(fpo, meta, band*nl, nl, obuf); FCLOSE(fpo); } FCLOSE(fpi); FREE(obuf); FREE(ibuf); FREE(lower); // if we output to a temporary file, clobber the input if (do_rename) { char *tmp_outfile_img = appendExt(tmp_outfile, ".img"); char *outfile_img = appendExt(outfile, ".img"); //printf("Renaming: %s -> %s\n", tmp_outfile_img, outfile_img); rename(tmp_outfile_img, outfile_img); FREE(tmp_outfile_img); FREE(outfile_img); } FREE(tmp_outfile); // only need to update the deskewed flag in the metadata meta->sar->deskewed = 1; meta_write(meta, outfile); meta_free(meta); }
int main(int argc,char *argv[]) { char infile1[256], infile2[256], infile3[256]; // Input file name char outfile[256]; // Output file name char tmpPath[1024]; browse_type_t mode = NOTYPE; int i,j; int sample_count; double scale; extern int currArg; strcpy(tmpPath, ""); // Parse command line if ((argc-currArg)<1) { printf("Insufficient arguments.\n"); usage(""); } while (currArg < (argc-2)) { char *key = argv[currArg++]; if (strmatches(key, "-sentinel", "--sentinel", NULL)) { CHECK_ARG(1); scale = atof(GET_ARG(1)); mode = SENTINEL_DUAL; } else if (strmatches(key, "-tmpDir", "--tmpDir", NULL)) { CHECK_ARG(1); strcpy(tmpPath, GET_ARG(1)); } else if (strmatches(key, "-log", "--log", NULL)) { CHECK_ARG(1); strcpy(logFile,GET_ARG(1)); fLog = FOPEN(logFile, "a"); logflag = TRUE; } else if (strmatches(key, "-quiet", "--quiet", "-q", NULL)) quietflag = TRUE; else { --currArg; break; } } if ((argc-currArg) < 2) { printf("Insufficient arguments.\n"); usage(argv[0]); } if (mode == NOTYPE && argc == 4) mode = PALSAR_FBD; else if (mode == NOTYPE && argc == 5) mode = PALSAR_PLR; if (!quietflag) asfSplashScreen(argc, argv); if (mode == PALSAR_FBD) { asfPrintStatus("Creating colorized browse image from PALSAR FBD data\n"); create_name(infile1,argv[1],".img"); create_name(infile2,argv[2],".img"); create_name(outfile,argv[3],".img"); meta_parameters *meta1 = meta_read(infile1); meta_parameters *meta2 = meta_read(infile2); if (meta1->general->line_count != meta2->general->line_count || meta1->general->sample_count != meta2->general->sample_count) { asfPrintError("Images must be the same size!!!\n"); exit(1); } strcpy(meta1->general->bands,"HH"); strcpy(meta2->general->bands,"HV"); int pixel_count = meta1->general->line_count*meta1->general->sample_count; float *buf1 = MALLOC(pixel_count * sizeof(float)); float *buf2 = MALLOC(pixel_count * sizeof(float)); float *buf3 = MALLOC(pixel_count * sizeof(float)); unsigned char *cbuf1, *cbuf2, *cbuf3; FILE *fp1 = FOPEN(infile1, "r"); FILE *fp2 = FOPEN(infile2, "r"); FILE *ofp = FOPEN(outfile, "w"); char ofile1[256]; char ofile2[256]; strcpy(ofile1,argv[1]); strcat(ofile1,"_DB.img"); strcpy(ofile2,argv[2]); strcat(ofile2,"_DB.img"); printf("Creating output DB files %s and %s\n",ofile1,ofile2); FILE *ofp1 = FOPEN(ofile1, "w"); FILE *ofp2 = FOPEN(ofile2, "w"); get_float_lines(fp1,meta1,0,meta1->general->line_count, buf1); get_float_lines(fp2,meta2,0,meta2->general->line_count, buf2); /* Convert data from sigma0 to dB */ sample_count = 0; for (i=0; i<meta1->general->line_count; ++i) { for (j=0; j<meta1->general->sample_count; ++j) { if (meta_is_valid_double(buf1[sample_count])) { if (buf1[sample_count] != 0) buf1[sample_count] = 10.0 * log10f(buf1[sample_count]); if (buf2[sample_count] != 0) buf2[sample_count] = 10.0 * log10f(buf2[sample_count]); } sample_count++; } } put_float_lines(ofp1, meta1, 0,meta1->general->line_count,buf1); put_float_lines(ofp2, meta2, 0,meta1->general->line_count,buf2); meta_write(meta1, ofile1); meta_write(meta2, ofile2); fclose(fp1); fclose(fp2); fclose(ofp1); fclose(ofp2); /* Scale the data to a byte range using given min/max values */ cbuf1 = my_floats_to_bytes(buf1,(long long) pixel_count, 0.0,MINMAX,-30.0,-1.0); cbuf2 = my_floats_to_bytes(buf2,(long long) pixel_count, 0.0,MINMAX,-30.0,-10.0); /* cbuf1 = my_floats_to_bytes(buf1,(long long) pixel_count, 0.0,MINMAX,-31.0,7.1); cbuf2 = my_floats_to_bytes(buf2,(long long) pixel_count, 0.0,MINMAX,-31.0,7.1); */ strcpy(ofile1,argv[1]); strcat(ofile1,"_byte.img"); strcpy(ofile2,argv[2]); strcat(ofile2,"_byte.img"); printf("Creating output byte files %s and %s\n",ofile1,ofile2); ofp1 = FOPEN(ofile1, "w"); ofp2 = FOPEN(ofile2, "w"); meta1->general->data_type=REAL32; meta2->general->data_type=REAL32; sample_count = 0; for (i=0; i<meta1->general->line_count; ++i) { for (j=0; j<meta1->general->sample_count; ++j) { buf1[sample_count] = (float) cbuf1[sample_count]; buf2[sample_count] = (float) cbuf2[sample_count]; sample_count++; } } put_float_lines(ofp1,meta1,0,meta1->general->line_count,buf1); put_float_lines(ofp2,meta2,0,meta2->general->line_count,buf2); meta_write(meta1, ofile1); meta_write(meta2, ofile2); fclose(ofp1); fclose(ofp2); /* Create the third band for the color image */ sample_count = 0; for (i=0; i<meta1->general->line_count; ++i) { for (j=0; j<meta1->general->sample_count; ++j) { if (buf2[sample_count] != 0) { /* buf3[sample_count] = (buf1[sample_count] / buf2[sample_count]); */ buf3[sample_count] = (buf1[sample_count] - buf2[sample_count]); if (buf3[sample_count] < 1) buf3[sample_count] = 1; else if (buf3[sample_count] > 255) buf3[sample_count] = 255; } else buf3[sample_count] = 0; sample_count++; } } cbuf3 = my_floats_to_bytes(buf3,(long long) pixel_count, 0.0,SIGMA ,-25.0,-10.0); sample_count = 0; for (i=0; i<meta1->general->line_count; ++i) { for (j=0; j<meta1->general->sample_count; ++j) { buf3[sample_count] = (float) cbuf3[sample_count]; sample_count++; } } /* Finally, create the 3 banded image we were looking for */ strcpy(meta1->general->bands,"HH,HV,DIV"); meta1->general->band_count=3; put_band_float_lines(ofp,meta1,0,0,meta1->general->line_count,buf1); put_band_float_lines(ofp,meta1,1,0,meta1->general->line_count,buf2); put_band_float_lines(ofp,meta1,2,0,meta1->general->line_count,buf3); meta_write(meta1,outfile); } else if (mode == PALSAR_PLR) { /* Mode 1 - Create Color Browse from 3 bands using 3sigma stretch */ asfPrintStatus("Creating colorized browse image from PALSAR PLR data\n"); create_name(infile1,argv[1],".img"); create_name(infile2,argv[2],".img"); create_name(infile3,argv[3],".img"); create_name(outfile,argv[4],".img"); meta_parameters *meta1 = meta_read(infile1); meta_parameters *meta2 = meta_read(infile2); meta_parameters *meta3 = meta_read(infile3); if (meta1->general->line_count != meta2->general->line_count || meta1->general->sample_count != meta2->general->sample_count) { asfPrintError("Images must be the same size!!!\n"); exit(1); } if (meta3->general->line_count != meta2->general->line_count || meta3->general->sample_count != meta2->general->sample_count) { asfPrintError("Images must be the same size!!!\n"); exit(1); } int pixel_count = meta1->general->line_count*meta1->general->sample_count; float *buf1 = MALLOC(pixel_count * sizeof(float)); float *buf2 = MALLOC(pixel_count * sizeof(float)); float *buf3 = MALLOC(pixel_count * sizeof(float)); float *buf4 = MALLOC(pixel_count * sizeof(float)); unsigned char *cbuf1, *cbuf2, *cbuf3, *cbuf4; FILE *fp1 = FOPEN(infile1, "r"); FILE *fp2 = FOPEN(infile2, "r"); FILE *fp3 = FOPEN(infile3, "r"); FILE *ofp = FOPEN(outfile, "w"); get_float_lines(fp1,meta1,0,meta1->general->line_count, buf1); get_float_lines(fp2,meta2,0,meta2->general->line_count, buf2); get_float_lines(fp3,meta3,0,meta3->general->line_count, buf3); /* Convert data from sigma0 to dB */ sample_count = 0; for (i=0; i<meta1->general->line_count; ++i) { for (j=0; j<meta1->general->sample_count; ++j) { if (meta_is_valid_double(buf1[sample_count])) { if (buf1[sample_count] != 0) buf1[sample_count] = 10.0 * log10f(buf1[sample_count]); if (buf2[sample_count] != 0) buf2[sample_count] = 10.0 * log10f(buf2[sample_count]); if (buf3[sample_count] != 0) buf3[sample_count] = 10.0 * log10f(buf3[sample_count]); } sample_count++; } } /* Scale the data to a byte range using 3-sigma stretch values */ cbuf1 = my_floats_to_bytes(buf1,(long long) pixel_count, 0.0,SIGMA3,-30.0,-1.0); cbuf2 = my_floats_to_bytes(buf2,(long long) pixel_count, 0.0,SIGMA3,-30.0,-10.0); cbuf3 = my_floats_to_bytes(buf3,(long long) pixel_count, 0.0,SIGMA3,-30.0,-10.0); meta1->general->data_type=REAL32; //meta2->general->data_type=ASF_BYTE; //meta3->general->data_type=ASF_BYTE; sample_count = 0; for (i=0; i<meta1->general->line_count; ++i) { for (j=0; j<meta1->general->sample_count; ++j) { buf1[sample_count] = (float) cbuf1[sample_count]; buf2[sample_count] = (float) cbuf2[sample_count]; buf3[sample_count] = (float) cbuf3[sample_count]; sample_count++; } } /* Finally, create the 3 banded image we were looking for */ strcpy(meta1->general->bands,"HH,HV,VV"); meta1->general->band_count=3; put_band_float_lines(ofp,meta1,0,0,meta1->general->line_count,buf1); put_band_float_lines(ofp,meta1,1,0,meta1->general->line_count,buf2); put_band_float_lines(ofp,meta1,2,0,meta1->general->line_count,buf3); meta_write(meta1,outfile); } else if (mode == SENTINEL_DUAL) { asfPrintStatus("Creating colorized browse image from Sentinel dual-pol " "data\n"); if (strlen(tmpPath) > 0) { create_name(infile1,argv[5],".img"); create_name(infile2,argv[6],".img"); create_name(outfile,argv[7],".tif"); } else { create_name(infile1,argv[3],".img"); create_name(infile2,argv[4],".img"); create_name(outfile,argv[5],".tif"); } // Create temporary directory char tmpDir[1024]; if (strlen(tmpPath) > 0) sprintf(tmpDir, "%s%cbrowse-", tmpPath, DIR_SEPARATOR); else strcpy(tmpDir, "browse-"); strcat(tmpDir, time_stamp_dir()); create_clean_dir(tmpDir); asfPrintStatus("Temp dir is: %s\n", tmpDir); // Calculate ratio image char tmpRatio[512], tmpRed[512], tmpGreen[512], tmpBlue[512], tmpIn[512]; char *inFiles[2]; inFiles[0] = (char *) MALLOC(sizeof(char)*255); inFiles[1] = (char *) MALLOC(sizeof(char)*255); strcpy(inFiles[0], infile1); strcpy(inFiles[1], infile2); sprintf(tmpRatio, "%s%cdiv.img", tmpDir, DIR_SEPARATOR); raster_calc(tmpRatio, "a/b", 2, inFiles); // Resample all three bands and scale to byte meta_parameters *metaIn = meta_read(tmpRatio); double scaleFactor = 1.0/(scale/metaIn->general->x_pixel_size); meta_free(metaIn); sprintf(tmpIn, "%s%cred.img", tmpDir, DIR_SEPARATOR); resample(infile1, tmpIn, scaleFactor, scaleFactor); sprintf(tmpRed, "%s%cred_byte.img", tmpDir, DIR_SEPARATOR); floats_to_bytes_from_file(tmpIn, tmpRed, NULL, -40.0, SIGMA); sprintf(tmpIn, "%s%cgreen.img", tmpDir, DIR_SEPARATOR); resample(infile2, tmpIn, scaleFactor, scaleFactor); sprintf(tmpGreen, "%s%cgreen_byte.img", tmpDir, DIR_SEPARATOR); floats_to_bytes_from_file(tmpIn, tmpGreen, NULL, -40.0, SIGMA); sprintf(tmpIn, "%s%cblue.img", tmpDir, DIR_SEPARATOR); resample(tmpRatio, tmpIn, scaleFactor, scaleFactor); sprintf(tmpBlue, "%s%cblue_byte.img", tmpDir, DIR_SEPARATOR); floats_to_bytes_from_file(tmpIn, tmpBlue, NULL, -40.0, SIGMA); // Layer stack the bands char tmpBrowse[512]; sprintf(tmpBrowse, "%s%cbrowse.img", tmpDir, DIR_SEPARATOR); FILE *fpOut = FOPEN(tmpBrowse, "w"); meta_parameters *metaOut = meta_read(tmpRed); metaOut->general->band_count = 3; metaIn = meta_read(tmpRed); int line_count = metaIn->general->line_count; int sample_count = metaIn->general->sample_count; float *buf = (float *) MALLOC(sizeof(float)*line_count*sample_count); FILE *fpIn = FOPEN(tmpBlue, "r"); get_float_lines(fpIn, metaIn, 0, line_count, buf); put_band_float_lines(fpOut, metaOut, 0, 0, line_count, buf); FCLOSE(fpIn); fpIn = FOPEN(tmpGreen, "r"); get_float_lines(fpIn, metaIn, 0, line_count, buf); put_band_float_lines(fpOut, metaOut, 1, 0, line_count, buf); FCLOSE(fpIn); fpIn = FOPEN(tmpRed, "r"); get_float_lines(fpIn, metaIn, 0, line_count, buf); put_band_float_lines(fpOut, metaOut, 2, 0, line_count, buf); FCLOSE(fpIn); FCLOSE(fpOut); FREE(buf); strcpy(metaOut->general->bands, "red,green,blue"); meta_write(metaOut, tmpBrowse); // Export to GeoTIFF char *band_names[3] = { "blue", "green", "red" }; asf_export_bands(GEOTIFF, NONE, TRUE, FALSE, FALSE, FALSE, FALSE, tmpBrowse, outfile, band_names, NULL, NULL); // Clean up asfPrintStatus("Removing temporary directory: %s\n", tmpDir); remove_dir(tmpDir); meta_free(metaIn); meta_free(metaOut); } else asfPrintError("Mode is not defined!\n"); asfPrintStatus("Done.\n"); exit(EXIT_SUCCESS); }
int main(int argc,char **argv) { int lines,samps; /* Number of image lines and samples */ int fftLen,start_line; /* FFT length, & line to start processing at*/ int x,y,i,k; /* Counters */ int f_lo1,f_lo2,f_hi1,f_hi2; /* Filter frequency indicies */ int chunk_size,chunk_int; /* Size of current datablock, & temp value*/ int last_chunk; /* Size of the last chunk */ int compensate_for_last_chunk=1; /* If last chunk = 0 dont loop for last chunk*/ char *inName, *parmName, *outName; /* Input filename */ float filtStart[2], filtEnd[2]; /* Filter start and stop variables */ float df, stop; /* Delta and counter variables */ complexFloat *inBuf,*outBuf; /* Input/Output Image Buffers */ complexFloat *fftBuf; /* FFT Buffer for the image */ float *ampBuf,*phsBuf; /* Amplitude and Phase Buffers */ float *time_vector,A,B,shift; /* Time vector, & freq modulation shift vars*/ float chunk_float; /* Temporary value */ FILE *inF, *freqF, *outF1; /* Input and Output file pointers */ float cur_time, f_s; /* Current time to increment the time vector by */ meta_parameters *inMeta, *outMeta; /* Meta info about the images */ /* Usage is shown if the user doesn't give 3 arguements */ if(argc!=4) { usage(argv[0]); } StartWatch(); printf("Program cpx_filter\n"); /* Get the filename and filter start and end frequencies from the command line*/ inName=argv[1]; if(findExt(inName)==NULL) inName = appendExt(argv[1],".cpx"); outName=argv[2]; parmName=argv[3]; /* Get input metadata. Make sure data_type is complex */ inMeta = meta_read(inName); if (inMeta->general->data_type < COMPLEX_BYTE) { switch (inMeta->general->data_type) { case ASF_BYTE: inMeta->general->data_type=COMPLEX_BYTE; break; case INTEGER16: inMeta->general->data_type=COMPLEX_INTEGER16; break; case INTEGER32: inMeta->general->data_type=COMPLEX_INTEGER32; break; case REAL32: inMeta->general->data_type=COMPLEX_REAL32; break; case REAL64: inMeta->general->data_type=COMPLEX_REAL64; break; } meta_write (inMeta, inName); } /* Open the frequency parameter file and read the parameters */ if((freqF=FOPEN(parmName,"r"))==NULL) { printf("Frequency Parameter File %s could not be Opened!\n",parmName); exit(EXIT_FAILURE); } fscanf(freqF,"%f\n",&f_s); fscanf(freqF,"%f\n",&shift); fscanf(freqF,"%f %f\n", &filtStart[0], &filtEnd[0]); fscanf(freqF,"%f %f\n", &filtStart[1], &filtEnd[1]); printf("\n"); printf("Input file is %s\n",inName); printf("Output file is %s.cpx\n",outName); printf("Parameter file is %s\n",parmName); printf("Filtering from frequencies %.2f to %.2f Hz and %.2f to %.2f in Azimuth\n",filtStart[0],filtEnd[0],filtStart[1],filtEnd[1]); printf("The sampling frequency is %f Hz\n",f_s); printf("Shifting the spectrum by %.2f Hz\n",shift); /* Get the number of lines and samples from the input meta file */ lines = inMeta->general->line_count; samps = inMeta->general->sample_count; chunk_size = BLOCK_SIZE; chunk_float = (float)lines/chunk_size; chunk_int = lines/chunk_size; last_chunk = (int)((chunk_float-(float)chunk_int) * (float)BLOCK_SIZE + 0.5); if( (2*TOSS_SIZE) > last_chunk) compensate_for_last_chunk=0; printf("Chunk Size is set to %d, the last chunk is %d lines\n", chunk_size, last_chunk); /* Compute the FFT length based on the number of lines. Must be a power of 2 */ i = (log10(chunk_size)/log10(2)) + 1; fftLen = pow(2,i); printf("FFT Length is %d\n",fftLen); cfft1d(fftLen,NULL,0); printf("The Input Image has %d lines and %d samples\n",lines,samps); /* Allocate the memory for all the buffers */ inBuf = (complexFloat *)MALLOC(sizeof(complexFloat)*samps*fftLen); outBuf = (complexFloat *)MALLOC(sizeof(complexFloat)*samps*fftLen); fftBuf = (complexFloat *)MALLOC(sizeof(complexFloat)*fftLen); ampBuf = (float *)MALLOC(sizeof(float)*fftLen); phsBuf = (float *)MALLOC(sizeof(float)*fftLen); time_vector = (float *)MALLOC(sizeof(float)*lines); /* Open the Complex Image File */ if((inF=FOPEN(inName,"rb"))==NULL) { printf("Complex Image file %s could not be opened\n",inName); exit(EXIT_FAILURE); } strcat(outName,".cpx"); if((outF1=FOPEN(outName,"wb"))==NULL) { printf("Unable to write output %s\n",outName); exit(EXIT_FAILURE); } outMeta = meta_copy(inMeta); outMeta->general->line_count = chunk_int*(BLOCK_SIZE-2*TOSS_SIZE)+(last_chunk-2*TOSS_SIZE); outMeta->general->sample_count = samps; meta_write(outMeta, outName); /* Find the filter frequency index values */ df = f_s/fftLen; stop = 0; i = 0; while(stop<filtStart[0]) { f_lo1 = i; stop = df*i; i++; } stop = 0; i = 0; while(stop<filtStart[1]) { f_lo2=i; stop=df*i; i++; } i = fftLen; stop = df*i; while(stop>filtEnd[0]) { f_hi1 = i; stop = df*i; i--; } i = fftLen; stop = df*i; while(stop>filtEnd[1]) { f_hi2 = i; stop = df*i; i--; } /* Zero out all the arrays and begin processing data */ cur_time = 0; for(i=0; i<fftLen; i++) { ampBuf[i] = 0; phsBuf[i] = 0; } for(k=0; k<chunk_int+compensate_for_last_chunk; k++) { printf("\nProcessing Chunk %d of %d\n",k,lines/chunk_size); start_line = (k==0) ? 0 : (k*chunk_size)-(2*TOSS_SIZE); if (k==chunk_int) chunk_size=last_chunk; cur_time=start_line*(1/f_s); /* Read in the data chunk & put in proper endian order */ printf("Reading %d Lines Starting at Line %d\n",chunk_size,start_line); get_complexFloat_lines(inF, inMeta, start_line, chunk_size, inBuf); /* Process the each column */ printf("Performing the FFT and Filtering Operations\n"); for(x=0; x<samps; x++) { if(x%1000 == 0) printf("Processing Column %d\n",x); for(y=0;y<fftLen;y++) { fftBuf[y].real = 0; fftBuf[y].imag = 0; } for(y=0;y<chunk_size;y++) { fftBuf[y].real = inBuf[y*samps+x].real; fftBuf[y].imag = inBuf[y*samps+x].imag; } cfft1d(fftLen,fftBuf,-1); for (i=0; i<fftLen; i++) { ampBuf[i] = sqrt(fftBuf[i].real*fftBuf[i].real + fftBuf[i].imag*fftBuf[i].imag); if(fftBuf[i].imag!=0.0 || fftBuf[i].real!=0.0) phsBuf[i] = atan2(fftBuf[i].imag,fftBuf[i].real); else phsBuf[i] = 0; if(((i>f_lo1)&&(i<f_hi1)) || ((i>f_lo2) && (i<f_hi2))) { ampBuf[i] = 0; phsBuf[i] = 0; } fftBuf[i].real = ampBuf[i]*cos(phsBuf[i]); fftBuf[i].imag = ampBuf[i]*sin(phsBuf[i]); } cfft1d(fftLen,fftBuf,1); for(i=0;i<chunk_size;i++) { outBuf[i*samps+x].real = fftBuf[i].real; outBuf[i*samps+x].imag = fftBuf[i].imag; } } printf("Finished the FFT and Filtering Operations\n"); /* Perform the time-domain frequency shift */ if(shift != 0.0) { for(i=0; i<chunk_size; i++) time_vector[i] = cur_time+(1/f_s)*i; printf("\nPerforming time-domain frequency shift of %.2f Hz\n",shift); for(y=0; y<chunk_size; y++) { for(x=0; x<samps; x++) { A = outBuf[y*samps+x].real; B = outBuf[y*samps+x].imag; outBuf[y*samps+x].real = A*cos(2*pi*shift*time_vector[y]) - B*sin(2*pi*shift*time_vector[y]); outBuf[y*samps+x].imag = B*cos(2*pi*shift*time_vector[y]) + A*sin(2*pi*shift*time_vector[y]); } } } /* Write out the data file in big endian format */ printf("Writing the output lines %d to %d in file %s\n", start_line, start_line+chunk_size-TOSS_SIZE, outName); put_complexFloat_lines(outF1, outMeta, start_line, samps*(chunk_size-TOSS_SIZE), outBuf+(samps*TOSS_SIZE)); } printf("\n"); FCLOSE(outF1); StopWatch(); return 0; }
int asf_windspeed(platform_type_t platform_type, char *band_id, double wind_dir, int cmod4, double landmaskHeight, char *landmaskFile, char *demFile, char *inBaseName, char *colormapName, char *outBaseName) { char *inDataName, outDataName[1024], outMetaName[1024]; FILE *in = NULL, *out = NULL; asfPrintStatus("\n Determining windspeeds in: %s\n", inBaseName); strcpy(outDataName, outBaseName); strcpy(outMetaName, outBaseName); inDataName = (char *)MALLOC(sizeof(char) * (strlen(inBaseName) + 10)); strcpy(inDataName, inBaseName); append_ext_if_needed(inDataName, ".img", NULL); append_ext_if_needed(outDataName, ".img", NULL); append_ext_if_needed(outMetaName, ".meta", NULL); // New images for processing in to out meta_parameters *imd = meta_read(inBaseName); meta_general *img = imd->general; // convenience ptr meta_parameters *omd = meta_read(inBaseName); meta_general *omg = omd->general; // convenience ptr meta_sar *oms = omd->sar; // convenience ptr omg->band_count = 0; strcpy(omg->bands, ""); strcpy(oms->polarization, ""); if (strstr(img->bands, "VV") == NULL && strstr(img->bands, "HH") == NULL) { asfPrintError("Cannot find any VV or HH polarized bands in this data. Available\n" "bands are %s). Wind speeds can only be determined on Sigma0-\n" "calibrated SAR data in HH or VV polarizations.\n", img->bands); } in = (FILE *)FOPEN(inDataName, "rb"); out = (FILE *)FOPEN(outDataName, "wb"); FREE(inDataName); // For each band double alpha = 1.0; // Default for VV polarization; int band_num; float *data = (float *)MALLOC(sizeof(float) * img->sample_count); for (band_num = 0; band_num < img->band_count; band_num++) { // Get band name, check for proper polarization, and create new output bandname, set alpha char *band_name = get_band_name(img->bands, img->band_count, band_num); long offset = img->line_count * band_num; char polarization[2]=""; if (strncmp_case(band_name, "SIGMA-VV", 8) == 0 || strncmp_case(band_name, "SIGMA-HH", 8) == 0) { asfPrintStatus("\nProcessing wind speed calculations on band %s...\n\n", band_name); (omg->band_count)++; strcpy(polarization, (strstr(band_name, "VV") != NULL) ? "VV" : "HH"); strcpy(oms->polarization, polarization); sprintf(&omg->bands[strlen(omg->bands)], "%s%s%s", WINDSPEED_BAND_BASENAME, polarization, (band_num < img->band_count - 1 && img->band_count > 0) ? ", " : ""); alpha = (strcmp(polarization, "VV") == 0) ? 1.0 : DEFAULT_HH_POL_ALPHA; // For CMODx } else { asfPrintStatus("\nFound band: %s (Cannot calculate wind speed on this type of band)\n\n", band_name); continue; // Skip this band } // Calculate average r_look for entire image (r_look is the angle between the NADIR line // and a line point directly north, the 'look angle' of the platform.) double r_look = asf_r_look(imd); double phi_diff = wind_dir - r_look; // Pre-populate incidence angles (as a function of sample) and get min/max incidence angle // as well int line, sample; double *incids = (double *)MALLOC(img->sample_count * sizeof(double)); double min_incid = DBL_MAX; double max_incid = DBL_MIN; for (sample = 0; sample < img->sample_count; sample++) { incids[sample] = R2D * meta_incid(imd, img->line_count / 2, sample); min_incid = (incids[sample] < min_incid) ? incids[sample] : min_incid; max_incid = (incids[sample] > max_incid) ? incids[sample] : max_incid; } // Get min/max radar cross-sections asfPrintStatus("\nFinding min/max radar cross-sections...\n\n"); double rcs_min = DBL_MAX; double rcs_max = DBL_MIN; for (line = 0; line < img->line_count; line++) { // Get a line get_float_line(in, imd, line+offset, data); for (sample = 0; sample < img->sample_count; sample++) { if (meta_is_valid_double(data[sample]) && data[sample] >= 0.0) { rcs_min = (data[sample] < rcs_min) ? data[sample] : rcs_min; rcs_max = (data[sample] > rcs_max) ? data[sample] : rcs_max; } } asfLineMeter(line, img->line_count); } // FIXME: Generate 2D array of windspeeds here. One dimension is incidence angle and // the other is radar cross-section. The values in the table are wind speed as a function // of incidence angle and radar cross-section (given the provided wind direction.) The idea // is to more-quickly populate a grid of results and then to interpolate results for each // pixel of the image rather then perform the full calculation (very sloooow) double windspeed1 = 0.0, windspeed2 = 0.0; for (line = 0; line < img->line_count; line++) { // Get a line get_float_line(in, imd, line+offset, data); for (sample = 0; sample < img->sample_count; sample++) { // FIXME: Here is where we should apply a land mask ...in this if-statement expression if (meta_is_valid_double(data[sample]) && data[sample] >= 0.0) { // Calculate windspeed // FIXME: This returns the angle, at the target pixel location, between straight up // and the line to the satellite. Make sure Frank's code doesn't assume the angle // between the line to the satellite and a horizontal line, i.e. 90 degrees minus // this angle. double incidence_angle = incids[sample]; switch (platform_type) { case p_RSAT1: if (!cmod4) { // Use CMOD5 to calculate windspeeds double hh = alpha; ws_inv_cmod5((double)data[sample], phi_diff, incidence_angle, &windspeed1, &windspeed2, (double)MIN_CMOD5_WINDSPEED, (double)MAX_CMOD5_WINDSPEED, 25, hh); data[sample] = windspeed1; // When 2 answers exist, take the lower (per Frank Monaldo) } else { // Use CMOD4 to calculate windspeeds asfPrintError("The CMOD4 algorithm is not yet supported. Avoid the -cmod4\n" "option for now and let %s default to using the CMOD5 algorithm\n" "instead.\n"); } break; case p_PALSAR: case p_TERRASARX: case p_ERS1: case p_ERS2: default: asfPrintError("Found a platform type (%s) that is not yet supported.\n", (platform_type == p_PALSAR) ? "PALSAR" : (platform_type == p_TERRASARX) ? "TerraSAR-X" : (platform_type == p_ERS1) ? "ERS-1" : (platform_type == p_ERS2) ? "ERS-2" : "UNKNOWN PLATFORM"); } } } put_float_line(out, omd, line+offset, data); asfLineMeter(line, img->line_count); } } // end for (each band) FREE(data); // Insert colormap into metadata meta_write(omd, outMetaName); meta_free(imd); meta_free(omd); asfPrintStatus("Windspeed calculation complete.\n\n"); return EXIT_SUCCESS; }
void prep_specan_file(int nLooks,int quality,double aspect, struct ARDOP_PARAMS *g,meta_parameters *meta) { getRec *inFile; FILE *outFile; int outLines,outSamples/*,x*/; /*char command[1024];*/ int i; specan_struct rng={1.0/RFS, RSLOPE, RCEN, RBW, RLEN_INIT}; specan_struct az={1.0/AFS, ASLOPE, ACEN, ABW, ALEN_INIT}; /*Set quality: longer FFT's -> bigger image, better quality.*/ for (i=0;i<quality;i++) { rng.fftLen*=2; az.fftLen*=2; } rng.fftLen=(int)(rng.fftLen*aspect); /*Open files.*/ if (!quietflag) printf("Opening input files...\n"); inFile=fillOutGetRec(g->in1); outFile=fopenImage(g->out,"wb"); /*Init. Range Variables*/ if (!quietflag) printf("Init SPECAN\n"); rng.iSamp=1.0/g->fs;/*Sample size, range (s)= 1.0/sample freqency (Hz)*/ rng.chirpSlope=g->slope;/*Range chirp slope (Hz/Sec)*/ specan_init(&rng); /*Init. Azimuth Variables*/ if (!quietflag) printf("Estimate Doppler\n"); az.iSamp=1.0/g->prf;/*Sample size, azimuth (s)=1.0/sample freqency (Hz)*/ if (meta->stVec==NULL) { fprintf(stderr, "Can only quicklook scenes with state vectors!\n"); exit(1);} else { /*Find doppler rate (Hz/sec) <=> azimuth chirp slope*/ double dopRate,yaw=0.0; GEOLOCATE_REC *g=init_geolocate_meta(&meta->stVec->vecs[0].vec,meta); double look; int ret; ret=getLook(g,meta->geo->slantFirst,yaw,&look); assert(ret==0); getDoppler(g,look,yaw,NULL,&dopRate,NULL,NULL); az.chirpSlope=dopRate; free_geolocate(g); } az.chirpCenter=g->fd*(1.0/az.iSamp);/*Convert doppler central freqency to Hz*/ /*For de-scalloping, compute the most powerful doppler freqency.*/ az.powerCenter=(1.0/az.iSamp)* fftEstDop(inFile,inFile->nLines/2,1,az.fftLen); if (!quietflag) printf("Doppler centroid at %.0f Hz, %.0f Hz/sec\n",az.chirpCenter,az.chirpSlope); specan_init(&az); if (!quietflag) printf("Efficiency: Range(%d): %.0f%% Azimuth(%d): %.0f%%\n", rng.fftLen,100.0*rng.oNum/rng.fftLen, az.fftLen,100.0*az.oNum/az.fftLen); /*Process image.*/ specan_file(inFile,nLooks,outFile,&rng,&az,&outLines,&outSamples); FCLOSE(outFile); freeGetRec(inFile); /*Create DDR for output file.*/ { struct DDR ddr;/*Output DDR*/ c_intddr(&ddr); ddr.dtype=DTYPE_FLOAT; ddr.nbands=1; ddr.nl=outLines; ddr.ns=outSamples; ddr.sample_inc=rng.oSamp/rng.iSamp; ddr.line_inc=az.oSamp/az.iSamp; c_putddr(g->out,&ddr); } /*Copy over metadata*/ if (meta->info) sprintf(meta->info->processor,"ASF/QUICKLOOK/%.2f",VERSION); meta_write(meta,g->out); }
int md_chown(mreq_p request, char *fname) { fmeta meta1; int fd,length,i, setgid = -1, force_group_change = 0; char temp[MAXPATHLEN]; dmeta dir; struct passwd *pw; struct group *grp; if ((fd = meta_open(fname, O_RDWR)) < 0) { if (errno != EISDIR) { PERROR(SUBSYS_META,"md_chown: meta_open"); return (-1); } } /* check execute permissions on directory */ strncpy(temp, fname, MAXPATHLEN); length = get_parent(temp); /* length < 0 means CWD */ if (length >= 0) { dmeta pdir; if (meta_access(0, temp, request->uid, request->gid, X_OK) < 0) { PERROR(SUBSYS_META,"md_chown: meta_access"); return(-1); } get_dmeta(temp, &pdir); if(S_ISGID & pdir.dr_mode) { setgid = pdir.dr_gid; } } /* Read metadata file */ if (fd >= 0) { if (meta_read(fd, &meta1) < 0) { PERROR(SUBSYS_META,"md_chown: meta_read"); meta_close(fd); return (-1); } lseek(fd, 0, SEEK_SET); } else { /* directory */ get_dmeta(fname, &dir); meta1.u_stat.st_uid = dir.dr_uid; meta1.u_stat.st_gid = dir.dr_gid; } /* Change owner if necessary */ if (request->req.chown.owner >= 0) { /* root can change this or if uid = file owner uid, * let group chown be performed */ if (((request->uid != 0) && (request->uid != request->req.chown.owner)) || ((request->uid != 0) && (request->uid != meta1.u_stat.st_uid))) { errno = EPERM; PERROR(SUBSYS_META,"md_chown: permission denied"); if (fd >= 0) meta_close(fd); return(-1); } meta1.u_stat.st_uid = request->req.chown.owner; } /* Change group if necessary */ if (request->req.chown.group >= 0) { if (request->uid) /* not root, check perms */ { /* from chown(2), only root or owner can change group permissions, so check for owner of file */ if(request->uid != meta1.u_stat.st_uid){ LOG(stderr, WARNING_MSG, SUBSYS_META, "md_chown: change group permission denied (1)"); if (fd >= 0) meta_close(fd); errno = EPERM; return(-1); } /* grab group info from /etc/group or wherever */ if (!(grp = getgrgid(request->req.chown.group))) { PERROR(SUBSYS_META,"md_chown: getgrgid"); if (fd >= 0) meta_close(fd); errno = EINVAL; return(-1); } /* see if user is a member of target group in /etc/group or /etc/passwd */ if (!(pw = getpwuid(request->uid))) { PERROR(SUBSYS_META,"md_chown: getpwuid"); if (fd >= 0) meta_close(fd); errno = EINVAL; return(-1); } for(i=0;grp->gr_mem[i] && strcmp(pw->pw_name, grp->gr_mem[i]); i++); if(!grp->gr_mem[i] && pw->pw_gid != request->req.chown.group) { LOG(stderr, WARNING_MSG, SUBSYS_META, "md_chown: change group permission denied (2)"); if (fd >= 0) meta_close(fd); errno = EPERM; return(-1); } } if (setgid == -1) { meta1.u_stat.st_gid = request->req.chown.group; } else { force_group_change = request->req.chown.force_group_change; if(force_group_change == 1) { meta1.u_stat.st_gid = request->req.chown.group; } else { meta1.u_stat.st_gid = setgid; } } } /* Write metadata back */ if (fd >= 0) { if (meta_write(fd, &meta1) < 0) { PERROR(SUBSYS_META,"md_chown: meta_write"); meta_close(fd); return(-1); } } else { /* directory */ dir.dr_uid = meta1.u_stat.st_uid; dir.dr_gid = meta1.u_stat.st_gid; put_dmeta(fname, &dir); } /* Close metadata file */ if (fd >= 0 && (meta_close(fd)) < 0) { PERROR(SUBSYS_META,"md_chown: meta_close"); return(-1); } /* Do acknowledge and return */ return (0); }
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; }