void check_for_help(int argc,char *argv[]) { if (checkForOption("--help", argc, argv) || checkForOption("-h", argc, argv) || checkForOption("-help", argc, argv)) { print_help(); exit(1); } }
int main(int argc, char *argv[]){ bool DEBUG = checkForOption(argv, argv + argc, "debug"); bool LOG_EN = checkForOption(argv, argv + argc, "log"); Memory mem = Memory(); if (parseInput(mem, DEBUG)){ std::cout << "There were errors during preparation process, simulation aborted" << std::endl; return 1; } runSimulation(mem, LOG_EN); if (DEBUG) mem.memoryDump(); return 0; }
int main(int argc, char *argv[]) { char inBaseName[256]=""; char outBaseName[256]=""; char *colormapName = NULL; char band_id[256]=""; double wind_dir = 315.0; // Default to wind from the NW int cmod4 = 0; char *landmaskFile = NULL; double landmaskHeight = atof(DEFAULT_LANDMASK_HEIGHT); platform_type_t platform_type; char *demFile = NULL; int ii; int flags[NUM_WINDSPEED_FLAGS]; /* Set all flags to 'not set' */ for (ii=0; ii<NUM_WINDSPEED_FLAGS; ii++) { flags[ii] = FLAG_NOT_SET; } /**********************BEGIN COMMAND LINE PARSING STUFF**********************/ if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } handle_license_and_version_args(argc, argv, ASF_NAME_STRING); /*Check to see if any options were provided*/ flags[f_LOG] = checkForOption("-log", argc, argv); flags[f_QUIET] = checkForOption("-quiet", argc, argv); flags[f_REAL_QUIET] = checkForOption("-real-quiet", argc, argv); flags[f_BAND] = checkForOption("-band", argc, argv); flags[f_COLORMAP] = checkForOption("-colormap", argc, argv); flags[f_WINDDIR] = checkForOption("-wind-dir", argc, argv); flags[f_CMOD4] = checkForOption("-cmod4", argc, argv); flags[f_LANDMASK] = checkForOption("-landmask", argc, argv); flags[f_LANDMASK_HEIGHT] = checkForOption("-landmask-height", argc, argv); flags[f_DEM] = checkForOption("-dem", argc, argv); { /*We need to make sure the user specified the proper number of arguments*/ int needed_args = 1 + REQUIRED_ARGS; /*command + REQUIRED_ARGS*/ if(flags[f_LOG] != FLAG_NOT_SET) needed_args += 2;/*option & parameter*/ if(flags[f_QUIET] != FLAG_NOT_SET) needed_args += 1;/*option*/ if(flags[f_REAL_QUIET] != FLAG_NOT_SET) needed_args += 1;/*option*/ if(flags[f_BAND] != FLAG_NOT_SET) needed_args += 2;/*option & parameter*/ if(flags[f_COLORMAP] != FLAG_NOT_SET) needed_args += 2; /*option & parameter*/ if(flags[f_WINDDIR] != FLAG_NOT_SET) needed_args += 2; /*option & parameter*/ if(flags[f_CMOD4] != FLAG_NOT_SET) needed_args += 2; /*option & parameter*/ if(flags[f_LANDMASK] != FLAG_NOT_SET) needed_args += 2; /*option & parameter*/ if(flags[f_LANDMASK_HEIGHT] != FLAG_NOT_SET) needed_args += 2; /*option & parameter*/ if(flags[f_DEM] != FLAG_NOT_SET) needed_args += 2; /*option & parameter*/ /*Make sure we have enough arguments*/ if(argc != needed_args) print_usage();/*This exits with a failure*/ } if(flags[f_LOG] != FLAG_NOT_SET) /*Make sure the field following -log isn't another option*/ if( argv[flags[f_LOG]+1][0] == '-' || flags[f_LOG] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_BAND] != FLAG_NOT_SET) /*Make sure the field following -format isn't another option*/ if( argv[flags[f_BAND]+1][0] == '-' || flags[f_BAND] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_COLORMAP] != FLAG_NOT_SET) /*Make sure the field following -colormap isn't another option*/ if( argv[flags[f_COLORMAP]+1][0] == '-' || flags[f_COLORMAP] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_WINDDIR] != FLAG_NOT_SET) if( argv[flags[f_WINDDIR]+1][0] == '-' || flags[f_WINDDIR] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_CMOD4] != FLAG_NOT_SET) if( argv[flags[f_CMOD4]+1][0] == '-' || flags[f_CMOD4] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_LANDMASK] != FLAG_NOT_SET) if( argv[flags[f_LANDMASK]+1][0] == '-' || flags[f_LANDMASK] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_LANDMASK_HEIGHT] != FLAG_NOT_SET) if( argv[flags[f_LANDMASK_HEIGHT]+1][0] == '-' || flags[f_LANDMASK_HEIGHT] >= argc-REQUIRED_ARGS) print_usage(); if(flags[f_DEM] != FLAG_NOT_SET) if( argv[flags[f_DEM]+1][0] == '-' || flags[f_DEM] >= argc-REQUIRED_ARGS) print_usage(); /* Be sure to open log ASAP */ if(flags[f_LOG] != FLAG_NOT_SET) strcpy(logFile, argv[flags[f_LOG] + 1]); else /*default behavior: log to tmp<pid>.log*/ sprintf(logFile, "tmp%i.log", (int)getpid()); logflag = TRUE; /* Since we always log, set the old school logflag to true */ // Open log file in output folder char path[1024], tmp[1024]; split_dir_and_file(argv[argc-1], path, tmp); strcpy(tmp, logFile); sprintf(logFile, "%s%s", path, tmp); fLog = fopen(logFile, "a"); if ( fLog == NULL ) { logflag = FALSE; } /* Set old school quiet flag (for use in our libraries) */ quietflag = flags[f_QUIET] != FLAG_NOT_SET; if (flags[f_REAL_QUIET] != FLAG_NOT_SET) quietflag = 2; /* We must be close to good enough at this point... log & quiet flags are set Report what was retrieved at the command line */ asfSplashScreen(argc, argv); if(flags[f_COLORMAP] != FLAG_NOT_SET) { colormapName = (char *) MALLOC(sizeof(char)*1024); strcpy(colormapName, argv[flags[f_COLORMAP] + 1]); } if (flags[f_WINDDIR] != FLAG_NOT_SET) { wind_dir = atof(argv[flags[f_WINDDIR]+1]); } if (flags[f_LANDMASK] != FLAG_NOT_SET) { landmaskFile = (char *) MALLOC(sizeof(char)*1024); strncpy(landmaskFile, argv[flags[f_LANDMASK]], 8); } if (flags[f_LANDMASK_HEIGHT] != FLAG_NOT_SET) { landmaskHeight = atof(argv[flags[f_LANDMASK_HEIGHT]]); } if (flags[f_DEM] != FLAG_NOT_SET) { demFile = (char *) MALLOC(sizeof(char)*1024); strncpy(demFile, argv[flags[f_DEM]], 8); } // Check validity if (flags[f_LANDMASK] != FLAG_NOT_SET && (flags[f_LANDMASK_HEIGHT] != FLAG_NOT_SET || flags[f_DEM] != FLAG_NOT_SET)) { asfPrintStatus("\nCannot use the -landmask option together with -landmask-height\n" "or -dem.\n\n"); print_usage(); } if (wind_dir < 0.0 || wind_dir >= 360.0) { asfPrintError("Wind direction specified with the -wind-dir argument must range\n" "from 0.0 up to, but not including, 360.0. Wind direction is specified\n" "as being the direction the wind blows FROM in degrees clockwise from\n" "North, with North being 0.0 degrees.\n"); } if (landmaskHeight <= 0.0) { asfPrintStatus("\nLandmask height set with -landmask-height must be a positive height\n\n"); print_usage(); } if(flags[f_BAND] != FLAG_NOT_SET) { strcpy(band_id, argv[flags[f_BAND] + 1]); if (strlen(band_id) && strcmp("ALL", uc(band_id)) == 0) { strcpy(band_id, ""); } } /* Fetch required arguments */ strcpy(inBaseName, argv[argc - 2]); strcpy(outBaseName, argv[argc - 1]); /***********************END COMMAND LINE PARSING STUFF***********************/ asfSplashScreen (argc, argv); // Check the metadata to find out if this is data we an process meta_parameters *md = meta_read(inBaseName); meta_general *mg = md->general; // convenience ptr meta_sar *ms = md->sar; // convenience ptr if ((strncmp(mg->sensor, "RSAT-1", 6) != 0 && strncmp(mg->sensor, "ERS1", 4) != 0 && strncmp(mg->sensor, "ALOS", 4) != 0 && strncmp(mg->sensor, "TSX-1", 5) != 0) || strncmp(mg->sensor_name, "SAR", 3) != 0) { asfPrintError("Only SAR products from RSAT1, ERS1, ALOS PALSAR, and TERRASAR\n" "are supported. Found sensor %s, sensor_name %s in metadata.\n", mg->sensor, mg->sensor_name); } if (mg->radiometry != r_SIGMA) { asfPrintError("Only sigma-nought products (not in decibels) are currently supported.\n" "See asf_import -help for more info on how to produce these from \n" "original format data.\n"); } if (!strstr(mg->bands, "HH") && !strstr(mg->bands, "VV")) { asfPrintError("Only HH and VV polarizations are supported. Found bands %s\n", mg->bands); } if (ms->image_type != 'G') { asfPrintError("Only ground range images are currently supported. Found %s image\n", (ms->image_type == 'R') ? "GEOREFERENCED" : (ms->image_type == 'S') ? "SLANT RANGE" : (ms->image_type == 'P') ? "MAP PROJECTED" : "UNKNOWN TYPE"); } // As-yet unimplemented feature bail-outs... if (strncmp(mg->sensor, "RSAT-1", 6) != 0) { // Temporary bail-out until we add the other platforms asfPrintError("Platforms other than RSAT1 not yet supported...\n"); } if (flags[f_COLORMAP] != FLAG_NOT_SET || flags[f_CMOD4] != FLAG_NOT_SET || flags[f_LANDMASK] != FLAG_NOT_SET || flags[f_LANDMASK_HEIGHT] != FLAG_NOT_SET || flags[f_DEM] != FLAG_NOT_SET) { asfPrintError("The following options are not yet supported:\n" " -colormap\n" " -cmod4\n" " -landmask\n" " -landmask-height\n" " -dem\n"); } // Determine platform type // RSAT-1 (C-band), ERS1 (C-band), ALOS (L-band), TSX-1 (X-band) platform_type = (strncmp(mg->sensor, "RSAT-1", 6) == 0) ? p_RSAT1 : (strncmp(mg->sensor, "ERS1", 4) == 0) ? p_ERS1 : (strncmp(mg->sensor, "ALOS", 4) == 0) ? p_PALSAR : (strncmp(mg->sensor, "TSX-1", 5) == 0) ? p_TERRASARX : 0; meta_free(md); asf_windspeed(platform_type, band_id, wind_dir, cmod4, landmaskHeight, landmaskFile, demFile, inBaseName, colormapName, outBaseName); FREE(colormapName); FREE(landmaskFile); FREE(demFile); /* If the user didn't ask for a log file then we can nuke the one that we've been keeping since we've finished everything */ if (logflag) { fclose (fLog); remove(logFile); } exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char inFile[512], outFile[512], *colormap=NULL; char *polsarpro=NULL, *band=NULL, *rgb=NULL; const int pid = getpid(); extern int logflag, quietflag; int reduction = 8; int transparency = 0; int quiet_f; /* log_f is a static global */ int redFlag = FLAG_NOT_SET; // reduction factor flag int transFlag = FLAG_NOT_SET; // level of transparency flag int colorFlag = FLAG_NOT_SET; // colormap flag int rgbFlag = FLAG_NOT_SET; // RGB flag int polFlag = FLAG_NOT_SET; // polarimetry type flag int bandFlag = FLAG_NOT_SET; // band flag logflag = quietflag = FALSE; log_f = quiet_f = FLAG_NOT_SET; // Begin command line parsing *********************************************** if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } get_asf_share_dir_with_argv0(argv[0]); handle_license_and_version_args(argc, argv, ASF_NAME_STRING); // Check which options were provided log_f = checkForOption("-log", argc, argv); quiet_f = checkForOption("-quiet", argc, argv); redFlag = checkForOption("-reduction_factor", argc, argv); transFlag = checkForOption("-transparency", argc, argv); colorFlag = checkForOption("-colormap", argc, argv); rgbFlag = checkForOption("-rgb", argc, argv); polFlag = checkForOption("-polsarpro", argc, argv); bandFlag = checkForOption("-band", argc, argv); // We need to make sure the user specified the proper number of arguments int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS int num_flags = 0; if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (quiet_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option if (redFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (transFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (colorFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (rgbFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (polFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (bandFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param // Make sure we have the right number of args if(argc != needed_args) { print_usage(); } // Make sure argument for each flag (that requires an arg) is not another // option flag & is not a required argument if (log_f != FLAG_NOT_SET) { if ( (argv[log_f+1][0]=='-') || (log_f>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } if (redFlag != FLAG_NOT_SET) { if ( (argv[redFlag+1][0]=='-') || (redFlag>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } if (transFlag != FLAG_NOT_SET) { if ( (argv[transFlag+1][0]=='-') || (transFlag>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } if (colorFlag != FLAG_NOT_SET) { if ( (argv[colorFlag+1][0]=='-') || (colorFlag>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } if (rgbFlag != FLAG_NOT_SET) { if ( (argv[rgbFlag+1][0]=='-') || (rgbFlag>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } if (polFlag != FLAG_NOT_SET) { if ( (argv[polFlag+1][0]=='-') || (polFlag>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } if (bandFlag != FLAG_NOT_SET) { if ( (argv[bandFlag+1][0]=='-') || (bandFlag>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } // Make sure all options occur before the config file name argument if (num_flags == 1 && (log_f > 1 || quiet_f > 1 || redFlag > 1 || transFlag > 1 || colorFlag > 1 || rgbFlag > 1 || polFlag > 1 || bandFlag > 1)) { print_usage(); } else if (num_flags > 1 && (log_f >= argc - REQUIRED_ARGS - 1 || quiet_f >= argc - REQUIRED_ARGS - 1 || redFlag >= argc - REQUIRED_ARGS - 1 || transFlag >= argc - REQUIRED_ARGS - 1 || colorFlag >= argc - REQUIRED_ARGS - 1 || rgbFlag >= argc - REQUIRED_ARGS - 1 || polFlag >= argc - REQUIRED_ARGS - 1 || bandFlag >= argc - REQUIRED_ARGS - 1)) { print_usage(); } // Do the actual flagging & such for each flag if (redFlag != FLAG_NOT_SET) { reduction = atoi(argv[redFlag+1]); } if (transFlag != FLAG_NOT_SET) { transparency = atoi(argv[transFlag+1]); } if (colorFlag != FLAG_NOT_SET) { colormap = (char *) MALLOC(sizeof(char)*1024); strcpy(colormap, argv[colorFlag+1]); } if (rgbFlag != FLAG_NOT_SET) { rgb = (char *) MALLOC(sizeof(char)*1024); strcpy(rgb, argv[rgbFlag+1]); } if (polFlag != FLAG_NOT_SET) { polsarpro = (char *) MALLOC(sizeof(char)*1024); strcpy(polsarpro, argv[polFlag+1]); } if (bandFlag != FLAG_NOT_SET) { band = (char *) MALLOC(sizeof(char)*1024); strcpy(band, argv[bandFlag+1]); } if (log_f != FLAG_NOT_SET) { strcpy(logFile, argv[log_f+1]); } else { // default behavior: log to tmp<pid>.log sprintf(logFile, "tmp%i.log", pid); } logflag = TRUE; fLog = FOPEN(logFile, "a"); // Set old school quiet flag (for use in our libraries) quietflag = quiet_f != FLAG_NOT_SET; // Fetch required arguments strcpy(inFile, argv[argc-2]); strcpy(outFile, argv[argc-1]); // Report the command line asfSplashScreen(argc, argv); // No zipping at the moment asfPrintStatus("A system independent zipping function is currently not " "available.\nFor the moment the KML and PNG files need to " "be manually zipped together.\n\n"); kml_overlay_ext(inFile, outFile, reduction, transparency, colormap, rgb, polsarpro, band, FALSE); asfPrintStatus("\nSuccessful completion!\n\n"); FCLOSE(fLog); remove(logFile); return(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char configFileName[255]; const int pid = getpid(); int createflag; extern int logflag, quietflag; int create_f, quiet_f; /* log_f is a static global */ createflag = logflag = quietflag = FALSE; create_f = log_f = quiet_f = FLAG_NOT_SET; // Begin command line parsing *********************************************** if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } get_asf_share_dir_with_argv0(argv[0]); handle_license_and_version_args(argc, argv, ASF_NAME_STRING); // This is an undocumented option, for internal use (by the GUI) int save_dem = extract_flag_options(&argc, &argv, "-save-dem", "--save-dem", NULL); // Check which options were provided create_f = checkForOption("-create", argc, argv); log_f = checkForOption("-log", argc, argv); quiet_f = checkForOption("-quiet", argc, argv); // We need to make sure the user specified the proper number of arguments int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS int num_flags = 0; if (create_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (quiet_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option // Make sure we have the right number of args if(argc != needed_args) { print_usage(); } // Make sure argument for each flag (that requires an arg) is not another // option flag & is not a required argument if (log_f != FLAG_NOT_SET) { if ( (argv[log_f+1][0]=='-') || (log_f>=(argc-REQUIRED_ARGS)) ) { print_usage(); } } // Make sure all options occur before the config file name argument if (num_flags == 1 && (create_f > 1 || log_f > 1 || quiet_f > 1)) { print_usage(); } else if (num_flags > 1 && (create_f >= argc - REQUIRED_ARGS - 1 || log_f >= argc - REQUIRED_ARGS - 1 || quiet_f >= argc - REQUIRED_ARGS - 1)) { print_usage(); } // Do the actual flagging & such for each flag if (create_f != FLAG_NOT_SET) { createflag = TRUE; } if (log_f != FLAG_NOT_SET) { strcpy(logFile, argv[log_f+1]); } else { // default behavior: log to tmp<pid>.log sprintf(logFile, "tmp%i.log", pid); } logflag = TRUE; fLog = FOPEN(logFile, "a"); // Set old school quiet flag (for use in our libraries) quietflag = quiet_f != FLAG_NOT_SET; // Fetch required arguments strcpy(configFileName, argv[argc-1]); // Report the command line asfSplashScreen(argc, argv); // End command line parsing ************************************************* asf_convert_ext(createflag, configFileName, save_dem); // remove log file if we created it (leave it if the user asked for it) FCLOSE(fLog); if (log_f == FLAG_NOT_SET) remove(logFile); return(EXIT_SUCCESS); }
/* Main program */ int main(int argc, char *argv[]) { FILE *fpLook=NULL, *fpIncid=NULL, *fpRange=NULL, *fpIn=NULL, *fpMask=NULL; meta_parameters *meta; stateVector stVec; int ii, kk, ll; char inFile[255], metaFile[255], dataFile[255], outLook[255], outIncid[255]; char outRange[255], outBase[255], outFile[255], *maskFile=NULL; char cmd[255], *bufMask=NULL; float *bufImage=NULL, *bufLook=NULL, *bufIncid=NULL, *bufRange=NULL; double latitude, longitude, time, doppler, earth_radius=0, satellite_height, range; double look_angle, incidence_angle, height; double line, sample, re=6378144.0, rp=6356754.9, px, py; double firstLook=0.0, firstIncid=0.0, firstRange=0.0; flag_indices_t flags[NUM_FLAGS]; /* Set all flags to 'not set' */ for (ii=0; ii<NUM_FLAGS; ii++) { flags[ii] = FLAG_NOT_SET; } /**********************BEGIN COMMAND LINE PARSING STUFF**********************/ /* Check to see if any options were provided */ if (checkForOption("-help", argc, argv) != -1) /* Most important */ help_page(); flags[f_LOOK] = checkForOption("-look", argc, argv); flags[f_INCIDENCE] = checkForOption("-incidence", argc, argv); flags[f_RANGE] = checkForOption("-range", argc, argv); flags[f_LINE] = checkForOption("-line", argc, argv); flags[f_SAMPLE] = checkForOption("-sample", argc, argv); flags[f_MIN] = checkForOption("-min", argc, argv); flags[f_MAX] = checkForOption("-max", argc, argv); flags[f_BINS] = checkForOption("-bins", argc, argv); flags[f_INTERVAL] = checkForOption("-interval", argc, argv); /* Make sure to set log & quiet flags (for use in our libraries) */ logflag = (flags[f_LOG]!=FLAG_NOT_SET) ? TRUE : FALSE; quietflag = (flags[f_QUIET]!=FLAG_NOT_SET) ? TRUE : FALSE; { /* We need to make sure the user specified the proper number of arguments */ int needed_args = 4;/*command & in_base & out_base */ if (flags[f_MIN] != FLAG_NOT_SET) needed_args += 2; /* option & value */ if (flags[f_MAX] != FLAG_NOT_SET) needed_args += 2; /* option & value */ if (flags[f_BINS] != FLAG_NOT_SET) needed_args += 2; /* option & value */ if (flags[f_INTERVAL] != FLAG_NOT_SET) needed_args += 2; /* option & value */ /*Make sure we have enough arguments*/ if (argc != needed_args) usage();/*This exits with a failure*/ } /* We must be close to good enough at this point...start filling in fields as needed */ if (flags[f_MIN] != FLAG_NOT_SET) min = atof(argv[flags[f_MIN] + 1]); if (flags[f_MAX] != FLAG_NOT_SET) max = atof(argv[flags[f_MAX] + 1]); if (flags[f_BINS] != FLAG_NOT_SET) bins = atoi(argv[flags[f_BINS] + 1]); if (flags[f_INTERVAL] != FLAG_NOT_SET) interval = atof(argv[flags[f_INTERVAL] + 1]); if (flags[f_QUIET] == FLAG_NOT_SET) /* display splash screen if not quiet */ print_splash_screen(argc, argv); if (flags[f_LOG] != FLAG_NOT_SET) strcpy(logFile, argv[flags[f_LOG] + 1]); else /* default behavior: log to tmp<pid>.log */ sprintf(logFile, "tmp%i.log", (int)getpid()); fLog = FOPEN(logFile, "a"); /* Fetch required arguments */ strcpy(inFile,argv[argc - 2]); strcpy(outBase,argv[argc - 1]); /***********************END COMMAND LINE PARSING STUFF***********************/ create_name(metaFile, inFile, ".meta"); create_name(dataFile, inFile, ".img"); /* Read metadata */ meta = meta_read(inFile); lines = meta->general->line_count; samples = meta->general->sample_count; /* Set some values */ doppler = 0.0; /* Determine what kind of image it is */ if (meta->sar->image_type=='P') { if (meta->projection->type==SCANSAR_PROJECTION) printf(" Detected ScanSAR "); } else if (meta->sar->image_type=='S') printf(" Detected slant range "); else if (meta->sar->image_type=='G') printf(" Detected ground range "); /* switch (meta->general->image_data_type) { case AMPLITUDE_IMAGE: printf("amplitude image ...\n"); break; case SIGMA_IMAGE: printf("sigma image ...\n"); break; case GAMMA_IMAGE: printf("gamma image ...\n"); break; case BETA_IMAGE: printf("beta image ...\n"); break; case RAW_IMAGE: case COMPLEX_IMAGE: case PHASE_IMAGE: case POWER_IMAGE: case COHERENCE_IMAGE: case GEOREFERENCED_IMAGE: case GEOCODED_IMAGE: case POLARIMETRIC_IMAGE: case LUT_IMAGE: case ELEVATION: case DEM: case IMAGE: case MASK: break; } */ /* Create a mask file for background fill - required only for ScanSAR */ if (meta->sar->image_type=='P') { if (meta->projection->type==SCANSAR_PROJECTION) { fpIn = fopenImage(inFile, "rb"); bufImage = (float *) MALLOC(samples * sizeof(float)); printf(" Generating mask file ...\n"); maskFile = (char *) MALLOC(255*sizeof(char)); sprintf(maskFile, "tmp%i.mask", (int)getpid()); fpMask = fopenImage(maskFile, "wb"); bufMask = (unsigned char *) MALLOC(samples * sizeof(char)); for (ii=0; ii<lines; ii++) { get_float_line(fpIn, meta, ii, bufImage); for (kk=0; kk<samples; kk++) { if (bufImage[kk]>0.0) bufMask[kk] = 1; else bufMask[kk] = 0; } ASF_FWRITE(bufMask, sizeof(char), samples, fpMask); } FCLOSE(fpMask); FREE(bufMask); FCLOSE(fpIn); FREE(bufImage); } } /* Create grid for least square approach */ printf(" Initialization ...\n"); if (flags[f_LOOK] != FLAG_NOT_SET) { sprintf(outLook, "tmp%i.look", (int)getpid()); fpLook = FOPEN(outLook, "w"); } if (flags[f_INCIDENCE] != FLAG_NOT_SET) { sprintf(outIncid, "tmp%i.incid", (int)getpid()); fpIncid = FOPEN(outIncid, "w"); } if (flags[f_RANGE] != FLAG_NOT_SET) { sprintf(outRange, "tmp%i.range", (int)getpid()); fpRange = FOPEN(outRange, "w"); } if (flags[f_LOOK] != FLAG_NOT_SET || flags[f_INCIDENCE] != FLAG_NOT_SET || flags[f_RANGE] != FLAG_NOT_SET) { for (ll=0; ll<=RES_X; ll++) for (kk=0; kk<=RES_Y; kk++) { line = ll * lines / RES_Y; sample = kk * samples / RES_X; if (meta->sar->image_type=='P') { px = meta->projection->startX + meta->projection->perX * sample; py = meta->projection->startY + meta->projection->perY * line; proj_to_latlon(meta->projection, px, py, 0.0, &latitude, &longitude, &height); latLon2timeSlant(meta, latitude, longitude, &time, &range, &doppler); } else time = meta_get_time(meta, line, sample); stVec = meta_get_stVec(meta, time); if (meta->sar->image_type=='P') { if (meta->projection->type==SCANSAR_PROJECTION) earth_radius = meta->projection->param.atct.rlocal; else asfPrintError("Unable to determine earth radius.\n"); } else earth_radius = my_get_earth_radius(time, stVec, re, rp); satellite_height = my_get_satellite_height(time, stVec); range = my_get_slant_range(meta, earth_radius, satellite_height, line, sample); look_angle = my_get_look_angle(earth_radius, satellite_height, range); incidence_angle = my_get_incidence_angle(earth_radius, satellite_height, range); if (ll==0 && kk==0) { firstLook = look_angle * R2D; firstIncid = incidence_angle * R2D; firstRange = range; } if (flags[f_LOOK] != FLAG_NOT_SET) fprintf(fpLook, "%.18f %.12f %.12f\n", (float)look_angle*R2D, line, sample); if (flags[f_INCIDENCE] != FLAG_NOT_SET) fprintf(fpIncid, "%.18f %.12f %.12f\n", (float)incidence_angle*R2D, line, sample); if (flags[f_RANGE] != FLAG_NOT_SET) fprintf(fpRange, "%.18f %.12f %.12f\n", (float)range, line, sample); } } /* Close files for now */ if (flags[f_LOOK] != FLAG_NOT_SET) { FCLOSE(fpLook); FREE(bufLook); } if (flags[f_INCIDENCE] != FLAG_NOT_SET) { FCLOSE(fpIncid); FREE(bufIncid); } if (flags[f_RANGE] != FLAG_NOT_SET) { FCLOSE(fpRange); FREE(bufRange); } /* Calculate plots */ if (flags[f_LOOK] != FLAG_NOT_SET) { create_name(outFile, outBase, "_look.plot"); calculate_plot("Look angle", outLook, dataFile, maskFile, outFile, meta, firstLook); } if (flags[f_INCIDENCE] != FLAG_NOT_SET) { create_name(outFile, outBase, "_incid.plot"); calculate_plot("Incidence angle", outIncid, dataFile, maskFile, outFile, meta, firstIncid); } if (flags[f_RANGE] != FLAG_NOT_SET) { create_name(outFile, outBase, "_range.plot"); calculate_plot("Range", outRange, dataFile, maskFile, outFile, meta, firstRange); } if (flags[f_LINE] != FLAG_NOT_SET) { create_name(outFile, outBase, "_line.plot"); calculate_plot("Line", NULL, dataFile, maskFile, outFile, meta, 0.0); } if (flags[f_SAMPLE] != FLAG_NOT_SET) { create_name(outFile, outBase, "_sample.plot"); calculate_plot("Sample", NULL, dataFile, maskFile, outFile, meta, 0.0); } /* Clean up */ sprintf(cmd, "rm -rf tmp*"); system(cmd); exit(0); }
// Main program body. int main (int argc, char *argv[]) { output_format_t format = 0; meta_parameters *md; char *in_base_name, *output_name; char **band_names=NULL; int rgb=0; int true_color; int false_color; int num_bands_found; int ignored[3] = {0, 0, 0}; int num_ignored = 0; in_base_name = (char *) MALLOC(sizeof(char)*255); output_name = (char *) MALLOC(sizeof(char)*255); /**********************BEGIN COMMAND LINE PARSING STUFF**********************/ // Command line input goes in it's own structure. command_line_parameters_t command_line; strcpy (command_line.format, ""); command_line.size = NO_MAXIMUM_OUTPUT_SIZE; strcpy (command_line.in_data_name, ""); strcpy (command_line.in_meta_name, ""); strcpy (command_line.output_name, ""); command_line.verbose = FALSE; command_line.quiet = FALSE; strcpy (command_line.leader_name, ""); strcpy (command_line.cal_params_file, ""); strcpy (command_line.cal_comment, ""); command_line.sample_mapping = 0; strcpy(command_line.red_channel, ""); strcpy(command_line.green_channel, ""); strcpy(command_line.blue_channel, ""); strcpy(command_line.band, ""); strcpy(command_line.look_up_table_name, ""); int formatFlag, logFlag, quietFlag, byteFlag, rgbFlag, bandFlag, lutFlag; int truecolorFlag, falsecolorFlag; int needed_args = 3; //command & argument & argument int ii; char sample_mapping_string[25]; //Check to see which options were specified if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } get_asf_share_dir_with_argv0(argv[0]); handle_license_and_version_args(argc, argv, ASF_NAME_STRING); formatFlag = checkForOption ("-format", argc, argv); logFlag = checkForOption ("-log", argc, argv); quietFlag = checkForOption ("-quiet", argc, argv); byteFlag = checkForOption ("-byte", argc, argv); rgbFlag = checkForOption ("-rgb", argc, argv); bandFlag = checkForOption ("-band", argc, argv); lutFlag = checkForOption ("-lut", argc, argv); truecolorFlag = checkForOption("-truecolor", argc, argv); falsecolorFlag = checkForOption("-falsecolor", argc, argv); if ( formatFlag != FLAG_NOT_SET ) { needed_args += 2; // Option & parameter. } if ( quietFlag != FLAG_NOT_SET ) { needed_args += 1; // Option & parameter. } if ( logFlag != FLAG_NOT_SET ) { needed_args += 2; // Option & parameter. } if ( byteFlag != FLAG_NOT_SET ) { needed_args += 2; // Option & parameter. } if ( rgbFlag != FLAG_NOT_SET ) { needed_args += 4; // Option & 3 parameters. } if ( bandFlag != FLAG_NOT_SET ) { needed_args += 2; // Option & parameter. } if ( lutFlag != FLAG_NOT_SET ) { needed_args += 2; // Option & parameter. } if ( truecolorFlag != FLAG_NOT_SET ) { needed_args += 1; // Option only } if ( falsecolorFlag != FLAG_NOT_SET ) { needed_args += 1; // Option only } if ( argc != needed_args ) { print_usage (); // This exits with a failure. } // We also need to make sure the last three options are close to // what we expect. if ( argv[argc - 1][0] == '-' || argv[argc - 2][0] == '-' ) { print_usage (); // This exits with a failure. } // Make sure any options that have parameters are followed by // parameters (and not other options) Also make sure options' // parameters don't bleed into required arguments. if ( formatFlag != FLAG_NOT_SET ) { if ( argv[formatFlag + 1][0] == '-' || formatFlag >= argc - 3 ) { print_usage (); } } if ( byteFlag != FLAG_NOT_SET ) { if ( argv[byteFlag + 1][0] == '-' || byteFlag >= argc - 3 ) { print_usage (); } } if ( rgbFlag != FLAG_NOT_SET ) { if (( argv[rgbFlag + 1][0] == '-' && argv[rgbFlag + 2][0] == '-' && argv[rgbFlag + 3][0] == '-' ) || rgbFlag >= argc - 5 ) { print_usage (); } } if ( bandFlag != FLAG_NOT_SET ) { if ( argv[bandFlag + 1][0] == '-' || bandFlag >= argc - 3 ) { print_usage (); } } if ( lutFlag != FLAG_NOT_SET ) { if ( argv[lutFlag + 1][0] == '-' || lutFlag >= argc - 3 ) { print_usage (); } } if ( logFlag != FLAG_NOT_SET ) { if ( argv[logFlag + 1][0] == '-' || logFlag >= argc - 3 ) { print_usage (); } } // Make sure there are no flag incompatibilities if ( (rgbFlag != FLAG_NOT_SET && (bandFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET)) || (bandFlag != FLAG_NOT_SET && (rgbFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET)) || (truecolorFlag != FLAG_NOT_SET && (bandFlag != FLAG_NOT_SET || rgbFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET)) || (falsecolorFlag != FLAG_NOT_SET && (bandFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || rgbFlag != FLAG_NOT_SET)) ) { asfPrintWarning("The following options may only be used one at a time:\n" " %s\n %s\n %s\n %s\n %s\n %s\n", "-rgb", "-truecolor", "-falsecolor", "-band"); print_help(); } if ( (rgbFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET) && lutFlag != FLAG_NOT_SET ) asfPrintError("Look up table option can only be used on single-band " "images.\n"); if( logFlag != FLAG_NOT_SET ) { strcpy(logFile, argv[logFlag+1]); } else { sprintf(logFile, "tmp%i.log", (int)getpid()); } logflag = TRUE; // Since we always log, set the old school logflag to true fLog = FOPEN (logFile, "a"); // Set old school quiet flag (for use in our libraries) quietflag = ( quietFlag != FLAG_NOT_SET ) ? TRUE : FALSE; // We're good enough at this point... print the splash screen. asfSplashScreen (argc, argv); // Grab the input and output name strcpy (in_base_name, argv[argc - 2]); strcpy (output_name, argv[argc - 1]); strcpy (command_line.output_name, output_name); // If user added ".img", strip it. char *ext = findExt(in_base_name); if (ext && strcmp(ext, ".img") == 0) *ext = '\0'; // Set default output type if( formatFlag != FLAG_NOT_SET ) { strcpy (command_line.format, argv[formatFlag + 1]); } else { // Default behavior: produce a geotiff. strcpy (command_line.format, "geotiff"); } // Compose input metadata name strcpy (command_line.in_meta_name, in_base_name); strcat (command_line.in_meta_name, ".meta"); // for some validation, need the metadata md = meta_read (command_line.in_meta_name); // Convert the string to upper case. for ( ii = 0 ; ii < strlen (command_line.format) ; ++ii ) { command_line.format[ii] = toupper (command_line.format[ii]); } if (strcmp (command_line.format, "PGM") == 0 && (rgbFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET) ) { asfPrintWarning("Greyscale PGM output is not compatible with color options:\n" "(RGB, True Color, False Color, color look-up tables, etc\n)" "...Defaulting to producing separate greyscale PGM files for available band.\n"); rgbFlag = FLAG_NOT_SET; truecolorFlag = FLAG_NOT_SET; falsecolorFlag = FLAG_NOT_SET; } // Set the default byte scaling mechanisms if (md->optical) { // for optical data, default sample mapping is NONE command_line.sample_mapping = NONE; } // for other data, default is based on the output type else if (strcmp (command_line.format, "TIFF") == 0 || strcmp (command_line.format, "TIF") == 0 || strcmp (command_line.format, "JPEG") == 0 || strcmp (command_line.format, "JPG") == 0 || strcmp (command_line.format, "PNG") == 0 || strcmp (command_line.format, "PGM") == 0 || strcmp (command_line.format, "PNG_ALPHA") == 0 || strcmp (command_line.format, "PNG_GE") == 0) { command_line.sample_mapping = SIGMA; } else if (strcmp (command_line.format, "GEOTIFF") == 0) { command_line.sample_mapping = NONE; } if ( quietFlag != FLAG_NOT_SET ) command_line.quiet = TRUE; else command_line.quiet = FALSE; // Set rgb combination if ( rgbFlag != FLAG_NOT_SET ) { int i; for (i=0, num_ignored = 0; i<3; i++) { ignored[i] = strncmp("IGNORE", uc(argv[rgbFlag + i + 1]), 6) == 0 ? 1 : 0; num_ignored += ignored[i] ? 1 : 0; } asfRequire(num_ignored < 3, "Cannot ignore all bands. Exported image would be blank.\n"); strcpy (command_line.red_channel, ignored[0] ? "Ignored" : argv[rgbFlag + 1]); strcpy (command_line.green_channel, ignored[1] ? "Ignored" : argv[rgbFlag + 2]); strcpy (command_line.blue_channel, ignored[2] ? "Ignored" : argv[rgbFlag + 3]); // Check to see if the bands are numeric and in range int r_channel = atoi(command_line.red_channel); int g_channel = atoi(command_line.green_channel); int b_channel = atoi(command_line.blue_channel); /////////// Numeric channel case //////////// // Remove trailing non-numeric characters from the channel number // string and pad front end nicely with a zero if (!ignored[0] && is_numeric(command_line.red_channel) && r_channel >= 1 && r_channel <= MAX_BANDS) { sprintf(command_line.red_channel, "%02d", atoi(command_line.red_channel)); } if (!ignored[1] && is_numeric(command_line.green_channel) && g_channel >= 1 && g_channel <= MAX_BANDS) { sprintf(command_line.green_channel, "%02d", atoi(command_line.green_channel)); } if (!ignored[2] && is_numeric(command_line.blue_channel) && b_channel >= 1 && b_channel <= MAX_BANDS) { sprintf(command_line.blue_channel, "%02d", atoi(command_line.blue_channel)); } } // Set up the bands for true or false color optical data true_color = false_color = 0; int with_sigma = FALSE; if (truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET) { int ALOS_optical = (md->optical && strncmp(md->general->sensor, "ALOS", 4) == 0) ? 1 : 0; if (md->optical && truecolorFlag != FLAG_NOT_SET) { if (ALOS_optical) { with_sigma = TRUE; strcpy(command_line.red_channel, "03"); strcpy(command_line.green_channel, "02"); strcpy(command_line.blue_channel, "01"); true_color = 1; asfPrintStatus("Applying True Color contrast expansion to following channels:"); } else { char **bands = extract_band_names(md->general->bands, 3); asfRequire(bands != NULL, "-truecolor option specified for non-true color optical image.\n"); asfPrintWarning("Attempting to use the -truecolor option with non-ALOS\n" "optical data.\n"); strcpy(command_line.red_channel, bands[2]); strcpy(command_line.green_channel, bands[1]); strcpy(command_line.blue_channel, bands[0]); int i; for (i=0; i<3; i++) { FREE(bands[i]); } FREE(bands); } } if (md->optical && falsecolorFlag != FLAG_NOT_SET) { if (ALOS_optical) { with_sigma = TRUE; strcpy(command_line.red_channel, "04"); strcpy(command_line.green_channel, "03"); strcpy(command_line.blue_channel, "02"); false_color = 1; asfPrintStatus("Applying False Color contrast expansion to the following channels:"); } else { char **bands = extract_band_names(md->general->bands, 4); asfRequire(bands != NULL, "-falsecolor option specified for an optical image with fewer than 4 bands.\n"); asfPrintWarning("Attempting to use the -falsecolor option with non-ALOS\n" "optical data.\n"); strcpy(command_line.red_channel, bands[3]); strcpy(command_line.green_channel, bands[2]); strcpy(command_line.blue_channel, bands[1]); int i; for (i=0; i<3; i++) { FREE(bands[i]); } FREE(bands); } } if (!ALOS_optical && !md->optical) { asfPrintError("-truecolor or -falsecolor option selected with non-optical data\n"); } } if (rgbFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET) { char red_band[16], green_band[16], blue_band[16]; asfPrintStatus("\nRed channel : %s %s\n", command_line.red_channel, sigma_str(with_sigma)); asfPrintStatus("Green channel: %s %s\n", command_line.green_channel, sigma_str(with_sigma)); asfPrintStatus("Blue channel : %s %s\n\n", command_line.blue_channel, sigma_str(with_sigma)); if (is_numeric(command_line.red_channel) && is_numeric(command_line.green_channel) && is_numeric(command_line.blue_channel)) { sprintf(red_band, "%02d", atoi(command_line.red_channel)); sprintf(green_band, "%02d", atoi(command_line.green_channel)); sprintf(blue_band, "%02d", atoi(command_line.blue_channel)); band_names = find_bands(in_base_name, rgbFlag, red_band, green_band, blue_band, &num_bands_found); } else { band_names = find_bands(in_base_name, rgbFlag, command_line.red_channel, command_line.green_channel, command_line.blue_channel, &num_bands_found); } } // Set band if ( bandFlag != FLAG_NOT_SET) { strcpy (command_line.band, argv[bandFlag + 1]); band_names = find_single_band(in_base_name, command_line.band, &num_bands_found); } else if (rgbFlag == FLAG_NOT_SET && truecolorFlag == FLAG_NOT_SET && falsecolorFlag == FLAG_NOT_SET && bandFlag == FLAG_NOT_SET) { bandFlag=1; // For proper messaging to the user strcpy (command_line.band, "all"); band_names = find_single_band(in_base_name, command_line.band, &num_bands_found); } // Read look up table name if ( lutFlag != FLAG_NOT_SET) { strcpy(command_line.look_up_table_name, argv[lutFlag + 1]); rgb = 1; } // Set scaling mechanism if ( byteFlag != FLAG_NOT_SET ) { strcpy (sample_mapping_string, argv[byteFlag + 1]); for ( ii = 0; ii < strlen(sample_mapping_string); ii++) { sample_mapping_string[ii] = toupper (sample_mapping_string[ii]); } if ( strcmp (sample_mapping_string, "TRUNCATE") == 0 ) command_line.sample_mapping = TRUNCATE; else if ( strcmp(sample_mapping_string, "MINMAX") == 0 ) command_line.sample_mapping = MINMAX; else if ( strcmp(sample_mapping_string, "SIGMA") == 0 ) command_line.sample_mapping = SIGMA; else if ( strcmp(sample_mapping_string, "HISTOGRAM_EQUALIZE") == 0 ) command_line.sample_mapping = HISTOGRAM_EQUALIZE; else if ( strcmp(sample_mapping_string, "NONE") == 0 ) { asfPrintWarning("Sample remapping method (-byte option) is set to NONE\n" "which doesn't make sense. Defaulting to TRUNCATE...\n"); command_line.sample_mapping = TRUNCATE; } else asfPrintError("Unrecognized byte scaling method '%s'.\n", sample_mapping_string); } int is_polsarpro = (md->general->bands && strstr(md->general->bands, "POLSARPRO") != NULL) ? 1 : 0; if ( !is_polsarpro && lutFlag != FLAG_NOT_SET && bandFlag == FLAG_NOT_SET && md->general->band_count > 1) { asfPrintError("Look up tables can only be applied to single band" " images\n"); } if ( !is_polsarpro && lutFlag != FLAG_NOT_SET && command_line.sample_mapping == NONE && md->general->data_type != BYTE && md->general->band_count == 1) { asfPrintError("Look up tables can only be applied to byte output" " images\n"); } // Report what is going to happen if (rgbFlag != FLAG_NOT_SET || truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET) { if (num_bands_found >= 3) { asfPrintStatus("Exporting multiband image ...\n\n"); rgb = 1; } else { asfPrintError("Not all RGB channels found.\n"); } } else if (bandFlag != FLAG_NOT_SET) { if (strcmp_case(command_line.band, "ALL") == 0) { if (multiband(command_line.format, extract_band_names(md->general->bands, md->general->band_count), md->general->band_count)) asfPrintStatus("Exporting multiband image ...\n\n"); else if (num_bands_found > 1) asfPrintStatus("Exporting each band into individual greyscale files ...\n\n"); } else if (num_bands_found == 1) { if (lutFlag != FLAG_NOT_SET) asfPrintStatus("Exporting band '%s' applying look up table ...\n\n", command_line.band); else asfPrintStatus("Exporting band '%s' as greyscale ...\n\n", command_line.band); } else asfPrintError("Band could not be found in the image.\n"); } else if (lutFlag != FLAG_NOT_SET) asfPrintStatus("Exporting applying look up table.\n\n"); else asfPrintStatus("Exporting as greyscale.\n\n"); //If user added ".img", strip it. ext = findExt(in_base_name); if (ext && strcmp(ext, ".img") == 0) *ext = '\0'; meta_free(md); /***********************END COMMAND LINE PARSING STUFF***********************/ if ( strcmp (command_line.format, "ENVI") == 0 ) { format = ENVI; } else if ( strcmp (command_line.format, "ESRI") == 0 ) { format = ESRI; } else if ( strcmp (command_line.format, "GEOTIFF") == 0 || strcmp (command_line.format, "GEOTIF") == 0) { format = GEOTIFF; } else if ( strcmp (command_line.format, "TIFF") == 0 || strcmp (command_line.format, "TIF") == 0) { format = TIF; } else if ( strcmp (command_line.format, "JPEG") == 0 || strcmp (command_line.format, "JPG") == 0) { format = JPEG; } else if ( strcmp (command_line.format, "PGM") == 0 ) { format = PGM; } else if ( strcmp (command_line.format, "PNG") == 0 ) { format = PNG; } else if ( strcmp (command_line.format, "PNG_ALPHA") == 0 ) { format = PNG_ALPHA; } else if ( strcmp (command_line.format, "PNG_GE") == 0 ) { format = PNG_GE; } else if ( strcmp (command_line.format, "KML") == 0 ) { format = KML; } else if ( strcmp (command_line.format, "POLSARPRO") == 0 ) { format = POLSARPRO_HDR; } else if ( strcmp (command_line.format, "HDF5") == 0 ) { format = HDF; } else if ( strcmp (command_line.format, "NETCDF") == 0 ) { format = NC; } else { asfPrintError("Unrecognized output format specified\n"); } /* Complex data generally can't be output into meaningful images, so we refuse to deal with it. */ /* md = meta_read (command_line.in_meta_name); asfRequire ( md->general->data_type == BYTE || md->general->data_type == INTEGER16 || md->general->data_type == INTEGER32 || md->general->data_type == REAL32 || md->general->data_type == REAL64, "Cannot cope with complex data, exiting...\n"); meta_free (md); */ // Do that exporting magic! asf_export_bands(format, command_line.sample_mapping, rgb, true_color, false_color, command_line.look_up_table_name, in_base_name, command_line.output_name, band_names, NULL, NULL); // If the user didn't ask for a log file then nuke the one that's been kept // since everything has finished successfully if (logFlag == FLAG_NOT_SET) { fclose (fLog); remove(logFile); } for (ii = 0; ii<num_bands_found; ii++) { FREE(band_names[ii]); } FREE(band_names); FREE(in_base_name); FREE(output_name); exit (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { dem_config *cfg=NULL; int createFlag = FLAG_NOT_SET; char configFile[255]; // Check for all those little helper options if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } handle_license_and_version_args(argc, argv, ASF_NAME_STRING); // Check which options were provided createFlag = checkForOption("-create", argc, argv); // We need to make sure the user specified the proper number of arguments int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS if (createFlag != FLAG_NOT_SET) needed_args += 1; // option // Make sure we have the right number of args if(argc != needed_args) { print_usage(); } if (createFlag != FLAG_NOT_SET) createFlag = 1; else createFlag = 0; // Fetch required arguments strcpy(configFile, argv[argc-1]); // Report the command line asfSplashScreen(argc, argv); // If requested, create a config file and exit (if the file does not exist), // otherwise read it if ( createFlag==TRUE && !fileExists(configFile) ) { init_config(configFile); exit(EXIT_SUCCESS); } // Extend the configuration file if the file already exist else if ( createFlag==TRUE && fileExists(configFile) ) { cfg = read_config(configFile, createFlag); // Assign names for results to be kept sprintf(cfg->igram_coh->igram, "%s_igram", cfg->general->base); sprintf(cfg->igram_coh->coh, "%s_coh.img", cfg->general->base); sprintf(cfg->coreg->master_power, "%s_a_pwr.img", cfg->general->base); sprintf(cfg->coreg->slave_power, "%s_b_pwr.img", cfg->general->base); sprintf(cfg->refine->seeds, "%s.seeds", cfg->general->base); sprintf(cfg->dinsar->igram, "%s_digram.img", cfg->general->base); sprintf(cfg->unwrap->qc, "%s_qc_phase.img", cfg->general->base); sprintf(cfg->elevation->dem, "%s_ht.img", cfg->general->base); sprintf(cfg->elevation->error, "%s_err_ht.img", cfg->general->base); sprintf(cfg->geocode->dem, "%s_dem", cfg->general->base); sprintf(cfg->geocode->amp, "%s_amp", cfg->general->base); sprintf(cfg->geocode->error, "%s_error", cfg->general->base); sprintf(cfg->geocode->coh, "%s_coh", cfg->general->base); asfRequire( 0==write_config(configFile, cfg), "Could not update configuration file"); asfPrintStatus(" Initialized complete configuration file\n\n"); exit(EXIT_SUCCESS); } else if (!fileExists(configFile)) asfPrintError("Configuration file does not exist!\n"); else { cfg = read_config(configFile, createFlag); } /* Setup log file */ sprintf(logFile, "%s.log", cfg->general->base); if (strncmp(cfg->general->status, "new", 3)==0) fLog = FOPEN(logFile, "w"); else fLog = FOPEN(logFile, "a"); if (argc == 3) { sprintf(logbuf, "\nCommand line: ips -c %s\n", configFile); printLog(logbuf); } else { sprintf(logbuf, "\nCommand line: ips %s\n", configFile); printLog(logbuf); } sprintf(logbuf, "Program: ips\n\n"); printLog(logbuf); FCLOSE(fLog); return ips(cfg, configFile, createFlag); }
int main(int argc, char *argv[]) { char inFile[512], outFile[512], *projFile=NULL, type[10]; const int pid = getpid(); extern int logflag, quietflag; int quiet_f; /* log_f is a static global */ int proj_f, pixel_f, list_f, ii, file_count, list=FALSE; char **import_files; double pixel_size = -99; logflag = quietflag = FALSE; log_f = quiet_f = FLAG_NOT_SET; // Begin command line parsing *********************************************** if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } get_asf_share_dir_with_argv0(argv[0]); handle_license_and_version_args(argc, argv, ASF_NAME_STRING); // Check which options were provided log_f = checkForOption("-log", argc, argv); quiet_f = checkForOption("-quiet", argc, argv); proj_f = checkForOption("-proj", argc, argv); pixel_f = checkForOption("-pixel-size", argc, argv); list_f = checkForOption("-list", argc, argv); // We need to make sure the user specified the proper number of arguments int needed_args = 3 + REQUIRED_ARGS; // command & REQUIRED_ARGS int num_flags = 0; if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (quiet_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option if (proj_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (pixel_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (list_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option // Make sure we have the right number of args if(argc != needed_args) { print_usage(); } // Make sure all options occur before the config file name argument if (num_flags == 1 && (log_f > 1 || quiet_f > 1)) { print_usage(); } else if (num_flags > 1 && (log_f >= argc - REQUIRED_ARGS - 1 || quiet_f >= argc - REQUIRED_ARGS - 1)) { print_usage(); } if (proj_f != FLAG_NOT_SET) { projFile = (char *) MALLOC(sizeof(char)*512); strcpy(projFile, argv[proj_f+1]); } if (pixel_f != FLAG_NOT_SET) { pixel_size = atof(argv[pixel_f+1]); } if (list_f != FLAG_NOT_SET) { list = TRUE; } if (log_f != FLAG_NOT_SET) { strcpy(logFile, argv[log_f+1]); } else { // default behavior: log to tmp<pid>.log sprintf(logFile, "tmp%i.log", pid); } logflag = TRUE; fLog = FOPEN(logFile, "a"); // Set old school quiet flag (for use in our libraries) quietflag = quiet_f != FLAG_NOT_SET; // Fetch required arguments strcpy(inFile, argv[argc-3]); strcpy(outFile, argv[argc-2]); strcpy(type, argv[argc-1]); // Report the command line asfSplashScreen(argc, argv); char *tmp_dir = (char *) MALLOC(sizeof(char)*512); char *tmpFile = (char *) MALLOC(sizeof(char)*512); if (projFile || list || (strcmp_case(type, "ASTER") == 0 && strcmp_case(findExt(inFile), ".ZIP") == 0)) { strcpy(tmp_dir, "tmp_dem-"); strcat(tmp_dir, time_stamp_dir()); create_clean_dir(tmp_dir); sprintf(tmpFile, "%s%cimport", tmp_dir, DIR_SEPARATOR); import_dem(inFile, list, tmpFile, type, tmp_dir, &import_files, &file_count); } else { strcpy(tmp_dir, "./"); import_dem(inFile, list, outFile, type, tmp_dir, &import_files, &file_count); } if (projFile) { project_parameters_t pps; projection_type_t proj_type; datum_type_t datum; spheroid_type_t spheroid; if (fileExists(projFile)) read_proj_file(projFile, &pps, &proj_type, &datum, &spheroid); else { projFile = get_proj_file(projFile); read_proj_file(projFile, &pps, &proj_type, &datum, &spheroid); } if (file_count > 1) asf_mosaic(&pps, proj_type, FALSE, RESAMPLE_BILINEAR, 0.0, datum, spheroid, pixel_size, FALSE, 0, import_files, outFile, 0.0, -999, 999, -999, 999, "OVERLAY", FALSE); else asf_geocode(&pps, proj_type, FALSE, RESAMPLE_BILINEAR, 0.0, datum, pixel_size, NULL, tmpFile, outFile, 0.0, FALSE); } else if (strlen(tmp_dir) > 2) { /* char *imgFile = (char *) MALLOC(sizeof(char)*512); char *metaFile = (char *) MALLOC(sizeof(char)*512); for (ii=0; ii<file_count; ii++) { sprintf(imgFile, "%s.img", get_basename(import_files[ii])); fileCopy(import_files[ii], imgFile); sprintf(metaFile, "%s.meta", get_basename(import_files[ii])); sprintf(tmpFile, "%s%c%s.meta", tmp_dir, DIR_SEPARATOR, get_basename(import_files[ii])); fileCopy(tmpFile, metaFile); } FREE(imgFile); FREE(metaFile); */ combine(import_files, file_count, outFile); } for (ii=0; ii<file_count; ii++) FREE(import_files[ii]); FREE(import_files); if (strlen(tmp_dir) > 2) remove_dir(tmp_dir); FREE(tmp_dir); FREE(tmpFile); asfPrintStatus("\nSuccessful completion!\n\n"); FCLOSE(fLog); remove(logFile); return(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char configFile[1024], interface[25]; int createflag, unitflag, cleanflag; extern int logflag; int create_f, clean_f, log_f; createflag = unitflag = cleanflag = FALSE; create_f = clean_f, FLAG_NOT_SET; // Begin command line parsing *********************************************** if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } get_asf_share_dir_with_argv0(argv[0]); handle_license_and_version_args(argc, argv, ASF_NAME_STRING); // Check which options were provided create_f = checkForOption("-create", argc, argv); clean_f = checkForOption("-clean", argc, argv); log_f = checkForOption("-log", argc, argv); // We need to make sure the user specified the proper number of arguments int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS int num_flags = 0; if (create_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option if (clean_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param // Make sure we have the right number of args if (argc != needed_args) { print_usage(); } // Make sure argument for each flag (that requires an arg) is not another // option flag & is not a required argument if (log_f != FLAG_NOT_SET) { if ((argv[log_f+1][0]=='-') || (log_f>=(argc-REQUIRED_ARGS))) { print_usage(); } } // Make sure all options occur before the config file name argument if (num_flags == 1 && (create_f > 1 || log_f > 1)) { print_usage(); } else if (num_flags > 1 && (create_f >= argc - REQUIRED_ARGS - 1 || log_f >= argc - REQUIRED_ARGS - 1)) { print_usage(); } // Do the actual flagging & such for each flag if (create_f != FLAG_NOT_SET) { createflag = TRUE; } if (clean_f != FLAG_NOT_SET) { cleanflag = TRUE; } if (log_f != FLAG_NOT_SET) { strcpy(logFile, argv[log_f+1]); logflag = TRUE; fLog = FOPEN(logFile, "w"); } // Fetch required arguments strcpy(interface, argv[argc-2]); strcpy(configFile, argv[argc-1]); // Report the command line asfSplashScreen(argc, argv); // End command line parsing ************************************************* // Get test information from configuration file test_config *cfg; char line[1024]; // Creating configuration files if (createflag && !fileExists(configFile)) { init_test_config(configFile); return(EXIT_SUCCESS); } else if (createflag && fileExists(configFile)) { cfg = read_test_config(configFile); check_return(write_test_config(configFile, cfg), "Could not update configuration file"); free_test_config(cfg); return(EXIT_SUCCESS); } else if (!fileExists(configFile)) asfPrintError("Could not find config file (%s)\n", configFile); // Unit tests or single configuration file? if (strcmp_case(interface, "basic") == 0 || strcmp_case(interface, "automated") == 0) unitflag = TRUE; if (unitflag) { extern int quietflag; quietflag = 2; if (CUE_SUCCESS != CU_initialize_registry()) return CU_get_error(); int test = FALSE; FILE *fpList = FOPEN(configFile, "r"); while(fgets(line, 1024, fpList)) { if (strcmp_case(trim_spaces(line), "uavsar_metadata") == 0) add_uavsar_metadata_tests(); if (strcmp_case(trim_spaces(line), "uavsar_geotiff") == 0) add_uavsar_geotiff_tests(); if (strcmp_case(trim_spaces(line), "rsat1_map_projections") == 0) add_rsat1_map_projections_tests(); if (strcmp_case(trim_spaces(line), "rsat1_geotiff") == 0) add_rsat1_geotiff_tests(); if (strcmp_case(trim_spaces(line), "alos_browse") == 0) add_alos_browse_tests(); if (strcmp_case(trim_spaces(line), "alos_leader") == 0) add_alos_leader_tests(); if (strcmp_case(trim_spaces(line), "rsat1_overlay") == 0) add_rsat1_overlay_tests(); if (strcmp_case(trim_spaces(line), "alos_calibration") == 0) add_alos_calibration_tests(); test = TRUE; } FCLOSE(fpList); if (test && strcmp_case(interface, "basic") == 0) { asfPrintStatus("Running tests in basic mode ...\n"); CU_basic_set_mode(CU_BRM_VERBOSE); if (CUE_SUCCESS != CU_basic_run_tests()) { CU_cleanup_registry(); return CU_get_error(); } } if (test && strcmp_case(interface, "automated") == 0) { asfPrintStatus("Running tests in automated mode ...\n\n"); CU_set_output_filename("asf_tools"); CU_automated_run_tests(); CU_list_tests_to_file(); } CU_cleanup_registry(); if (cleanflag) cleanup_test_results(configFile); } else { // Configuration file for manual mode cfg = read_test_config(configFile); asfPrintStatus("Running tests in manual mode ...\n\n"); // Run metadata tests if (strcmp_case(cfg->general->type, "metadata") == 0) manual_metadata(configFile); // Run geotiff tests else if (strcmp_case(cfg->general->type, "geotiff") == 0) manual_geotiff(configFile); // Run binary tests else if (strcmp_case(cfg->general->type, "binary") == 0) manual_binary(configFile); // Run library tests else if (strcmp_case(cfg->general->type, "library") == 0) manual_library(configFile); free_test_config(cfg); } return(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char inFile[512], *configFile=NULL, type[10]; const int pid = getpid(); extern int logflag, quietflag; int quiet_f; /* log_f is a static global */ int createFlag = FLAG_NOT_SET; // create configuration file flag int configFlag = FLAG_NOT_SET; // use configuration file flag logflag = quietflag = FALSE; log_f = quiet_f = FLAG_NOT_SET; // Begin command line parsing *********************************************** if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET) || (checkForOption("-h", argc, argv) != FLAG_NOT_SET) || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) { print_help(); } get_asf_share_dir_with_argv0(argv[0]); handle_license_and_version_args(argc, argv, ASF_NAME_STRING); // Check which options were provided log_f = checkForOption("-log", argc, argv); quiet_f = checkForOption("-quiet", argc, argv); createFlag = checkForOption("-create", argc, argv); configFlag = checkForOption("-config", argc, argv); // We need to make sure the user specified the proper number of arguments int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS int num_flags = 0; if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param if (quiet_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option if (createFlag != FLAG_NOT_SET) {needed_args += 3; num_flags++;} // option & params if (configFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param // Make sure we have the right number of args if(argc != needed_args) { print_usage(); } // Make sure all options occur before the config file name argument if (num_flags == 1 && (log_f > 1 || quiet_f > 1)) { print_usage(); } else if (num_flags > 1 && (log_f >= argc - REQUIRED_ARGS - 1 || quiet_f >= argc - REQUIRED_ARGS - 1)) { print_usage(); } // Make sure that only one option is used if (createFlag != FLAG_NOT_SET && configFlag != FLAG_NOT_SET) asfPrintError("The tool can either create or use the " "configuration file, not both!\n"); // Do the actual flagging & such for each flag if (createFlag != FLAG_NOT_SET) { sprintf(type, "%s", argv[createFlag+1]); configFile = (char *) MALLOC(sizeof(char)*1024); sprintf(configFile, "%s", argv[createFlag+2]); } if (configFlag != FLAG_NOT_SET) { configFile = (char *) MALLOC(sizeof(char)*1024); sprintf(configFile, "%s", argv[configFlag+1]); } if (log_f != FLAG_NOT_SET) { strcpy(logFile, argv[log_f+1]); } else { // default behavior: log to tmp<pid>.log sprintf(logFile, "tmp%i.log", pid); } logflag = TRUE; fLog = FOPEN(logFile, "a"); // Set old school quiet flag (for use in our libraries) quietflag = quiet_f != FLAG_NOT_SET; // Fetch required arguments strcpy(inFile, argv[argc-1]); // Report the command line asfSplashScreen(argc, argv); // Initialze structure dataset_t *data = (dataset_t *) MALLOC(sizeof(dataset_t)); strcpy(data->dataset_id, MAGIC_UNSET_STRING); strcpy(data->origin, MAGIC_UNSET_STRING); strcpy(data->title, MAGIC_UNSET_STRING); strcpy(data->online_link, MAGIC_UNSET_STRING); data->west_bounding = MAGIC_UNSET_DOUBLE; data->east_bounding = MAGIC_UNSET_DOUBLE; data->north_bounding = MAGIC_UNSET_DOUBLE; data->south_bounding = MAGIC_UNSET_DOUBLE; data->near_start_lat = MAGIC_UNSET_DOUBLE; data->near_start_lon = MAGIC_UNSET_DOUBLE; data->far_start_lat = MAGIC_UNSET_DOUBLE; data->far_start_lon = MAGIC_UNSET_DOUBLE; data->far_end_lat = MAGIC_UNSET_DOUBLE; data->far_end_lon = MAGIC_UNSET_DOUBLE; data->near_end_lat = MAGIC_UNSET_DOUBLE; data->near_end_lon = MAGIC_UNSET_DOUBLE; data->center_lat = MAGIC_UNSET_DOUBLE; data->center_lon = MAGIC_UNSET_DOUBLE; strcpy(data->processing_level, MAGIC_UNSET_STRING); strcpy(data->platform, MAGIC_UNSET_STRING); strcpy(data->instrument, MAGIC_UNSET_STRING); data->band_count = MAGIC_UNSET_INT; data->browse_location = NULL; data->browse_format = NULL; strcpy(data->access, MAGIC_UNSET_STRING); strcpy(data->copyright, MAGIC_UNSET_STRING); data->start_time = NULL; data->center_time = NULL; data->end_time = NULL; strcpy(data->orbit_direction, MAGIC_UNSET_STRING); strcpy(data->mode, MAGIC_UNSET_STRING); strcpy(data->spatial_reference, MAGIC_UNSET_STRING); strcpy(data->cell_value, MAGIC_UNSET_STRING); strcpy(data->raster_object, MAGIC_UNSET_STRING); data->row_count = MAGIC_UNSET_INT; data->col_count = MAGIC_UNSET_INT; strcpy(data->format, MAGIC_UNSET_STRING); data->fees = MAGIC_UNSET_DOUBLE; // Open XML for reading xmlDoc *doc = xmlReadFile(inFile, NULL, 0); if (!doc) asfPrintError("Could not parse metadata file (%s)\n", inFile); // Read in all parameters and perform error checking char string[512], tmp[255], errorMessage[8192]="Metadata parsing errors:\n"; int nValue, error = FALSE; double fValue; // Dataset ID strcpy(string, xml_get_string_value(doc, "metadata.idinfo.datsetid")); if (strlen(string) > MAX_DATASET_ID) { error = TRUE; sprintf(tmp, "Dataset ID - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_DATASET_ID); strcat(errorMessage, tmp); } else { strcpy(data->dataset_id, xml_get_string_value(doc, "metadata.idinfo.datsetid")); //printf("Dataset ID: %s\n", data->dataset_id); } // Origin strcpy(string, xml_get_string_value(doc, "metadata.idinfo.citation.citeinfo.origin")); if (strlen(string) > MAX_ORIGIN) { error = TRUE; sprintf(tmp, "Origin - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_ORIGIN); strcat(errorMessage, tmp); } else { strcpy(data->origin, xml_get_string_value(doc, "metadata.idinfo.citation.citeinfo.origin")); //printf("Origin: %s\n", data->origin); } // Title strcpy(string, xml_get_string_value(doc, "metadata.idinfo.citation.citeinfo.title")); if (strlen(string) > MAX_TITLE) { error = TRUE; sprintf(tmp, "Title - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_TITLE); strcat(errorMessage, tmp); } else { strcpy(data->title, xml_get_string_value(doc, "metadata.idinfo.citation.citeinfo.title")); //printf("Title: %s\n", data->title); } // Online link strcpy(string, xml_get_string_value(doc, "metadata.idinfo.citation.citeinfo.onlink")); if (strlen(string) > MAX_ONLINE_LINK) { error = TRUE; sprintf(tmp, "Online link - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_ONLINE_LINK); strcat(errorMessage, tmp); } else { strcpy(data->online_link, xml_get_string_value(doc, "metadata.idinfo.citation.citeinfo.onlink")); //printf("Online link: %s\n", data->online_link); } // West bounding coordinate fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.westbc"); if (fValue < -180.0 || fValue > 180.0) { error = TRUE; sprintf(tmp, "West bounding coordinate - Value (%.4lf) outside the " "expected value range (-180.0 < value < 180.0)\n", fValue); strcat(errorMessage, tmp); } else { data->west_bounding = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.westbc"); //printf("West bounding coordinate: %.4lf\n", data->west_bounding); } // East bounding coordinate fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.eastbc"); if (fValue < -180.0 || fValue > 180.0) { error = TRUE; sprintf(tmp, "East bounding coordinate - Value (%.4lf) outside the " "expected value range (-180.0 < value < 180.0)\n", fValue); strcat(errorMessage, tmp); } else { data->east_bounding = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.eastbc"); //printf("East bounding coordinate: %.4lf\n", data->east_bounding); } // North bounding coordinate fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.northbc"); if (fValue < -90.0 || fValue > 90.0) { error = TRUE; sprintf(tmp, "West bounding coordinate - Value (%.4lf) outside the " "expected value range (-90.0 < value < 90.0)\n", fValue); strcat(errorMessage, tmp); } else { data->north_bounding = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.northbc"); //printf("West bounding coordinate: %.4lf\n", data->north_bounding); } // South bounding coordinate fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.southbc"); if (fValue < -90.0 || fValue > 90.0) { error = TRUE; sprintf(tmp, "South bounding coordinate - Value (%.4lf) outside the " "expected value range (-90.0 < value < 90.0)\n", fValue); strcat(errorMessage, tmp); } else { data->south_bounding = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.southbc"); //printf("South bounding coordinate: %.4lf\n", data->south_bounding); } // Open KML for reading char centerFile[512], boundaryFile[512], *baseName; char coordStr[50]; float height; baseName = get_basename(inFile); sprintf(boundaryFile, "%s_boundary.kml", baseName); sprintf(centerFile, "%s_center.kml", baseName); xmlDoc *xmlBoundary = xmlReadFile(boundaryFile, NULL, 0); if (!xmlBoundary) asfPrintError("Could not parse boundary file (%s)\n", boundaryFile); else { strcpy(coordStr, xml_get_string_value(xmlBoundary, "kml.Document.Placemark.Polygon.outerBoundaryIs.LinearRing.coordinates")); sscanf(coordStr, "%f,%f,%f\n%f,%f,%f\n%f,%f,%f\n%f,%f", &data->near_start_lat, &data->near_start_lon, &height, &data->near_end_lat, &data->near_end_lon, &height, &data->far_end_lat, &data->far_end_lon, &height, &data->far_start_lat, &data->far_start_lon); //printf("Near start latitude: %.4f\n", data->near_start_lat); //printf("Near start longitude: %.4f\n", data->near_start_lon); //printf("Near end latitude: %.4f\n", data->near_end_lat); //printf("Near end longitude: %.4f\n", data->near_end_lon); //printf("Far start latitude: %.4f\n", data->far_start_lat); //printf("Far start longitude: %.4f\n", data->far_start_lon); //printf("Far end latitude: %.4f\n", data->far_end_lat); //printf("Far end longitude: %.4f\n", data->far_end_lon); } xmlFreeDoc(xmlBoundary); xmlDoc *xmlCenter = xmlReadFile(centerFile, NULL, 0); if (!xmlCenter) asfPrintWarning("Could not parse center point file (%s)\n", centerFile); else { strcpy(coordStr, xml_get_string_value(xmlCenter, "kml.Document.Placemark.Point.coordinates")); sscanf(coordStr, "%f,%f", &data->center_lat, &data->center_lon); //printf("Center latitude: %.4f\n", data->center_lat); //printf("Center longitude: %.4f\n", data->center_lon); } xmlFreeDoc(xmlCenter); // Processing level strcpy(string, xml_get_string_value(doc, "metadata.idinfo.proclevl.prolevid")); if (strlen(string) > MAX_PROCESSING_LEVEL) { error = TRUE; sprintf(tmp, "Processing level - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_PROCESSING_LEVEL); strcat(errorMessage, tmp); } else { strcpy(data->processing_level, xml_get_string_value(doc, "metadata.idinfo.proclevl.prolevid")); //printf("Processing level: %s\n", data->processing_level); } // Place strcpy(string, xml_get_string_value(doc, "metadata.idinfo.keywords.place.placekey[0]")); if (strlen(string) > MAX_PLACE) { error = TRUE; sprintf(tmp, "Place - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_PLACE); strcat(errorMessage, tmp); } else { data->place = (char *) MALLOC(sizeof(char)*MAX_PLACE); strcpy(data->place, xml_get_string_value(doc, "metadata.idinfo.keywords.place.placekey[0]")); //printf("Place: %s\n", data->place); } // Platform strcpy(string, xml_get_string_value(doc, "metadata.idinfo.plainsid.platflnm")); if (strlen(string) > MAX_PLATFORM) { error = TRUE; sprintf(tmp, "Platform - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_PLATFORM); strcat(errorMessage, tmp); } else { strcpy(data->platform, xml_get_string_value(doc, "metadata.idinfo.plainsid.platflnm")); //printf("Platform: %s\n", data->platform); } // Instrument strcpy(string, xml_get_string_value(doc, "metadata.idinfo.plainsid.instflnm")); if (strlen(string) > MAX_INSTRUMENT) { error = TRUE; sprintf(tmp, "Instrument - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_INSTRUMENT); strcat(errorMessage, tmp); } else { strcpy(data->instrument, xml_get_string_value(doc, "metadata.idinfo.plainsid.instflnm")); //printf("Instrument: %s\n", data->instrument); } // Number of bands nValue = xml_get_int_value(doc, "metadata.idinfo.bandidnt.numbands"); if (nValue < 0) { error = TRUE; sprintf(tmp, "Number of bands - Value (%i) outside the " "expected value range (value > 0)\n", nValue); strcat(errorMessage, tmp); } else { data->band_count = xml_get_int_value(doc, "metadata.idinfo.bandidnt.numbands"); //printf("Number of bands: %i\n", data->band_count); } // Browse image location strcpy(string, xml_get_string_value(doc, "metadata.idinfo.browse.browsen")); if (strlen(string) > MAX_BROWSE_LOCATION) { error = TRUE; sprintf(tmp, "Browse image location - String length: %d, allowed " "characters: %d\n", (int) strlen(string), MAX_BROWSE_LOCATION); strcat(errorMessage, tmp); } else if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) { data->browse_location = (char *) MALLOC(sizeof(char)*MAX_BROWSE_LOCATION); strcpy(data->browse_location, xml_get_string_value(doc, "metadata.idinfo.browse.browsen")); //printf("Browse image location: %s\n", data->browse_location); } // Browse image format strcpy(string, xml_get_string_value(doc, "metadata.idinfo.browse.browset")); if (strlen(string) > MAX_BROWSE_FORMAT) { error = TRUE; sprintf(tmp, "Browse image format - String length: %d, allowed characters:" " %d\n", (int) strlen(string), MAX_BROWSE_FORMAT); strcat(errorMessage, tmp); } else if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) { data->browse_format = (char *) MALLOC(sizeof(char)*MAX_BROWSE_FORMAT); strcpy(data->browse_format, xml_get_string_value(doc, "metadata.idinfo.browse.browset")); //printf("Browse format: %s\n", data->browse_format); } // Data access level strcpy(string, xml_get_string_value(doc, "metadata.idinfo.secinfo.secclass")); if (strlen(string) > MAX_ACCESS) { error = TRUE; sprintf(tmp, "Data access level - String length: %d, allowed characters: " "%d\n", (int) strlen(string), MAX_ACCESS); strcat(errorMessage, tmp); } else { strcpy(data->access, xml_get_string_value(doc, "metadata.idinfo.secinfo.secclass")); //printf("Data access level: %s\n", data->access); } // Copyright strcpy(string, xml_get_string_value(doc, "metadata.idinfo.copyright")); if (strlen(string) > MAX_COPYRIGHT) { error = TRUE; sprintf(tmp, "Copyright - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_COPYRIGHT); strcat(errorMessage, tmp); } else { strcpy(data->copyright, xml_get_string_value(doc, "metadata.idinfo.copyright")); //printf("Copyright: %s\n", data->copyright); } // Start time char dateStr[25], timeStr[25], *message; int year, month, day, hour, minute, second; strcpy(dateStr, xml_get_string_value(doc, "metadata.idinfo.timeperd.timeinfo.rngdates.begdate")); year = subStr(0, 4, dateStr); month = subStr(4, 2, dateStr); day = subStr(6, 2, dateStr); strcpy(timeStr, xml_get_string_value(doc, "metadata.idinfo.timeperd.timeinfo.rngdates.begtime")); hour = subStr(0, 2, timeStr); minute = subStr(2, 2, timeStr); second = subStr(4, 2, timeStr); if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 && strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) { if (isNumeric(dateStr) && isNumeric(timeStr)) { message = checkTime(year, month, day, hour, minute, second); if (message) { error = TRUE; sprintf(tmp, "Start time - %s", message); strcat(errorMessage, tmp); } else { data->start_time = (char *) MALLOC(sizeof(char)*MAX_START_TIME); sprintf(data->start_time, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second); //printf("Start time: %s\n", data->start_time); } } } // Center time strcpy(dateStr, xml_get_string_value(doc, "metadata.idinfo.timeperd.timeinfo.sngdate.caldate")); year = subStr(0, 4, dateStr); month = subStr(4, 2, dateStr); day = subStr(6, 2, dateStr); strcpy(timeStr, xml_get_string_value(doc, "metadata.idinfo.timeperd.timeinfo.sngdate.time")); hour = subStr(0, 2, timeStr); minute = subStr(2, 2, timeStr); second = subStr(4, 2, timeStr); if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 && strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) { if (isNumeric(dateStr) && isNumeric(timeStr)) { message = checkTime(year, month, day, hour, minute, second); if (message) { error = TRUE; sprintf(tmp, "Center time - %s", message); strcat(errorMessage, tmp); } else { data->center_time = (char *) MALLOC(sizeof(char)*MAX_CENTER_TIME); sprintf(data->center_time, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second); //printf("Center time: %s\n", data->center_time); } } } // End time strcpy(dateStr, xml_get_string_value(doc, "metadata.idinfo.timeperd.timeinfo.rngdates.enddate")); year = subStr(0, 4, dateStr); month = subStr(4, 2, dateStr); day = subStr(6, 2, dateStr); strcpy(timeStr, xml_get_string_value(doc, "metadata.idinfo.timeperd.timeinfo.rngdates.endtime")); hour = subStr(0, 2, timeStr); minute = subStr(2, 2, timeStr); second = subStr(4, 2, timeStr); if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 && strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) { if (isNumeric(dateStr) && isNumeric(timeStr)) { message = checkTime(year, month, day, hour, minute, second); if (message) { error = TRUE; sprintf(tmp, "End time - %s", message); strcat(errorMessage, tmp); } else { data->end_time = (char *) MALLOC(sizeof(char)*MAX_END_TIME); sprintf(data->end_time, "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second); //printf("End time: %s\n", data->end_time); } } } // Orbit direction nValue = xml_get_int_value(doc, "metadata.dataqual.acqinfo.ascdscin"); if (nValue != MAGIC_UNSET_INT) { if (nValue < 0 || nValue > 1) { error = TRUE; sprintf(tmp, "Orbit direction - Value (%i) outside the " "expected value range (0 <= value <= 1)\n", nValue); strcat(errorMessage, tmp); } else { if (nValue == 0) strcpy(data->orbit_direction, "Ascending"); else if (nValue == 1) strcpy(data->orbit_direction, "Descending"); //printf("Orbit direction: %s\n", data->orbit_direction); } } else strcpy(data->orbit_direction, "Unknown"); // Imaging mode strcpy(string, xml_get_string_value(doc, "metadata.idinfo.plainsid.mode")); if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) { if (strlen(string) > MAX_MODE) { error = TRUE; sprintf(tmp, "Imaging mode - String length: %d, allowed characters: %d" "\n", (int) strlen(string), MAX_MODE); strcat(errorMessage, tmp); } else { strcpy(data->mode, xml_get_string_value(doc, "metadata.idinfo.plainsid.mode")); //printf("Imaging mode: %s\n", data->mode); } } else strcpy(data->mode, "Unknown"); // Spatial reference strcpy(string, xml_get_string_value(doc, "metadata.spdoinfo.direct")); if (strcmp_case(string, "Point") != 0 && strcmp_case(string, "Vector") != 0 && strcmp_case(string, "Raster") != 0) { error = TRUE; sprintf(tmp, "Spatial reference - String (%s) not valid; expected " "\"Point\", \"Vector\" or \"Raster\"\n", string); strcat(errorMessage, tmp); } else { strcpy(data->spatial_reference, xml_get_string_value(doc, "metadata.spdoinfo.direct")); //printf("Spatial reference: %s\n", data->spatial_reference); } // Cell value type strcpy(string, xml_get_string_value(doc, "metadata.spdoinfo.rastinfo.cvaltype")); if (strlen(string) > MAX_CELL_VALUE) { error = TRUE; sprintf(tmp, "Cell value type - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_CELL_VALUE); strcat(errorMessage, tmp); } else { strcpy(data->cell_value, xml_get_string_value(doc, "metadata.spdoinfo.rastinfo.cvaltype")); //printf("Cell value type: %s\n", data->cell_value); } // Raster object type strcpy(string, xml_get_string_value(doc, "metadata.spdoinfo.rastinfo.rasttype")); if (strcmp_case(string, "Point") != 0 && strcmp_case(string, "Pixel") != 0 && strcmp_case(string, "Grid Cell") != 0 && strcmp_case(string, "Voxel") != 0 && strcmp_case(string, "Swath") != 0) { error = TRUE; sprintf(tmp, "Raster object type - String (%s) not valid; expected " "\"Point\", \"Pixel\", \"Grid Cell\", \"Voxel\" or \"Swath\".\n", string); strcat(errorMessage, tmp); } else { strcpy(data->raster_object, xml_get_string_value(doc, "metadata.spdoinfo.rastinfo.rasttype")); //printf("Raster object type: %s\n", data->raster_object); } // Number of rows nValue = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.rowcount"); if (nValue < 0) { error = TRUE; sprintf(tmp, "Number of rows - Value (%i) outside the " "expected value range (value > 0)\n", nValue); strcat(errorMessage, tmp); } else { data->row_count = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.rowcount"); //printf("Number of rows: %i\n", data->row_count); } // Number of columns nValue = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.colcount"); if (nValue < 0) { error = TRUE; sprintf(tmp, "Number of columns - Value (%i) outside the " "expected value range (value > 0)\n", nValue); strcat(errorMessage, tmp); } else { data->col_count = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.colcount"); //printf("Number of columns: %i\n", data->col_count); } // Format name strcpy(string, xml_get_string_value(doc, "metadata.distinfo.stdorder.digform.digtinfo.formname")); if (strlen(string) > MAX_FORMAT) { error = TRUE; sprintf(tmp, "Format name - String length: %d, allowed characters: %d\n", (int) strlen(string), MAX_FORMAT); strcat(errorMessage, tmp); } else { strcpy(data->format, xml_get_string_value(doc, "metadata.distinfo.stdorder.digform.digtinfo.formname")); //printf("Format name: %s\n", data->format); } // Fees fValue = xml_get_double_value(doc, "metadata.distinfo.stdorder.fees"); if (fValue < 0.0) { error = TRUE; sprintf(tmp, "Fees - Value (%.2lf) outside the expected value range " "(value >= 0.0)\n", fValue); strcat(errorMessage, tmp); } else { data->fees = xml_get_double_value(doc, "metadata.distinfo.stdorder.fees"); //printf("Fees: %.2lf\n", data->fees); } if (error) asfPrintError("%s", errorMessage); xmlFreeDoc(doc); xmlCleanupParser(); FREE(configFile); FCLOSE(fLog); remove(logFile); // Add dataset to database addData(data); FREE(data); asfPrintStatus("\nSuccessful completion!\n\n"); return(EXIT_SUCCESS); }