char *find_in_share(const char * filename) { char * ret = MALLOC(sizeof(char) * (strlen(get_asf_share_dir()) + strlen(filename) + 5)); sprintf(ret, "%s/%s", get_asf_share_dir(), filename); return ret; }
static char * projection_directory(int projection) { char * location = NULL, * ret; switch (projection) { case PROJ_UTM: location = "utm"; break; case PROJ_PS: location = "polar_stereographic"; break; case PROJ_LAMCC: location = "lambert_conformal_conic"; break; case PROJ_LAMAZ: location = "lambert_azimuthal_equal_area"; break; case PROJ_ALBERS: location = "albers_equal_area_conic"; break; } ret = (char *) malloc(sizeof(char) * (strlen(location) + strlen(get_asf_share_dir()) + 25)); sprintf(ret, "%s%cprojections%c%s", get_asf_share_dir(), DIR_SEPARATOR, DIR_SEPARATOR, location); return ret; }
static char *get_proj_file(char *projFile) { char location[50], *ret; if (strncmp_case(projFile, "ALBERS_EQUAL_AREA_CONIC", 23) == 0) strcpy(location, "albers_equal_area_conic"); else if (strncmp_case(projFile, "EQUIDISTANT", 11) == 0) strcpy(location, "equidistant"); else if (strncmp_case(projFile, "EQUI_RECTANGULAR", 16) == 0) strcpy(location, "equi_rectangular"); else if (strncmp_case(projFile, "LAMBERT_AZIMUTHAL_EQUAL_AREA", 28) == 0) strcpy(location, "lambert_azimuthal_equal_area"); else if (strncmp_case(projFile, "LAMBERT_CONFORMAL_CONIC", 23) == 0) strcpy(location, "lambert_conformal_conic"); else if (strncmp_case(projFile, "MERCATOR", 8) == 0) strcpy(location, "mercator"); else if (strncmp_case(projFile, "POLAR_STEREOGRAPHIC", 19) == 0) strcpy(location, "polar_stereographic"); else if (strncmp_case(projFile, "SINUSOIDAL", 10) == 0) strcpy(location, "sinusoidal"); else if (strncmp_case(projFile, "UTM", 3) == 0) strcpy(location, "utm"); ret = (char *) MALLOC(sizeof(char) * (strlen(projFile)*2 + strlen(get_asf_share_dir()) + 5)); sprintf(ret, "%s%cprojections%c%s%c%s", get_asf_share_dir(), DIR_SEPARATOR, DIR_SEPARATOR, location, DIR_SEPARATOR, projFile); return ret; }
const char *get_asf_share_dir_with_argv0(const char *argv0) { #ifdef win32 // "realpath" not available on Windows char *argv0_real_path = STRDUP(argv0); #else // handle use of "./mapready" etc char *argv0_real_path = realpath(argv0, NULL); if (!argv0_real_path) { // probably user did not specify a path when running MapReady // so, can use the normal method for finding the share dir return get_asf_share_dir(); } #endif // strip off the executable, leaving just the path info char *argv0_path = get_dirname(argv0_real_path); if (!s_argv0) s_argv0 = STRDUP(argv0_path); #ifndef win32 // If the user specified a path on the command line, we want to // try that directory first, when searching for the share dir. // If this doesn't work, in get_asf_share_dir(), called below, we will // use the normal path-searching method to find the share dir. If this // does work, then the call below will just return what we've already // found. if (!s_share_dir) { // obtain what needs to be pasted on to the location of the bin dir // to get to the share dir (i.e. "share/asf_tools") char *share = strstr(ASF_SHARE_DIR, "share"); if (share) { if (argv0_path && strlen(argv0_path) > 0) { // a copy for us to change "whatever/bin" to "whatever/share/asf_tools" char *buf = MALLOC(sizeof(char)*(strlen(argv0_path) + strlen(share) + strlen(TOOL_SUITE_SHARE_DIR) + 5)); strcpy(buf, argv0_path); // only try this if the binary location ends with 'bin' if (strcmp(buf + strlen(buf) - 4, "bin/") == 0) { // strip off "bin" - add "share/asf_tools" *(buf + strlen(buf) - 4) = '\0'; strcat(buf, share); strcat(buf, "/"); strcat(buf, TOOL_SUITE_SHARE_DIR); if (check_for_known_file_in_share_dir(buf)) { // this is the one! s_share_dir = STRDUP(buf); } } FREE(buf); } } } #endif FREE(argv0_path); FREE(argv0_real_path); return get_asf_share_dir(); }
meta_parameters *read_asf_meta(const char *meta_name) { meta_parameters *meta = meta_read(meta_name); // If the ASF internal format file is a single-band image with RGB color map // in the metadata, then store the color map as an ASF style look-up table if (meta->colormap) { int i; meta_colormap *mc = meta->colormap; char lut_file[256]; char *lut_loc = (char *)MALLOC(sizeof(char)*(strlen(get_asf_share_dir())+128)); sprintf(lut_loc, "%s%clook_up_tables", get_asf_share_dir(), DIR_SEPARATOR); sprintf(lut_file,"%s%c%s", lut_loc, DIR_SEPARATOR, EMBEDDED_ASF_COLORMAP_LUT_FILE); FILE *lutFP = (FILE *)FOPEN(lut_file, "wt"); fprintf(lutFP, "# Look up table type: %s\n", mc->look_up_table); fprintf(lutFP, "# Originating source: %s\n", meta_name); fprintf(lutFP, "# Index Red Green Blue\n"); for (i=0; i<mc->num_elements; i++) { fprintf(lutFP, "%03d %03d %03d %03d\n", i, mc->rgb[i].red, mc->rgb[i].green, mc->rgb[i].blue); } fprintf(lutFP, "\n"); FCLOSE(lutFP); } return meta; }
char * find_in_share(const char * filename) { char * ret = (char *) malloc(sizeof(char) * (strlen(get_asf_share_dir()) + strlen(filename) + 5)); sprintf(ret, "%s%c%s", get_asf_share_dir(), DIR_SEPARATOR, filename); return ret; }
static char *find_in_share(const char * filename) { char * ret = (char *) MALLOC(sizeof(char) * (strlen(get_asf_share_dir()) + strlen(filename) + 5)); sprintf(ret, "%s%c%s", get_asf_share_dir(), DIR_SEPARATOR, filename); if (fileExists(ret)) return ret; else { FREE(ret); return NULL; } }
char *find_in_share(const char * filename) { char * ret = MALLOC(sizeof(char) * (strlen(get_asf_share_dir()) + strlen(filename) + 5)); sprintf(ret, "%s/%s", get_asf_share_dir(), filename); if (fileExists(ret)) { return ret; } else { printf("Trying to find %s file: %s\n", filename, ret); free(ret); return NULL; } }
double faraday_prediction(int frame_id, double look_angle, int year, int day, int hour, int minute, double clat, double clon, char *codg_file) { // Determine total electron count for location at given time // at 450 km elevation double fHour = (double)hour + (double)minute/60.0; int lo_hour = floor(fHour/2) + 1; int hi_hour = lo_hour + 1; double act_hour = fHour/2 + 1; double lo_tec = lookup_tec(codg_file, lo_hour, clat, clon); double hi_tec = lookup_tec(codg_file, hi_hour, clat, clon); double tec = interpolate(act_hour, hi_hour, hi_tec, lo_hour, lo_tec); tec /= 10.0; // Determine TEC at 350 km elevation char magnetic_field_file[512]; sprintf(magnetic_field_file, "%s%cx_350.txt", get_asf_share_dir(), DIR_SEPARATOR); double mag_south = lookup_reference(magnetic_field_file, clat, clat); mag_south *= -1.0; sprintf(magnetic_field_file, "%s%cy_350.txt", get_asf_share_dir(), DIR_SEPARATOR); double mag_east = lookup_reference(magnetic_field_file, clat, clat); sprintf(magnetic_field_file, "%s%cz_350.txt", get_asf_share_dir(), DIR_SEPARATOR); double mag_z = lookup_reference(magnetic_field_file, clat, clat); mag_z *= -1.0; double mag_i, mag_j, mag_k; sez2ijk(mag_south, mag_east, mag_z, clat, clon, &mag_i, &mag_j, &mag_k); // Determine ALOS pointing angle double pt_south, pt_east, pt_z, pt_i, pt_j, pt_k; alos_pointing(frame_id, look_angle, &pt_south, &pt_east, &pt_z); sez2ijk(pt_south, pt_east, pt_z, clat, clon, &pt_i, &pt_j, &pt_k); // Determine Faraday rotation double nano=1e-9, tecu=1e16, K=2.37e4, frequency=1.27e9; double look = look_angle*D2R; double dot_mag_pt = mag_i*pt_i + mag_j*pt_j + mag_k*pt_k; double norm_mag = sqrt(mag_i*mag_i + mag_j*mag_j + mag_k*mag_k); double norm_pt = sqrt(pt_i*pt_i + pt_j*pt_j + pt_k*pt_k); double psi = acos(dot_mag_pt / norm_mag / norm_pt); double omega = K/frequency/frequency*tec*tecu*nano; omega *= norm_mag*cos(psi)/cos(look)*R2D; //printf("omega: %lf\n", omega); return omega; }
static char * find_in_share(const char * filename) { char * escaped_dir = escapify(get_asf_share_dir()); char * ret = (char *) MALLOC(sizeof(char) * (strlen(escaped_dir) + strlen(filename) + 2)); sprintf(ret, "%s/%s", escaped_dir, filename); free(escaped_dir); return ret; }
// try to find a program we can use to view the generated csv files const char * detect_csv_assoc() { static char *csv_app = NULL; if (!csv_app) { char *csv_file = find_in_share("asf_view_cfg.csv"); #ifdef win32 // On Windows, use the file association table to find out what we // can do with csv files. char path[1024]; int ret = (int)FindExecutable((LPCTSTR)csv_file, (LPCTSTR)get_asf_share_dir(), (LPTSTR)path); if (ret > 32 && strlen(path) > 0) { csv_app = escapify(path); printf("Path to CSV Application: %s\n", csv_app); } else { if (ret==SE_ERR_FNF) printf("File not found: %s\n", csv_file); else if (ret==SE_ERR_NOASSOC) printf("No association for: %s\n", csv_file); else if (ret==SE_ERR_OOM) printf("Out of resources.\n"); else printf("Unknown error! (return value: %d)\n", ret); csv_app = STRDUP("notepad.exe"); printf("CSV Application not found -- using notepad.\n"); } FREE(csv_file); #else // On Linux, get the app from the configuration file FILE *cfg = fopen(csv_file, "r"); if (cfg) { char tmp[1024]; while (fgets(tmp, 1024, cfg) != NULL) { if (strncmp_case(tmp, "CSV,", 4) == 0) { csv_app = trim_whitespace(tmp+4); printf("CSV Application from config file: %s\n", csv_app); } } if (!csv_app) csv_app = STRDUP(""); fclose(cfg); } else { printf("Failed to open %s: %s\n", csv_file, strerror(errno)); csv_app = STRDUP(""); printf("CSV Application not found.\n"); } #endif } return csv_app; }
int share_file_exists(const char *filename) { char * full_name; const char * share_dir; share_dir = get_asf_share_dir(); full_name = (char *) MALLOC (sizeof(char) * (strlen(filename) + strlen(share_dir) + 10)); sprintf(full_name, "%s%c%s", share_dir, DIR_SEPARATOR, filename); int exists = fileExists(full_name); free(full_name); return exists; }
FILE * fopen_share_file(const char * filename, const char * mode) { char * full_name; const char * share_dir; FILE * fp; share_dir = get_asf_share_dir(); full_name = (char *) MALLOC (sizeof(char) * (strlen(filename) + strlen(share_dir) + 10)); sprintf(full_name, "%s%c%s", share_dir, DIR_SEPARATOR, filename); fp = fopen(full_name, mode); if (!fp) asfPrintWarning("Could not open share file: %s\n", filename); free(full_name); return fp; }
// Print minimalistic usage info & exit static void usage(const char *name) { char path[1024]; struct dirent *dp; DIR *dir; asfPrintStatus("\n" "Usage:\n" ASF_USAGE_STRING "\n"); asfPrintStatus("Currently available templates are:\n"); sprintf(path, "%s/metadata", get_asf_share_dir()); dir = opendir(path); while ((dp = readdir(dir)) != NULL) { if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0) asfPrintStatus(" %s\n", dp->d_name); } asfPrintStatus("\n"); closedir(dir); exit(EXIT_FAILURE); }
SIGNAL_CALLBACK void on_help_button_clicked(GtkWidget *widget) { #ifdef win32 char pdf_dir[1024], pdf_file[128], pdf_viewer[1024]; snprintf(pdf_dir, 1023, "%s/doc/", get_asf_share_dir()); strcpy(pdf_file, "mapready_manual.pdf"); //printf("pdf: %s/%s\n", pdf_dir, pdf_file); FindExecutable((LPCTSTR)pdf_file, (LPCTSTR)pdf_dir, (LPTSTR)pdf_viewer); printf("Found PDF Viewer: %s\n", pdf_viewer); if (strlen(pdf_viewer)) { asfSystem_NoWait("\"%s\" \"%s/%s\"", pdf_viewer, pdf_dir, pdf_file); } else { message_box("Couldn't find path to a PDF Viewer!"); } #else GtkWidget *help_dialog; GtkWidget *help_text; GtkTextBuffer * text_buffer; FILE * help_file; gchar * help_filename; help_dialog = get_widget_checked("help_dialog"); help_text = get_widget_checked("help_text"); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(help_text)); gtk_text_buffer_set_text(text_buffer, "", -1); help_filename = "mapready.txt"; //help_file = fopen(help_filename, "rt"); help_file = fopen_share_file(help_filename, "rt"); if (help_file) { int line_count = 0; gchar * buffer = (gchar *) g_malloc(sizeof(gchar) * max_line_len); while (!feof(help_file)) { gchar *p = fgets(buffer, max_line_len, help_file); if (p) { if (strlen(p)) line_count++; GtkTextIter end; gchar * q = strstr(buffer, "$VERSION"); if (q) { gchar * r = g_strdup(q + 8); /* 8 = length of '$VERSION' */ strcpy(q, MAPREADY_VERSION_STRING); strcat(buffer, r); g_free(r); } gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); } } if (!line_count) { sprintf(buffer, "\n\n ERROR: Empty help file (mapready.txt) in share folder\n(%s)\n", get_asf_share_dir()); GtkTextIter end; gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); } fclose(help_file); g_free(buffer); } else { // No help file found gchar *buffer = (gchar *) g_malloc(sizeof(gchar) * max_line_len); strcpy(buffer, "\n\n ERROR: Cannot find help file (mapready.txt) in share folder.\n"); GtkTextIter end; gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); g_free(buffer); } gtk_widget_show(help_dialog); #endif }
int main(int argc, char **argv) { if (detect_flag_options(argc, argv, "-help", "--help", NULL)) help(); char band[512], lut[512], mask_file_name[512]; strcpy(band, ""); strcpy(mask_file_name, ""); int band_specified = extract_string_options(&argc, &argv, band, "-band", "--band", "-b", NULL); int lut_specified = extract_string_options(&argc, &argv, lut, "-colormap", "--colormap", "-lut", "--lut", NULL); int planner_mode = extract_flag_options(&argc, &argv, "-plan", "--plan", NULL); int mask_specified = extract_string_options(&argc, &argv, mask_file_name, "-mask", "--mask", "--layover-mask", "--layover-mask", NULL); generic_specified = extract_flag_options(&argc, &argv, "-generic", "--generic", NULL); if (generic_specified) { char type[512]; if (!extract_int_options(&argc, &argv, &generic_bin_width, "-width", "--width", "-cols", "--cols", NULL) || !extract_int_options(&argc, &argv, &generic_bin_height, "-height", "--height", "-rows", "--rows", NULL)) { asfPrintError("When reading generic data, specify the size " "(--width, --height).\n"); } generic_bin_byteswap = extract_flag_options(&argc, &argv, "--byteswap", "-byteswap", NULL); if (extract_string_options(&argc, &argv, type, "-type", "--type", NULL)) { if (strcmp_case(type, "BYTE") == 0 || strcmp_case(type, "INT8") == 0) { generic_bin_datatype = BYTE; } else if (strcmp_case(type, "FLOAT") == 0 || strcmp_case(type, "REAL32") == 0) { generic_bin_datatype = REAL32; } else { asfPrintError("Unknown generic data type: %s\n", type); } } else { asfPrintStatus("Generic binary: assuming REAL32 data.\n"); generic_bin_datatype = REAL32; } } if (planner_mode) { if (detect_flag_options(argc, argv, "-calibrate-reference", NULL)) { calibrate_planner_reference(); exit(EXIT_SUCCESS); } } handle_common_asf_args(&argc, &argv, "ASF View"); // point to "polygon 0" as the one we initially work on g_poly = &g_polys[0]; // set up image array curr = &image_info[0]; curr->data_name = curr->meta_name = NULL; int ii; if (argc < 2) { curr->filename = STRDUP(find_in_share("startup.jpg")); } else { n_images_loaded = 0; for (ii=1; ii<argc; ++ii) { if (strlen(argv[ii]) > 0) { image_info[n_images_loaded].filename = STRDUP(argv[ii]); ++n_images_loaded; } } } if (n_images_loaded == 1) { asfPrintStatus("Loading 1 image: %s\n", image_info[0].filename); } else { asfPrintStatus("Loading %d images:\n", n_images_loaded); for (ii=0; ii<n_images_loaded; ++ii) asfPrintStatus("%d: %s\n", ii+1, image_info[ii].filename); } if (mask_specified) asfPrintStatus("Mask: %s\n", mask_file_name); // we could call load_file() here, but don't because this way we can // interleave the call to gtk_init() with some of the loading code -- // which keeps the window from showing up until after it has been loaded, // which looks much nicer // initialize globals reset_globals(TRUE); // Get rid of leftover (temporary) colormap luts if they exist, say if asf_view errored out // rather than being exited normally char embedded_tiff_lut_file[1024]; char embedded_asf_colormap_file[1024]; char *lut_loc = (char *)MALLOC(sizeof(char)*(strlen(get_asf_share_dir())+64)); sprintf(lut_loc, "%s%clook_up_tables", get_asf_share_dir(), DIR_SEPARATOR); sprintf(embedded_tiff_lut_file,"%s%c%s", lut_loc, DIR_SEPARATOR, EMBEDDED_TIFF_COLORMAP_LUT_FILE); sprintf(embedded_asf_colormap_file,"%s%c%s", lut_loc, DIR_SEPARATOR, EMBEDDED_ASF_COLORMAP_LUT_FILE); FREE(lut_loc); if (fileExists(embedded_tiff_lut_file)) remove(embedded_tiff_lut_file); if (fileExists(embedded_asf_colormap_file)) remove(embedded_asf_colormap_file); if (mask_specified) { curr = mask = &mask_info; mask->filename = STRDUP(mask_file_name); if (mask->filename[strlen(mask->filename)-1] == '.') mask->filename[strlen(mask->filename)-1] = '\0'; read_file(mask->filename, NULL, FALSE, TRUE); //set_lut("layover_mask"); } // load the image we're going to actually show last for (ii=n_images_loaded-1; ii>=0; --ii) { curr = &image_info[ii]; // strip off any trailing "." if (curr->filename[strlen(curr->filename)-1] == '.') curr->filename[strlen(curr->filename)-1] = '\0'; read_file(curr->filename, band_specified ? band : NULL, FALSE, TRUE); check_for_embedded_tiff_lut(curr->filename, &lut_specified, lut); if (lut_specified) set_lut(lut); assert(curr->data_name); assert(curr->meta_name); // we load the thumbnail data before bringing up the window, looks // much nicer. When loading an image within the GUI, we don't need // to do get_thumbnail_data() as a separate step. ThumbnailData *thumbnail_data = get_thumbnail_data(curr); // first time through the loop only, set up GTK if (ii == n_images_loaded-1) { gtk_init(&argc, &argv); gchar *glade_xml_file = (gchar *)find_in_share("asf_view.glade"); printf("Found asf_view.glade: %s\n", glade_xml_file); glade_xml = glade_xml_new(glade_xml_file, NULL, NULL); free(glade_xml_file); // set up window title, etc set_button_images(); // set up the acquisition planner, if we are in that mode if (planner_mode) { setup_planner(); // getting rid of the info section makes more room for the found // acquisitions, and isn't really necessary in the planner show_widget("info_hbox", FALSE); } // populate the look up table list, and apply the default // look-up-table, if there is one. In this case, we will need to // apply it retroactively to the thumbnail data we already loaded // (In new.c, this kludge isn't required - we load/apply in the // same pass -- here it is required because we pre-load the thumbnail) populate_lut_combo(); if (check_for_embedded_tiff_lut(curr->filename, &lut_specified, lut)) { GtkWidget *option_menu = get_widget_checked("lut_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), get_tiff_lut_index()); set_current_index(get_tiff_lut_index()); } else if (is_colormap_ASF_file(curr->filename)) { /* * lut_specified = 1; * strcpy(lut, EMBEDDED_ASF_COLORMAP_LUT); * GtkWidget *option_menu = get_widget_checked("lut_optionmenu"); * gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), get_asf_lut_index()); * set_current_index(get_asf_lut_index()); * check_lut(); * apply_lut_to_data(thumbnail_data); */ } } else if (ii == 0) { set_title(band_specified, band); } if (curr->meta && curr->meta->general) { if (set_lut_based_on_image_type(curr->meta->general->image_data_type)) { check_lut(); // data we loaded needs to be lutted apply_lut_to_data(thumbnail_data); } } // load the metadata & image data, other setup setup_gdk_window_ids(); setup_small_image_size(); fill_small_have_data(thumbnail_data, curr); fill_big(curr); update_pixel_info(curr); update_zoom(); set_font(); fill_meta_info(); update_map_settings(curr); fill_stats(curr); set_mapping_defaults(curr); setup_bands_tab(curr->meta); disable_meta_button_if_necessary(); if (lut_specified) select_lut(lut); } if (n_images_loaded>0) { asfPrintStatus("Currently displaying %d: %s\n", current_image_info_index, curr->filename); } glade_xml_signal_autoconnect(glade_xml); gtk_main (); // If the last viewed file left behind a (temporary) color map lut, // then get rid of it if (fileExists(embedded_tiff_lut_file)) remove(embedded_tiff_lut_file); if (fileExists(embedded_asf_colormap_file)) remove(embedded_asf_colormap_file); image_info_free(curr); free_shapes(); exit (EXIT_SUCCESS); }
int meta_test_ext(char *in_file, char *spec_file, report_level_t level) { char *filename = NULL, line[1024], param[100], type[25], valid[500], *p; char *strValue; int nMin, nMax, nValue, err, passed = TRUE; double lfMin, lfMax, lfValue; // First try to find the spec file locally FILE *fp = fopen(spec_file, "r"); if (!fp) { filename = appendExt(spec_file, ".specs"); fp = fopen(filename, "r"); } // Second try the spec file from share directory if (!fp) { FREE(filename); filename = (char *) MALLOC(sizeof(char)*1024); sprintf(filename, "%s/meta_test/%s", get_asf_share_dir(), spec_file); fp = fopen(filename, "r"); } if (!fp) { sprintf(filename, "%s/meta_test/%s.specs", get_asf_share_dir(), spec_file); fp = fopen(filename, "r"); } if (!fp) asfPrintError("Could not find spec file (%s)\n", spec_file); if (filename) FREE(filename); // FIXME: Need to implement some pre-checks. // For example, map projections will need special treatment. For a given // map projection, a set of parameters need are required to define that. // We need to be able to ignore some parameters in this context as well. // Only for the UAVSAR case, we are good to go. while(fgets(line, 1024, fp)) { // skip comments if (strstr(line, "#")) continue; else line[strlen(line)-1] = '\0'; // parameter out of the metadata structure p = strchr(line, ','); *p = '\0'; sprintf(param, "%s", line); strcat(param, ":"); // data type sprintf(line, "%s", p+1); p = strchr(line, ','); if (p) *p = '\0'; sprintf(type, "%s", line); // valid // If no value is given, we just want to check the parameter is given in // the metadata file. If we find quotation marks then assume we have a list // of values to check. Otherwise, we assume to find a minimum and a maximum // value to check. if (p) { sprintf(line, "%s", p+1); if (line[0] == '\'' && line[strlen(line)-1] == '\'') { sprintf(valid, "%s", line+1); valid[strlen(valid)-1] = '\0'; strValue = getString(in_file, param, &err); if (err || (strlen(valid) > 0 && strstr(valid, strValue) == NULL)) { asfReport(level, " %s failed\n", param); passed = FALSE; } } else { if (strncmp_case(type, "INT", 3) == 0) { sscanf(line, "%d,%d", &nMin, &nMax); nValue = getInt(in_file, param, &err); if (err || nValue < nMin || nValue > nMax) { asfReport(level, " %s failed\n", param); passed = FALSE; } } else if (strncmp_case(type, "DOUBLE", 6) == 0) { sscanf(line, "%lf,%lf", &lfMin, &lfMax); lfValue = getDouble(in_file, param, &err); if (err || lfValue < lfMin || lfValue > lfMax) { asfReport(level, " %s failed\n", param); passed = FALSE; } } } } } return passed; }
int main(int argc, char **argv) { char inFormat[25], outFormat[25], configFile[255]; int currArg = 1, NUM_ARGS = 1, configFlag = FALSE; c2v_config *cfg=NULL; if (argc < 3) { usage(argv[0]); exit(1); } // Check for configuration file option first while (currArg < (argc-NUM_ARGS)) { char *key = argv[currArg++]; if (strmatches(key, "-help", "--help", NULL)) { usage(argv[0]); char format[25], data_dictionary[512]; CHECK_ARG(1); strcpy(format, GET_ARG(1)); sprintf(data_dictionary, "%s%c%s_data_dictionary.csv", get_asf_share_dir(), DIR_SEPARATOR, format); if (fileExists(data_dictionary)) { asfPrintStatus("\nFormat defined in %s_data_dictionary.csv\n\n", format); catFile(data_dictionary); asfPrintStatus("\n\n"); } else asfPrintWarning("Could not find a data dictionary for format (%s)!\n\n", format); exit(1); } else if (strmatches(key, "-config", "--config", "-c", NULL)) { CHECK_ARG(1); strcpy(configFile, GET_ARG(1)); cfg = read_c2v_config(configFile); configFlag = TRUE; } } if (!configFlag) { sprintf(configFile, "%s%cconvert2vector.config", get_asf_share_dir(), DIR_SEPARATOR); asfPrintStatus("\nReading parameters from default configuration file:\n" "%s\n", configFile); cfg = read_c2v_config(configFile); } // Pick up the rest of the arguments currArg = 1; NUM_ARGS = 2; while (currArg < (argc-NUM_ARGS)) { char *key = argv[currArg++]; if (strmatches(key, "-config", "--config", "-c", NULL)) { ; } 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 if (strmatches(key, "-list", "--list", NULL)) cfg->list = TRUE; else if (strmatches(key, "-nosplit", "--nosplit", "-ns", NULL)) cfg->nosplit = TRUE; else if (strmatches(key, "-input-format", "--input-format", "-i", NULL)) { CHECK_ARG(1); strcpy(cfg->input_format, GET_ARG(1)); } else if (strmatches(key, "-output-format", "--output-format", "-o", NULL)) { CHECK_ARG(1); strcpy(cfg->output_format, GET_ARG(1)); } else { --currArg; break; } } if ((argc-currArg) < NUM_ARGS) { printf("Insufficient arguments.\n"); usage(argv[0]); } if (!configFlag) { sprintf(cfg->input_file, "%s", argv[currArg++]); sprintf(cfg->output_file, "%s", argv[currArg]); } asfSplashScreen (argc, argv); sprintf(inFormat, "%s", uc(cfg->input_format)); sprintf(outFormat, "%s", uc(cfg->output_format)); // Check whether you can find information about the format in the header // list file in the share directory dbf_header_t *dbf; int nCols; char shape_type[25]; if (strcmp_case(inFormat, "CSV") == 0 || read_header_config(inFormat, &dbf, &nCols, shape_type)) asfPrintStatus(" Converting a %s format file to %s\n", inFormat, outFormat); else asfPrintError(" Unsupported input format (%s)\n", inFormat); // Set output directory as the temporary directory -- where all temp files // created during import should be put char *tmpdir = get_dirname(cfg->output_file); if (tmpdir && strlen(tmpdir) > 0) set_asf_tmp_dir(tmpdir); convert2vector(cfg); asfPrintStatus("Done.\n\n"); return(0); }
int main(int argc, char **argv) { GtkWidget *widget; gchar *glade_xml_file; gtk_init(&argc, &argv); set_font(); get_asf_share_dir_with_argv0(argv[0]); set_tiff_warning_handler(); asfPrintStatus("\nASF MapReady:\n"); const char *share_dir = get_asf_share_dir(); if (!share_dir) // this actually should never happen with the current implementation // of get_asf_share_dir() -- always sets the share dir to something // even if it is a bad guess... in which case the next check will fail asfPrintError("Could not find the ASF share directory!\n"); glade_xml_file = (gchar *)find_in_share("mapready.glade"); if (!glade_xml_file) asfPrintError("Could not find the mapready.glade file!\n" "It should be in the share files directory, here:\n" " %s\n", share_dir); glade_xml = glade_xml_new(glade_xml_file, NULL, NULL); if (!glade_xml) asfPrintError("Could not load the mapready.glade file!\n" "This file may be corrupt. mapready.glade was found in:\n" " %s\n", share_dir); g_free(glade_xml_file); asfPrintStatus("Using share files directory: %s\n\n", share_dir); /* thumbnails supported in GTK 2.4 or greater */ #ifdef G_THREADS_ENABLED use_thumbnails = gtk_major_version >= 2 && gtk_minor_version >= 4; #else use_thumbnails = FALSE; #endif #ifdef win32 // On windows, ensure that our installed sh.exe is the one that is found, // by severely restricting the path. char pathenv[1024]; sprintf(pathenv, "PATH=%s", get_asf_bin_dir()); putenv(pathenv); #endif if (!use_thumbnails) { printf("GTK Version < 2.4 -- output thumbnails disabled.\n"); } else { // We will want to load thumbnails in other threads. if ( !g_thread_supported () ) { g_thread_init (NULL); } } /* allow FOPEN, FREAD, FWRITE to fail without aborting */ caplib_behavior_on_error = BEHAVIOR_ON_ERROR_CONTINUE; /* add version number to window title, request a default size */ char gtitle [256]; sprintf (gtitle, "ASF MapReady: Version %s", MAPREADY_VERSION_STRING); widget = get_widget_checked("asf_convert"); gtk_window_set_title(GTK_WINDOW(widget), gtitle); // commenting this out - now supported within glade //gtk_window_resize(GTK_WINDOW(widget), 1000, 700); /* select defaults for dropdowns & buttons & labeling */ widget = get_widget_checked("scaling_method_combobox"); set_combo_box_item(widget, SCALING_METHOD_SIGMA); widget = get_widget_checked("import_checkbutton"); gtk_widget_set_sensitive(widget, FALSE); widget = get_widget_checked("input_data_type_combobox"); set_combo_box_item(widget, INPUT_TYPE_AMP); widget = get_widget_checked("resample_option_menu"); set_combo_box_item(widget, RESAMPLE_BILINEAR); // Populate the colormap drop-downs on both the import tab and in the // browse dialog populate_polsarpro_classification_optionmenu(); widget = get_widget_checked("browse_select_colormap_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 0); widget = get_widget_checked("output_format_combobox"); set_combo_box_item(widget, OUTPUT_FORMAT_JPEG); widget = get_widget_checked("geocode_checkbutton"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE); geocode_options_changed(); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE); widget = get_widget_checked("about_dialog_copyright_label"); gtk_label_set_text(GTK_LABEL(widget), ASF_COPYRIGHT_STRING); // Hide latitude selection stuff until we start supporting // swath products (level 0) again widget = get_widget_checked("latitude_checkbutton"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_low_label"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_hi_label"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_low_entry"); gtk_widget_hide(widget); widget = get_widget_checked("latitude_hi_entry"); gtk_widget_hide(widget); // For now, do not allow manual offsets show_widget("hbox_tc_matching", FALSE); // This option is deprecated -- we always apply the fix now // and don't give the user the option of turning it off. Probably // we can just delete all code associated with it, but for now we // just turn it on, and hide it. set_checked("apply_metadata_fix_checkbutton", TRUE); widget = get_widget_checked("apply_metadata_fix_checkbutton"); gtk_widget_hide(widget); // Muck with the fonts in the About dialog widget = get_widget_checked("about_dialog_mapready_label"); gchar *str = gtitle; gchar *text; PangoAttrList *attrs; sprintf(gtitle, "\n<b>ASF MapReady</b>\n" "<i>Remote Sensing Toolkit</i>\n" "ver. %s", MAPREADY_VERSION_STRING); if (strlen(SVN_REV)>0) sprintf(gtitle, "%s (build %s)", gtitle, SVN_REV); else strcat(gtitle, " (custom build)"); pango_parse_markup(str, -1, 0, &attrs, &text, NULL, NULL); gtk_label_set_attributes(GTK_LABEL(widget), attrs); gtk_label_set_text(GTK_LABEL(widget), text); PangoFontDescription *font_desc = pango_font_description_from_string("Sans 12"); gtk_widget_modify_font(widget, font_desc); // Muck with the "Select Processing Steps" label widget = get_widget_checked("select_processing_steps_label"); str = gtitle; sprintf(gtitle, "<b><i> Select Processing Steps:</i></b>"); pango_parse_markup(str, -1, 0, &attrs, &text, NULL, NULL); gtk_label_set_attributes(GTK_LABEL(widget), attrs); gtk_label_set_text(GTK_LABEL(widget), text); font_desc = pango_font_description_from_string("Sans 12"); gtk_widget_modify_font(widget, font_desc); /* fire handlers for hiding/showing stuff */ output_format_combobox_changed(); input_data_type_changed(); geocode_options_changed(); load_external_commands(); external_settings_changed(); set_toolbar_images(); show_execute_button(TRUE); /* build columns in the files section */ show_full_paths = FALSE; // Set before setup_files_list(), default to FALSE widget = get_widget_checked("show_full_path_names_checkbutton"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE); setup_files_list(); /* allow multiple selects */ widget = get_widget_checked("input_file_selection"); gtk_file_selection_set_select_multiple(GTK_FILE_SELECTION(widget), TRUE); /* drag-n-drop setup */ setup_dnd(); /* right-click menu setup */ setup_popup_menu(); /* bands dropdown setup*/ setup_band_comboboxes(); current_naming_scheme = naming_scheme_default(); /* set initial vpanel setting */ //widget = get_widget_checked("vertical_pane"); //gtk_paned_set_position(GTK_PANED(widget), 240); /* Connect signal handlers. */ glade_xml_signal_autoconnect (glade_xml); /* initial flag settings */ processing = FALSE; settings_on_execute = NULL; /* explicit call to the function that refreshes the "summary" */ /* section when options are changed, so get the settings */ /* initially in there */ input_data_formats_changed(); input_data_type_combobox_changed(); default_to_terrcorr_on(); default_to_keep_temp(); terrcorr_options_changed(); init_browse_format_combobox(); /* For some reason, it did not work to set this via glade */ /* So, we have to select our default faraday rotation style here */ rb_select("rb_fr_global", TRUE); polarimetry_settings_changed(); /* put files on the command-line into the files section */ populate_files_list(argc, argv); /* set up the rgb stuff on the export tab */ rgb_combo_box_setup(); /* enters the main GTK loop */ gtk_main (); /* clean up, application has been closed */ if (settings_on_execute) settings_delete(settings_on_execute); if (output_directory) g_free(output_directory); if (current_naming_scheme) naming_scheme_delete(current_naming_scheme); release_predefined_projections(); exit (EXIT_SUCCESS); }
// Populate both the drop-down on the import tab and within the file browse dialog void populate_polsarpro_classification_optionmenu() { // Set up the menus (one on the import tab, the other on the input file browse dialog GtkWidget *browse_menu = NULL; GtkWidget *browse_option_menu = get_widget_checked("browse_select_colormap_optionmenu"); if (browse_option_menu) { browse_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(browse_option_menu)); if (browse_menu) { gtk_option_menu_remove_menu(GTK_OPTION_MENU(browse_option_menu)); } } browse_menu = gtk_menu_new(); GtkWidget *browse_item = gtk_menu_item_new_with_label("None"); gtk_menu_append(GTK_MENU(browse_menu), browse_item); gtk_widget_show(browse_item); browse_item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(browse_menu), browse_item); gtk_widget_show(browse_item); char lut_loc[1024]; sprintf(lut_loc, "%s%clook_up_tables", get_asf_share_dir(), DIR_SEPARATOR); if (g_polsarpro_classification_optionmenu_ht == NULL) { g_polsarpro_classification_optionmenu_ht = g_hash_table_new(g_str_hash,g_str_equal); } // Open up the share dir's look up tables list, populate dropdown // from the files in that directory. GDir *lut_dir = g_dir_open(lut_loc, 0, NULL); if (lut_dir) { unsigned int i, n=0; char **names = (char**)MALLOC(sizeof(char*)*MAX_LUTS); while (1) { const char *name = (char*)g_dir_read_name(lut_dir); if (name) { char *name_dup = STRDUP(name); char *p = findExt(name_dup); if (p && strcmp(p, ".pal") == 0 && is_jasc_palette_lut(name)) { *p = '\0'; // don't show ".pal" extension in menu names[n++] = name_dup; // quit when we get too many if (n > MAX_LUTS) break; } } else break; } g_dir_close(lut_dir); // alphabetize qsort(names, n, sizeof(char*), my_strcmp); // now populate the menus for (i=0; i<n; ++i) { browse_item = gtk_menu_item_new_with_label(names[i]); g_object_set_data(G_OBJECT(browse_item), "file", (gpointer)names[i]); g_object_set_data(G_OBJECT(browse_item), "index", GUINT_TO_POINTER(i+2)); gtk_menu_append(GTK_MENU(browse_menu), browse_item); gtk_widget_show(browse_item); g_hash_table_insert(g_polsarpro_classification_optionmenu_ht, (gpointer)g_strdup(names[i]), GUINT_TO_POINTER(i+2)); } } browse_option_menu = get_widget_checked("browse_select_colormap_optionmenu"); gtk_option_menu_set_menu(GTK_OPTION_MENU(browse_option_menu), browse_menu); gtk_option_menu_set_history(GTK_OPTION_MENU(browse_option_menu), 0); gtk_widget_show(browse_menu); gtk_widget_show(browse_option_menu); }
SIGNAL_CALLBACK void on_help_button_clicked(GtkWidget *widget) { #ifdef win32 char hh[1024]; // First method, get location of help viewer from the standard registry location get_string_from_registry_ex("SOFTWARE\\Classes\\chm.file\\shell\\open\\command", "", hh); if (strlen(hh) > 0) { char *p = strstr(hh, "%1"); if (p) *p = '\0'; char * escaped_share_dir = escapify(get_asf_share_dir()); strcat(hh, escaped_share_dir); strcat(hh, "/mapready.chm"); FREE(escaped_share_dir); } // Failed to find location of hh.exe through registry... try the system directory char *sr = getenv("SYSTEMROOT"); if (strlen(sr) > 0) { int i, j = 0; for (i = 0; i < strlen(sr); ++i) { switch(sr[i]) { case '\\': hh[j] = '\\'; hh[j+1] = '\\'; ++j; break; default: hh[j] = sr[i]; break; } ++j; } hh[j] = '\0'; strcat(hh, "/hh.exe "); char * escaped_share_dir = escapify(get_asf_share_dir()); strcat(hh, escaped_share_dir); strcat(hh, "/mapready.chm"); FREE(escaped_share_dir); } if (strlen(hh)>0) { static GThreadPool *ttp = NULL; GError *err = NULL; if (!ttp) { if (!g_thread_supported ()) g_thread_init (NULL); ttp = g_thread_pool_new ((GFunc)help_viewer_thread, NULL, 4, TRUE, &err); g_assert(!err); } g_thread_pool_push (ttp, g_string_new (hh), &err); g_assert(!err); } else { // Failed, give up. message_box("Couldn't find the help viewer!"); } #else GtkWidget *help_dialog; GtkWidget *help_text; GtkTextBuffer * text_buffer; FILE * help_file; gchar * help_filename; help_dialog = get_widget_checked("help_dialog"); help_text = get_widget_checked("help_text"); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(help_text)); gtk_text_buffer_set_text(text_buffer, "", -1); help_filename = "mapready.txt"; //help_file = fopen(help_filename, "rt"); help_file = fopen_share_file(help_filename, "rt"); if (help_file) { int line_count = 0; gchar * buffer = (gchar *) g_malloc(sizeof(gchar) * max_line_len); while (!feof(help_file)) { gchar *p = fgets(buffer, max_line_len, help_file); if (p) { if (strlen(p)) line_count++; GtkTextIter end; gchar * q = strstr(buffer, "$VERSION"); if (q) { gchar * r = g_strdup(q + 8); /* 8 = length of '$VERSION' */ strcpy(q, MAPREADY_VERSION_STRING); strcat(buffer, r); g_free(r); } gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); } } if (!line_count) { sprintf(buffer, "\n\n ERROR: Empty help file (mapready.txt) in share folder\n(%s)\n", get_asf_share_dir()); GtkTextIter end; gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); } fclose(help_file); g_free(buffer); } else { // No help file found gchar *buffer = (gchar *) g_malloc(sizeof(gchar) * max_line_len); strcpy(buffer, "\n\n ERROR: Cannot find help file (mapready.txt) in share folder.\n"); GtkTextIter end; gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); g_free(buffer); } gtk_widget_show(help_dialog); #endif }
static void load_file_banded_imp(const char *file, const char *band, int reset_location, int multilook) { char *old_file = NULL; if (curr->filename) { old_file = STRDUP(curr->filename); free(curr->filename); curr->filename = NULL; } reset_globals(reset_location); asfPrintStatus("\nLoading: %s\n", file); // start loading of the new file curr->filename = STRDUP(file); // strip off a trailing "." if (curr->filename[strlen(curr->filename)-1] == '.') curr->filename[strlen(curr->filename)-1] = '\0'; // Determine if the current file is a new file static char *last_file = NULL; int new_file = 0; if (!last_file) last_file = STRDUP(curr->filename); if (last_file && strcmp(last_file, curr->filename) != 0) { new_file = 1; FREE(last_file); last_file = STRDUP(curr->filename); } if (read_file(curr->filename, band, multilook, FALSE)) { int dummy; char lut[256]; static int tiff_lut_exists = 0; static int asf_colormap_exists = 0; char embedded_tiff_lut_file[1024]; char embedded_asf_colormap_file[1024]; char *lut_loc = (char *)MALLOC(sizeof(char)*(strlen(get_asf_share_dir())+128)); sprintf(lut_loc, "%s%clook_up_tables", get_asf_share_dir(), DIR_SEPARATOR); sprintf(embedded_tiff_lut_file,"%s%c%s", lut_loc, DIR_SEPARATOR, EMBEDDED_TIFF_COLORMAP_LUT_FILE); sprintf(embedded_asf_colormap_file, "%s%c%s", lut_loc, DIR_SEPARATOR, EMBEDDED_ASF_COLORMAP_LUT_FILE); FREE(lut_loc); tiff_lut_exists = new_file ? 0 : tiff_lut_exists; asf_colormap_exists = new_file ? 0 : asf_colormap_exists; tiff_lut_exists += fileExists(embedded_tiff_lut_file) ? 1 : 0; asf_colormap_exists += fileExists(embedded_asf_colormap_file) ? 1 : 0; GtkWidget *om = get_widget_checked("lut_optionmenu"); int idx = gtk_option_menu_get_history(GTK_OPTION_MENU(om)); if (tiff_lut_exists <= 1 && check_for_embedded_tiff_lut(curr->filename, &dummy, lut)) { // On first read of a TIFF file, check for embedded colormap and turn it into a // look up table if it exists ...then select it // (Run this stuff ONCE ...else the embedded lut will keep getting selected, even if changed) if (fileExists(embedded_asf_colormap_file)) { remove(embedded_asf_colormap_file); asf_colormap_exists = 0; } if (get_tiff_lut_index() == 0) { populate_lut_combo(); GtkWidget *option_menu = get_widget_checked("lut_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), get_tiff_lut_index()); set_current_index(get_tiff_lut_index()); select_lut(lut); } else { set_current_index(idx); } } else if (tiff_lut_exists && !check_for_embedded_tiff_lut(curr->filename, &dummy, lut)) { // If a tiff colormap look up table exists, but the current file being // read is not a color map tiff, then delete the existing tiff color map // look up table remove(embedded_tiff_lut_file); tiff_lut_exists = 0; populate_lut_combo(); // Re-populate since tiff colormap lut was removed GtkWidget *option_menu = get_widget_checked("lut_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), 0); // Default to None set_current_index(0); } if (asf_colormap_exists <= 1 && is_colormap_ASF_file(curr->filename)) { // On first read of an ASF file, check for a colormap and turn it into a // look up table if it exists ...then select it // (Run this stuff ONCE ...else the embedded lut will keep getting selected, even if changed) if (fileExists(embedded_tiff_lut_file)) { remove(embedded_tiff_lut_file); tiff_lut_exists = 0; } if (get_asf_lut_index() == 0) { populate_lut_combo(); select_lut(EMBEDDED_ASF_COLORMAP_LUT); GtkWidget *option_menu = get_widget_checked("lut_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), get_asf_lut_index()); set_current_index(get_asf_lut_index()); } else { set_current_index(idx); } } else if (asf_colormap_exists && !is_colormap_ASF_file(curr->filename)) { // If an ASF colormap look up table exists, but the current file being // read does not contain a color map in the metadata, then delete the existing ASF color map // look up table remove(embedded_asf_colormap_file); asf_colormap_exists = 0; populate_lut_combo(); // Re-populate since tiff colormap lut was removed GtkWidget *option_menu = get_widget_checked("lut_optionmenu"); gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), 0); // Default to None set_current_index(0); } if (new_file && !tiff_lut_exists && !asf_colormap_exists && reset_location && curr->meta && curr->meta->general) { // Change LUT selection if necessary set_lut_based_on_image_type(curr->meta->general->image_data_type); } else if (!new_file) { // Respect any changes made by the user to the look-up table selection after // the file has loaded the first time ... set_current_index(idx); } check_lut(); set_title(band != NULL, band); // load the metadata & image data, other setup fill_small_force_reload(curr); fill_big(curr); update_pixel_info(curr); update_zoom(); fill_meta_info(); fill_stats(curr); setup_bands_tab(curr->meta); FREE(old_file); } else { // file failed to load, re-load the old one // this is to prevent trying to re-load the old file again & again, // if for some reason that fails if (strcmp(curr->filename, old_file) == 0) { // if this does happen, just quit asfPrintError("Failed to load %s.\n", curr->filename); } asfPrintStatus("Failed to load %s. Re-loading %s.\n", curr->filename, old_file); load_file_banded_imp(old_file, band, reset_location, multilook); if (reset_location) { center_samp = (double)(curr->ns)/2.; center_line = (double)(curr->nl)/2.; crosshair_samp = (double)(curr->ns)/2.; crosshair_line = (double)(curr->nl)/2.; } } }
int write_test_config(char *configFile, test_config *cfg) { FILE *fConfig; int shortFlag = FALSE, ii; if (cfg == NULL) check_return(1, "No configuration structure to write.\n"); if (cfg->general->short_config) shortFlag = TRUE; fConfig = FOPEN(configFile, "w"); fprintf(fConfig, "%s\n\n", cfg->comment); fprintf(fConfig, "[General]\n"); // suite if (!shortFlag) fprintf(fConfig, "\n# This parameter defines the name of the test suite\n\n"); fprintf(fConfig, "suite = %s\n", cfg->general->suite); // type if (!shortFlag) fprintf(fConfig, "\n# This parameter defines the test type: metadata, binary\n" "# metadata runs checks on .meta file.\n" "# binary run checks on binary data files.\n\n"); fprintf(fConfig, "type = %s\n", cfg->general->type); // short configuration if (!shortFlag) fprintf(fConfig, "\n# The short configuration file flag allows the experienced " "user to\n# generate configuration files without the verbose " "comments that explain all\n# entries for the parameters in the " "configuration file (1 for a configuration\n# without comments, 0 " "for a configuration file with verbose comments)\n\n"); fprintf(fConfig, "short configuration file = %d\n", cfg->general->short_config); // status if (!shortFlag) fprintf(fConfig, "\n# The general status field indicates the progress of the " "testing.\n# Unless the interface is chosen to be 'manual' the tool " "will run all tests\n# regardless of their individual status.\n" "# Values for status: new, passed, failed\n\n"); fprintf(fConfig, "status = %s\n", cfg->general->status); if (!shortFlag) fprintf(fConfig, "\n# Each test of the suite has its own section. The name of " "the test is\n# user defined in name of the section [<test name>]" "\n\n"); for (ii=0; ii<cfg->general->test_count; ii++) { fprintf(fConfig, "\n[%s]\n", cfg->test[ii]->test); if (strcmp_case(cfg->general->type, "library") == 0) { // library if (!shortFlag) fprintf(fConfig, "\n# This parameter defines the name of the library function to be tested.\n\n"); fprintf(fConfig, "library function = %s\n", cfg->test[ii]->lib->name); } else { // file if (!shortFlag) fprintf(fConfig, "\n# This parameters defines the name of the file to be " "tested.\n\n"); fprintf(fConfig, "file = %s\n", cfg->test[ii]->file); } // specs if (!shortFlag) fprintf(fConfig, "\n# This parameters defines the name of the specification " "file that contains\n# the metadata parameters that are being " "checked. They can be checked for\n# existence in the file, a value " "within a range (defined by minimum and maximum)\n# and values in a " "predefined list.\n" "# The specification files are located in %s/meta_test.\n\n", get_asf_share_dir()); fprintf(fConfig, "specs = %s\n", cfg->test[ii]->specs); // status if (!shortFlag) fprintf(fConfig, "\n# The parameter indicates the status of this test.\n" "# Unless the interface is chosen to be 'manual' the tool " "will run all tests\n# regardless of their individual status.\n" "# Once a test is run, the status is either 'passed' or 'failed'. " "To avoid\n# that a test is executed altogether in manual mode set " "the status to 'skip'\n" "# Values for status: new, passed, failed, skip\n\n"); fprintf(fConfig, "status = %s\n", cfg->test[ii]->status); } FCLOSE(fConfig); return(0); }
int init_test_config(char *configFile) { FILE *fConfig; if ( fileExists(configFile) ) { asfPrintError("Cannot create file, %s, because it already exists.\n", configFile); } fConfig = FOPEN(configFile, "w"); fprintf(fConfig, "asf_test configuration file\n\n"); fprintf(fConfig, "[General]\n\n"); // suite fprintf(fConfig, "# This parameter defines the name of the test suite\n\n"); fprintf(fConfig, "suite = \n\n"); // type fprintf(fConfig, "# This parameter defines the test type: metadata, library, " "binary\n# metadata runs checks on .meta file.\n" "# library run on library functions.\n" "# binary run checks on binary data files.\n\n"); fprintf(fConfig, "type = metadata\n\n"); // short configuration fprintf(fConfig, "# The short configuration file flag allows the experienced " "user to\n# generate configuration files without the verbose " "comments that explain all\n# entries for the parameters in the " "configuration file (1 for a configuration\n# without comments, 0 " "for a configuration file with verbose comments)\n\n"); fprintf(fConfig, "short configuration file = 0\n\n"); // status fprintf(fConfig, "# The general status field indicates the progress of the " "testing.\n# Unless the interface is chosen to be 'manual' the tool " "will run all tests\n# regardless of their individual status.\n" "# Values for status: new, passed, failed\n\n"); fprintf(fConfig, "status = new\n\n"); fprintf(fConfig, "# Each test of the suite has its own section. The name of " "the test is\n# user defined in name of the section [<test name>]" "\n\n"); fprintf(fConfig, "[Test]\n\n"); // file fprintf(fConfig, "# This parameters defines the name of the file to be " "tested.\n\n"); fprintf(fConfig, "file = \n\n");\ // specs fprintf(fConfig, "# This parameters defines the name of the specification " "file that contains\n# the metadata parameters that are being " "checked. They can be checked for\n# existence in the file, a value " "within a range (defined by minimum and maximum)\n# and values in a " "predefined list.\n" "# The specification files are located in %s/meta_test.\n\n", get_asf_share_dir()); fprintf(fConfig, "specs = \n\n"); // status fprintf(fConfig, "# The parameter indicates the status of this test.\n" "# Unless the interface is chosen to be 'manual' the tool " "will run all tests\n# regardless of their individual status.\n" "# Once a test is run, the status is either 'passed' or 'failed'. " "To avoid\n# that a test is executed altogether in manual mode set " "the status to 'skip'\n" "# Values for status: new, passed, failed, skip\n\n"); fprintf(fConfig, "status = new\n\n"); FCLOSE(fConfig); asfPrintStatus(" Initialized test configuration file\n\n"); return(0); }
int asf_import(radiometry_t radiometry, int db_flag, int complex_flag, int multilook_flag, int azimuth_look_count, int range_look_count, int amp0_flag, input_format_t format_type, char *band_id, char *data_type, char *image_data_type, char *lutName, char *prcPath, double lowerLat, double upperLat, double lowerLon, double upperLon, int line, int sample, int width, int height, int save_intermediates, double *p_range_scale, double *p_azimuth_scale, double *p_correct_y_pixel_size, int apply_ers2_gain_fix, char *inMetaNameOption, char *inBaseName, char *ancillary_file, char *colormapName, char *slave_file, char *interferogram_file, char *coherence_file, char *baseline_file, int complex_gamma, char *uavsar_type, int metaonly, char *outBaseName) { char outDataName[256], outMetaName[256]; asfPrintStatus(" Importing: %s\n", inBaseName); /* printf("\nradiometry: %d\n", radiometry); printf("db_flag: %d\n", db_flag); printf("complex_flag: %d\n", complex_flag); printf("multilook_flag: %d\n", multilook_flag); printf("amp0_flag: %d\n", amp0_flag); printf("format_type: %d\n", format_type); printf("band_id: %s\n", band_id); printf("data_type: %s\n", data_type); printf("image_data_type: %s\n", image_data_type); printf("lutName: %s\n", lutName); printf("line: %d\n", line); printf("sample: %d\n", sample); printf("width: %d\n", width); printf("height: %d\n", height); printf("p_range_scale: %f\n", &p_range_scale); printf("p_azimuth_scale: %f\n", &p_azimuth_scale); printf("p_correct_y_pixel_size: %f\n", &p_correct_y_pixel_size); printf("apply_ers2_gain_fix: %d\n", apply_ers2_gain_fix); printf("inMetaNameOption: %s\n", inMetaNameOption); printf("inBaseName: %s\n", inBaseName); printf("outBaseName: %s\n\n", outBaseName); */ strcpy(outDataName, outBaseName); strcpy(outMetaName, outBaseName); strcat(outMetaName, TOOLS_META_EXT); if (metaonly) { create_xml_meta(inBaseName, outBaseName, format_type); return 0; } if ((radiometry == r_SIGMA || radiometry == r_BETA || radiometry == r_GAMMA || radiometry == r_POWER) && !(format_type == CEOS || format_type == STF || format_type == AIRSAR || format_type == ALOS_MOSAIC || format_type == TERRASAR)) { // A power flag is on, but the input file is not CEOS or STF format // so it will be ignored asfPrintWarning("Power flags %s%s will be only accepted for the following\n" "data formats since other formats do not indicate what " "type of data is in the file:\n" "CEOS, TERRASAR, STF, AirSAR and ALOS mosaics.\n" "Assuming the input data is an AMPLITUDE image...\n", radiometry == r_SIGMA ? "SIGMA" : radiometry == r_BETA ? "BETA" : radiometry == r_GAMMA ? "GAMMA" : radiometry == r_POWER ? "POWER" : "UNKNOWN", db_flag ? " scaled to DECIBELS" : ""); } // Ingest all sorts of flavors of CEOS data/ if (format_type == CEOS) { asfPrintStatus(" Data format: CEOS\n"); import_ceos(inBaseName, outBaseName, band_id, lutName, p_range_scale, p_azimuth_scale, p_correct_y_pixel_size, line, sample, width, height, inMetaNameOption, radiometry, db_flag, complex_flag, multilook_flag, azimuth_look_count, range_look_count, amp0_flag, apply_ers2_gain_fix); // Replace the restituted state vectors that comes with the image data with // precision state vectors from Delft if (prcPath != NULL && strlen(prcPath) > 0) { update_state_vectors(outBaseName, prcPath); } } // Ingest Vexcel Sky Telemetry Format (STF) data else if (format_type == STF) { asfPrintStatus(" Data format: STF\n"); int lat_constrained = upperLat != -99 && lowerLat != -99; import_stf(inBaseName, outBaseName, radiometry, inMetaNameOption, lat_constrained, lowerLat, upperLat, prcPath); } else if (format_type == GENERIC_GEOTIFF) { asfPrintStatus(" Data format: GEOTIFF\n"); if (band_id != NULL && strlen(band_id) > 0 && strncmp(uc(band_id), "ALL", 3) != 0) { asfPrintWarning("The -band option is not supported for data files containing\n" "multiple bands within a single file (such as GeoTIFF or TIFF)\n" "rather than in individual band files (such as ALOS etc).\n" "\nThe import will continue, but all available bands will be\n" "imported into a single ASF-format file. You may select any\n" "individual band for export however.\n"); } char *ext = findExt(inBaseName); if (ext != NULL) { *ext = '\0'; } GString *inGeotiffName = find_geotiff_name (inBaseName); if ( inGeotiffName == NULL ) { asfPrintError ("Couldn't find a GeoTIFF file (i.e. a file with " "extension '.tif', '.tiff',\n'.TIF', or '.TIFF') " "corresponding to specified inBaseName:\n" "%s\n", inBaseName); } if (strlen(image_data_type) && strncmp(image_data_type, MAGIC_UNSET_STRING, strlen(MAGIC_UNSET_STRING)) != 0) { import_generic_geotiff (inGeotiffName->str, outBaseName, image_data_type); } else { import_generic_geotiff (inGeotiffName->str, outBaseName, NULL); } g_string_free(inGeotiffName,TRUE); } else if (format_type == BIL) { asfPrintStatus(" Data format: BIL\n"); import_bil(inBaseName, outBaseName); } else if (format_type == GRIDFLOAT) { asfPrintStatus(" Data format: GRIDFLOAT\n"); import_gridfloat(inBaseName, outBaseName); } else if (format_type == AIRSAR) { asfPrintStatus(" Data format: AIRSAR\n"); import_airsar(inBaseName, update(radiometry, db_flag), outBaseName); } else if (format_type == UAVSAR) { asfPrintStatus(" Data format: UAVSAR\n"); import_uavsar(inBaseName, line, sample, width, height, update(radiometry, db_flag), uavsar_type, outBaseName); } else if (format_type == VP) { asfPrintStatus(" Data format: VP\n"); import_vexcel_plain(inBaseName, outBaseName); } else if (format_type == JAXA_L0) { asfPrintStatus(" Data format: JAXA_L0 (ALOS AVNIR-2 Level 0)\n"); import_jaxa_L0(inBaseName, outBaseName); } else if (format_type == ALOS_MOSAIC) { asfPrintStatus(" Data format: ALOS MOSAIC\n"); import_alos_mosaic(inBaseName, update(radiometry, db_flag), outBaseName); } else if (format_type == TERRASAR) { asfPrintStatus(" Data format: TERRASAR\n"); import_terrasar(inBaseName, update(radiometry, db_flag), outBaseName, 0); } else if (format_type == RADARSAT2) { asfPrintStatus(" Data format: RADARSAT2\n"); import_radarsat2(inBaseName, update(radiometry, db_flag), outBaseName, 0); } else if (format_type == POLSARPRO) { asfPrintStatus(" Data format: POLSARPRO\n"); import_polsarpro(inBaseName, ancillary_file, colormapName, image_data_type, db_flag, outBaseName); } else if (format_type == GAMMA) { asfPrintStatus(" Data format: GAMMA\n"); import_gamma(inBaseName, inMetaNameOption, slave_file, interferogram_file, coherence_file, baseline_file, complex_gamma, outBaseName); } else if (format_type == ROIPAC) { asfPrintStatus(" Data format: ROI_PAC\n"); import_roipac(inBaseName, outBaseName); } else if (format_type == SMAP) { asfPrintStatus(" Data format: SMAP\n"); import_smap(inBaseName, outBaseName, upperLat, upperLon, lowerLat, lowerLon); } // Don't recognize this data format; report & quit else { asfPrintError("Unrecognized data format: '%d'\n",format_type); } int num_elements = 0; int is_jasc_palette = 0; if (format_type == AIRSAR && colormapName != NULL) asfPrintError("Colormaps not supported for AirSAR data.\n"); if (format_type != AIRSAR && format_type != UAVSAR) { meta_parameters *meta = meta_read(outMetaName); if (meta->colormap) { if (!(colormapName != NULL && (meta->general->data_type == ASF_BYTE || is_PolSARpro(inBaseName)))) { // Ooops. Tried to apply a colormap to the wrong type of data asfPrintWarning( "Color map specified with the -colormap option (%s) not\n" "applied during ingest. Color maps can only be applied to byte or\n" "PolSARpro data. Data was imported as-is.\n", colormapName); } else { // Apply the user-selected color map to the metadata FILE *fp = NULL; unsigned char * lut_buffer; char *lut_basename = STRDUP(colormapName); char *ext = findExt(lut_basename); if (ext) *ext = '\0'; // Check LUT file validity and allocate appropriately sized buffer // to read into char magic_str[1024]; char version_s[1024]; char num_elements_s[1024]; char lut_path[1024]; sprintf(lut_path, "%s%clook_up_tables%c%s.pal", get_asf_share_dir(), DIR_SEPARATOR, DIR_SEPARATOR, lut_basename); if (fileExists(lut_path)) { fp = (FILE*)FOPEN(lut_path, "rt"); fgets(magic_str, 1024, fp); fgets(version_s, 1024, fp); fgets(num_elements_s, 1024, fp); FCLOSE(fp); int version = atoi(version_s); num_elements = atoi(num_elements_s); is_jasc_palette = (strncmp(magic_str, "JASC", 4) == 0 && version == 100) ? 1 : 0; if (is_jasc_palette && (num_elements <= 0 || num_elements > 512)) { asfPrintWarning( "Found invalid JASC-PAL type color map file (%s) ...color map\n" "not applied.\n", colormapName); } if (num_elements > 256) { asfPrintWarning( "PolSARpro look-up table contains more than 256 elements (%d).\n" "Only the first 256 will be read and mapped to data.\n", num_elements); } } else { sprintf(lut_path, "%s%clook_up_tables%c%s.lut", get_asf_share_dir(), DIR_SEPARATOR, DIR_SEPARATOR, lut_basename); if (fileExists(lut_path)) { is_jasc_palette = 0; // Assume ASF format } else { strcpy(lut_path, ""); } } lut_buffer = MALLOC(sizeof(unsigned char) * 3 * MAX_LUT_DN); // Read the LUT if (strlen(lut_path) > 0) { int max_dn = read_lut(lut_path, lut_buffer); // Populate the metadata colormap if (!meta->colormap) meta->colormap = meta_colormap_init(); if (is_jasc_palette) { meta->colormap->num_elements = (num_elements <= 256) ? num_elements : 256; sprintf(meta->colormap->look_up_table, "%s.pal", lut_basename); } else { num_elements = max_dn + 1; meta->colormap->num_elements = num_elements; sprintf(meta->colormap->look_up_table, "%s.lut", lut_basename); } meta->colormap->rgb = (meta_rgb*)CALLOC(meta->colormap->num_elements, sizeof(meta_rgb)); int i; for (i = 0; i < meta->colormap->num_elements; i++) { meta->colormap->rgb[i].red = lut_buffer[i*3]; meta->colormap->rgb[i].green = lut_buffer[i*3+1]; meta->colormap->rgb[i].blue = lut_buffer[i*3+2]; } } FREE(lut_basename); meta_write(meta, outMetaName); } } meta_free(meta); } asfPrintStatus("Import complete.\n\n"); return 0; }
int open_google_earth() { char *kml_filename = appendExt(curr->filename, ".kml"); char *basename = get_basename(curr->filename); char *dirname = get_dirname(curr->filename); char *arg; if (strlen(dirname)==0) { char *tmpdir = g_get_current_dir(); dirname = escapify(tmpdir); arg = MALLOC(sizeof(char)*(strlen(dirname)+strlen(kml_filename)+20)); sprintf(arg, "%s/%s", dirname, kml_filename); //free(tmpdir); } else { arg = STRDUP(kml_filename); } char *png_file = appendExt(arg, ".png"); printf("png file: %s\n", png_file); printf("Temporary kml file: %s\n", arg); FILE *kml_file = fopen(arg, "w"); if (!kml_file) { asfPrintWarning("Couldn't open kml file!\n"); return FALSE; } dbf_header_t *dbf; int nAttr, nCoords; double *lat, *lon, center_lat, center_lon; char configFile[255], *name; meta_parameters *meta; sprintf(configFile, "%s/convert2vector.config", get_asf_share_dir()); c2v_config *cfg = read_c2v_config(configFile); kml_header(kml_file); meta = meta2vector(curr->filename, &dbf, &nAttr, &lat, &lon, &nCoords); //meta_parameters *meta = curr->meta; if (meta && meta->general && meta_is_valid_double(meta->general->center_latitude) && meta_is_valid_double(meta->general->center_longitude)) { pixbuf2png(pixbuf_small, png_file); //kml_entry_with_overlay(kml_file, meta, basename, png_file, dirname); name = get_basename(kml_filename); center_lat = meta->general->center_latitude; center_lon = meta->general->center_longitude; write_kml_placemark(kml_file, name, center_lat, center_lon, png_file, dbf, nAttr, lat, lon, nCoords, cfg); FREE(lat); FREE(lon); FREE(dbf); } else { asfPrintWarning( "Failed, metadata doesn't contain valid lat/lon info.\n"); return FALSE; } kml_footer(kml_file); fclose(kml_file); gchar *ge; printf("kml: %s\n", kml_filename); printf("dir: %s\n", dirname); #ifdef win32 char path[1024]; FindExecutable((LPCTSTR)kml_filename, (LPCTSTR)dirname, (LPTSTR)path); ge = escapify(path); printf("Path to google earth: %s\n", ge); asfSystem("\"%s\" \"%s\"", ge, arg); #else ge = find_in_path("googleearth"); if (!ge) { message_box("Couldn't find googleearth! Is it installed?"); return FALSE; } int pid = fork(); if (pid == 0) { asfSystem("\"%s\" \"%s\"", ge, arg); //unlink(kml_filename); exit(EXIT_SUCCESS); } #endif free(kml_filename); free(basename); free(dirname); free(arg); return TRUE; }
void settings_save(Settings *s) { char *sav_file = find_in_share("req_settings.txt"); if (sav_file && fileExists(sav_file)) { // update an existing file printf("Found settings file: %s\n", sav_file); char *new_sav_txt = MALLOC(sizeof(char)*1024); strcpy(new_sav_txt, ""); int i,len=2048; int wrote_csv=FALSE, wrote_output=FALSE, wrote_obs_req_num=FALSE, wrote_obs_req_id_aadn=FALSE, wrote_obs_req_id_tdrs=FALSE, wrote_acq_req_num=FALSE, wrote_odl0_seq_num=FALSE, wrote_odl0_req_id=FALSE, wrote_station_code=FALSE; int wrote_acq_req_id[MAX_STATIONS]; int wrote_acq_req_stn_code[MAX_STATIONS]; for (i=0; i<MAX_STATIONS; ++i) { wrote_acq_req_id[i] = FALSE; wrote_acq_req_stn_code[i] = FALSE; } FILE *fp = FOPEN(sav_file, "r"); if (!fp) { message_box("Error opening output file!\n"); return; } char buf[1024]; while (fgets(buf, 1024, fp) != NULL) { if (s->csv_dir && matches(buf, csv_dir_key)) { add_to_text(&new_sav_txt, &len, "%s = %s\r\n", csv_dir_key, s->csv_dir); wrote_csv = TRUE; } else if (s->output_dir && matches(buf, output_dir_key)) { add_to_text(&new_sav_txt, &len, "%s = %s\r\n", output_dir_key, s->output_dir); wrote_output = TRUE; } else if (matches(buf, obs_req_num_key)) { add_to_text(&new_sav_txt, &len, "%s = %d\r\n", obs_req_num_key, s->obs_req_num); wrote_obs_req_num = TRUE; } else if (matches(buf, obs_req_id_aadn_key)) { add_to_text(&new_sav_txt, &len, "%s = %d\r\n", obs_req_id_aadn_key, s->obs_req_id_aadn); wrote_obs_req_id_aadn = TRUE; } else if (matches(buf, obs_req_id_tdrs_key)) { add_to_text(&new_sav_txt, &len, "%s = %d\r\n", obs_req_id_tdrs_key, s->obs_req_id_tdrs); wrote_obs_req_id_tdrs = TRUE; } else if (matches(buf, acq_req_num_key)) { add_to_text(&new_sav_txt, &len, "%s = %d\r\n", acq_req_num_key, s->acq_req_num); wrote_acq_req_num = TRUE; } else if (matches(buf, odl0_seq_num_key)) { add_to_text(&new_sav_txt, &len, "%s = %d\r\n", odl0_seq_num_key, s->odl0_seq_num); wrote_odl0_seq_num = TRUE; } else if (matches(buf, odl0_req_id_key)) { add_to_text(&new_sav_txt, &len, "%s = %d\r\n", odl0_req_id_key, s->odl0_req_id); wrote_odl0_req_id = TRUE; } else if (s->station_code && matches(buf, station_code_key)) { add_to_text(&new_sav_txt, &len, "%s = %s\r\n", station_code_key, s->station_code); wrote_station_code = TRUE; } else { int found=0; for (i=0; i<MAX_STATIONS; ++i) { char id_key[128], stn_code_key[128]; snprintf(id_key, 128, "%s %d", acq_req_id_key, i+1); snprintf(stn_code_key, 128, "%s %d", acq_req_stn_code_key, i+1); if (matches(buf, id_key)) { found = TRUE; add_to_text(&new_sav_txt, &len, "%s = %s\r\n", stn_code_key, s->acq_req_stn_codes[i]); wrote_acq_req_stn_code[i] = TRUE; } else if (matches(buf, stn_code_key)) { found = TRUE; add_to_text(&new_sav_txt, &len, "%s = %d\r\n", id_key, s->acq_req_ids[i]); wrote_acq_req_id[i] = TRUE; } } if (!found) add_to_text(&new_sav_txt, &len, "%s", buf); } } FCLOSE(fp); if (s->csv_dir && !wrote_csv) add_to_text(&new_sav_txt, &len, "%s = %s\r\n", csv_dir_key, s->csv_dir); if (s->output_dir && !wrote_output) add_to_text(&new_sav_txt, &len, "%s = %s\r\n", output_dir_key, s->output_dir); if (!wrote_obs_req_num && s->obs_req_num > 1) add_to_text(&new_sav_txt, &len, "%s = %d\r\n", obs_req_num_key, s->obs_req_num); if (!wrote_obs_req_id_aadn && s->obs_req_id_aadn > 1) add_to_text(&new_sav_txt, &len, "%s = %d\r\n", obs_req_id_aadn_key, s->obs_req_id_aadn); if (!wrote_obs_req_id_tdrs && s->obs_req_id_tdrs > 1) add_to_text(&new_sav_txt, &len, "%s = %d\r\n", obs_req_id_tdrs_key, s->obs_req_id_tdrs); if (!wrote_acq_req_num && s->acq_req_num > 1) add_to_text(&new_sav_txt, &len, "%s = %d\r\n", acq_req_num_key, s->acq_req_num); if (!wrote_odl0_seq_num && s->odl0_seq_num > 1) add_to_text(&new_sav_txt, &len, "%s = %d\r\n", odl0_seq_num_key, s->odl0_seq_num); if (!wrote_odl0_req_id && s->odl0_req_id > 1) add_to_text(&new_sav_txt, &len, "%s = %d\r\n", s->odl0_req_id); if (s->station_code && !wrote_station_code) add_to_text(&new_sav_txt, &len, "%s = %s\r\n", station_code_key, s->station_code); for (i=0; i<MAX_STATIONS; ++i) { if (!wrote_acq_req_id[i] && s->acq_req_ids[i] > 0 && !wrote_acq_req_stn_code[i] && strlen(s->acq_req_stn_codes[i]) > 0) { char id_key[128], stn_code_key[128]; snprintf(id_key, 128, "%s %d", acq_req_id_key, i+1); snprintf(stn_code_key, 128, "%s %d", acq_req_stn_code_key, i+1); add_to_text(&new_sav_txt, &len, "%s = %d\r\n", stn_code_key, s->acq_req_stn_codes[i]); add_to_text(&new_sav_txt, &len, "%s = %d\r\n", id_key, s->acq_req_ids[i]); } } fp = FOPEN(sav_file, "w"); fprintf(fp, "%s", new_sav_txt); FCLOSE(fp); } else { sav_file = MALLOC(sizeof(char)*(strlen(get_asf_share_dir())+32)); sprintf(sav_file, "%s/req_settings.txt", get_asf_share_dir()); // write a new file FILE *fp = FOPEN(sav_file, "w"); if (s->csv_dir) fprintf(fp, "%s = %s\r\n", csv_dir_key, s->csv_dir); if (s->output_dir) fprintf(fp, "%s = %s\r\n", output_dir_key, s->output_dir); fprintf(fp, "%s = %d\r\n", obs_req_num_key, s->obs_req_num); fprintf(fp, "%s = %d\r\n", obs_req_id_aadn_key, s->obs_req_id_aadn); fprintf(fp, "%s = %d\r\n", obs_req_id_tdrs_key, s->obs_req_id_tdrs); fprintf(fp, "%s = %d\r\n", acq_req_num_key, s->acq_req_num); fprintf(fp, "%s = %d\r\n", odl0_seq_num_key, s->odl0_seq_num); fprintf(fp, "%s = %d\r\n", odl0_req_id_key, s->odl0_req_id); int i; for (i=0; i<MAX_STATIONS; ++i) { if (s->acq_req_ids[i] > 0 && strlen(s->acq_req_stn_codes[i]) > 0) { char id_key[128], stn_code_key[128]; snprintf(stn_code_key, 128, "%s %d", acq_req_stn_code_key, i+1); fprintf(fp, "%s = %s\r\n", stn_code_key, s->acq_req_stn_codes[i]); snprintf(id_key, 128, "%s %d", acq_req_id_key, i+1); fprintf(fp, "%s = %d\r\n", id_key, s->acq_req_ids[i]); } } if (s->station_code) fprintf(fp, "%s = %s\r\n", station_code_key, s->station_code); FCLOSE(fp); } free(sav_file); }