Exemple #1
0
// Main program body.
int
main (int argc, char *argv[])
{
    char *inFile, *outFile;
    int currArg = 1;
    int NUM_ARGS = 2;

    // process log/quiet/license/etc options
    handle_common_asf_args(&argc, &argv, ASF_NAME_STRING);
    asfSplashScreen(argc, argv);

    char classFile[255];
    int classify = extract_string_options(&argc,&argv,classFile,"-c",NULL);
    int debug = extract_flag_options(&argc,&argv,"-debug","-d",NULL);
    int pauli = extract_flag_options(&argc,&argv,"-pauli","-p",NULL);
    int sinclair = extract_flag_options(&argc,&argv,"-sinclair","-s",NULL);
    int freeman = extract_flag_options(&argc,&argv,"-freeman","-f",NULL);

    int sz;
    int make_boundary_file =
        extract_int_options(&argc,&argv,&sz,"-make-feasible-boundary",NULL);

    if (make_boundary_file) {
        const char *fname = "ea_boundary.txt";
        asfPrintStatus("Generating entropy/alpha boundary curve file: %s\n",
                       fname);
        asfPrintStatus("Number of points: %d\n", sz);
        make_entropy_alpha_boundary(fname, sz);

        // if no other arguments were supplied, we are done - can exit
        // without making a fuss.
        if (argc==1) {
            asfPrintStatus("Done.\n");
            exit(1);
        }
    }

    if (classify + pauli + sinclair + freeman > 1) {
        asfPrintError("Use only one of the -pauli, -sinclair, -freeman "
                      "or -c options.\n");
    }

    if (argc<=1)
        usage(ASF_NAME_STRING);
    else if (strmatches(argv[1],"-help","--help",NULL))
        print_help();
    else if (argc<=2)
        usage(ASF_NAME_STRING);

    while (currArg < (argc-NUM_ARGS)) {
        char *key = argv[currArg++];
        if (strmatches(key,"-help","--help",NULL)) {
            print_help(); // doesn't return
        }
        else {
            --currArg;
            break;
        }
    }
    if ((argc-currArg) < NUM_ARGS) {
        printf("Insufficient arguments.\n");
        usage(argv[0]);
    } else if ((argc-currArg) > NUM_ARGS) {
        printf("Unknown argument: %s\n", argv[currArg]);
        usage(argv[0]);
    }

    inFile = argv[currArg];
    outFile = argv[currArg+1];

    if (debug) {
        asfPrintError("Debug mode no longer available.\n");
        //cpx2debug(inFile,outFile);
    }
    else if (classify) {
        polarimetric_decomp(inFile,outFile,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
                            classFile,1);
    }
    else if (pauli) {
        cpx2pauli(inFile,outFile,TRUE);
    }
    else if (sinclair) {
        cpx2sinclair(inFile,outFile,FALSE);
    }
    else if (freeman) {
        cpx2freeman_durden(inFile,outFile,TRUE);
    }
    else {
        polarimetric_decomp(inFile,outFile,0,1,2,3,4,5,6,7,8,9,-1,-1,-1,NULL,-1);
    }


    asfPrintStatus("Done.\n");
    return EXIT_SUCCESS;
}
Exemple #2
0
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);
}
int main(int argc, char *argv[])
{
  int extentFlag = FALSE, multiband = FALSE;
  char *extent = (char *) MALLOC(sizeof(char)*1024);
  char *outfile = (char *) MALLOC(sizeof(char)*1024);
  
    handle_common_asf_args(&argc, &argv, ASF_NAME_STRING);
    if (argc>1 && (strcmp(argv[1], "-help")==0 || strcmp(argv[1],"--help")==0))
        help();
    if (argc<2) usage();

    double background_val=0;
    extract_double_options(&argc, &argv, &background_val, "-background",
                           "--background", "-b", NULL);
    if (extract_string_options(&argc, &argv, extent, "-extent", "--extent", 
			       NULL))
      extentFlag = TRUE;
    if (extract_string_options(&argc, &argv, outfile, "-output", "--output",
			       NULL))
      multiband = TRUE;
    int no_blackfill = 
      extract_flag_options(&argc, &argv, "-no_blackfill", "--no_blackfill",
                          NULL);
    
    char *infile = argv[1];

    int i, size_x, size_y, n_inputs=0, start=0, n_bands;
    double start_x, start_y;
    double per_x, per_y;

    asfSplashScreen(argc, argv);
    char *line = (char *) MALLOC(sizeof(char)*512);
    FILE *fpList = FOPEN(infile, "r");
    while (fgets(line, 512, fpList))
      if (strlen(line) > 0)
        n_inputs++;
    FCLOSE(fpList);
    if (extentFlag) {
      n_inputs++;
      start = 1;
    }
    char **infiles = (char **) MALLOC(sizeof(char *)*n_inputs);
    if (extentFlag) {
      infiles[0] = (char *) MALLOC(sizeof(char)*512);
      strcpy(infiles[0], extent);
    }
    fpList = FOPEN(infile, "r");
    for (i=start; i<n_inputs; i++) {
      fgets(line, 512, fpList);
      chomp(line);
      infiles[i] = (char *) MALLOC(sizeof(char)*512);
      strcpy(infiles[i], line);
    }
    FCLOSE(fpList);
    FREE(line);

    if (multiband)
      asfPrintStatus("Stacking %d files to produce: %s\n", n_inputs, outfile);
    else
      asfPrintStatus("Putting %d files in image stack\n", n_inputs);

    asfPrintStatus("Input files:\n");
    for (i=start; i<n_inputs; ++i)
      asfPrintStatus("   %d: %s%s\n", i+1, infiles[i], i==0 ? " (reference)" : "");

    determine_extents(infiles, n_inputs, &size_x, &size_y, &n_bands,
		      &start_x, &start_y, &per_x, &per_y, extentFlag,
                      no_blackfill);

    asfPrintStatus("\nStacked image size: %dx%d LxS\n", size_y, size_x);
    asfPrintStatus("  Start X,Y: %f,%f\n", start_x, start_y);
    asfPrintStatus("    Per X,Y: %.2f,%.2f\n", per_x, per_y);

    meta_parameters *meta_out = meta_read(infiles[0]);
    if (multiband)
      meta_out->general->image_data_type = IMAGE_LAYER_STACK;
    meta_out->projection->startX = start_x;
    meta_out->projection->startY = start_y;
    meta_out->general->line_count = size_y;
    meta_out->general->sample_count = size_x;
    meta_out->general->no_data = background_val;
    update_location_block(meta_out);

    char *outfile_full = (char *) MALLOC(sizeof(char)*1024);

    if (multiband) {
      sprintf(outfile_full, "%s.img", stripExt(outfile));
      meta_write(meta_out, outfile_full);
    }
    for (i=start; i<n_inputs; i++) {
      asfPrintStatus("\nProcessing band %d (%s) ... \n", i, infiles[i]);
      if (!multiband) {
	sprintf(outfile_full, "%s_stack.img", stripExt(infiles[i]));
	meta_write(meta_out, outfile_full);
      }
      add_to_stack(outfile_full, i, infiles[i], size_x, size_y, 
                   start_x, start_y, per_x, per_y, multiband);
    }
    meta_free(meta_out);

    FREE(outfile_full);
    for (i=0; i<n_inputs; i++)
      FREE(infiles[i]);
    FREE(infiles);
    FREE(extent);
    FREE(outfile);

    asfPrintStatus("Done.\n");
    return 0;
}
Exemple #4
0
// The program itself!
int main (int argc, char **argv)
{

	struct stat	 stat_buf;
	size_t		 wordsize=0;
	size_t		 bytesread=0;
	size_t		 byteswritten=0;
	size_t		 nitems=0;
	size_t		 ret=0;
	int		 done=FALSE;
	char		*in_fname=NULL;
	char		*out_fname=NULL;
	FILE		*in_fp=NULL;
	FILE		*out_fp=NULL;
	void		*buf=NULL;
	void		(*byteswap)(unsigned char *);
	
	// Search the command line for help & report if requested
	if (extract_flag_options(&argc, &argv, "-h", "-help", "--help", NULL)) {
		help();
	}

	// Grab the common asf options (eg -version, -quiet, etc)
	handle_common_asf_args(&argc, &argv, ASF_NAME_STRING);
	
	// Since handle_common_asf_args reduces argc for all the options
	// we can check argc to see if we've got 3 arguments & the progname
	if (argc != 4) {
		usage();
	}
/*
	// Make sure data types are of the size we expect
	asfRequire( sizeof(short) == SHORT_INT_SIZE,
	            "Short integers need to be %d bytes (%d-bits),"
		    " they appear to be %d bytes.\n",
		    SHORT_INT_SIZE, SHORT_INT_SIZE*8, sizeof(short));
	asfRequire( sizeof(int) == INT_SIZE,
	            "Regular integers need to be %d bytes (%d-bits),"
		    " they appear to be %d bytes.\n",
		    INT_SIZE, INT_SIZE*8, sizeof(int));
	asfRequire( sizeof(long long) == LL_INT_SIZE,
	            "Long long integers need to be %d bytes (%d-bits),"
		    " they appear to be %d bytes.\n",
		    LL_INT_SIZE, LL_INT_SIZE*8, sizeof(long long));
	asfRequire( sizeof(long long) == FLOAT_SIZE,
	            "Floats need to be %d bytes (%d-bits),"
		    " they appear to be %d bytes.\n",
		    FLOAT_SIZE, FLOAT_SIZE*8, sizeof(long long));
	asfRequire( sizeof(long long) == DOUBLE_SIZE,
	            "Doubles need to be %d bytes (%d-bits),"
		    " they appear to be %d bytes.\n",
		    DOUBLE_SIZE, DOUBLE_SIZE*8, sizeof(long long));
*/
	// Fetch our required arguments
	wordsize = atoi(argv[1]);
	if (  ! (wordsize==16 || wordsize==32 || wordsize==64) ) {
		asfPrintError("Wordsize must be 16, 32, or 64 bits, you gave "
		              "%d... Exiting.\n", wordsize);
	}
	wordsize /= 8;  // change wordsize from bits to bytes
	in_fname = (char*)CALLOC(strlen(argv[2])+3,sizeof(char));
	strcpy(in_fname,argv[2]);
	out_fname = (char*)CALLOC(strlen(argv[3])+3,sizeof(char));
	strcpy(out_fname,argv[3]);

	// Set the byteswap function for the proper number of bytes
	switch (wordsize) {
	  case 2: byteswap = (void(*)(unsigned char*))swap16; break;
	  case 4: byteswap = (void(*)(unsigned char*))swap32; break;
	  case 8: byteswap = (void(*)(unsigned char*))swap64; break;
	  default: asfPrintError("Unrecognized wordsize %d\n",wordsize*8);
	}

	// Open the needed files
	in_fp = FOPEN(in_fname,"rb");
	out_fp = FOPEN(out_fname,"wb");

	// Prepare for the byteswapping loop
	bytesread = byteswritten = ret = 0;
	nitems = MEGABYTE / wordsize;
	buf = CALLOC(MEGABYTE,sizeof(char));
	done = FALSE;

	// Actual byteswapping routine
	asfPrintStatus("Swapping bytes (each '.' represents one megabyte)\n");
	while (!done) {
		int ii;
		if (nitems != (ret=fread(buf, wordsize, nitems, in_fp))) {
			if (feof(in_fp)) {
				done=TRUE;
			}
		}
		bytesread += ret*wordsize;
		for (ii=0; ii<nitems; ii++) {
			byteswap((unsigned char *)(buf+ii*wordsize));
		}
		ret = fwrite(buf, wordsize, ret, out_fp);
		byteswritten += ret*wordsize;
		asfPrintStatus(".");
	}

	// Make sure things look right before quitting
	stat(in_fname, &stat_buf);
	asfRequire((long long)bytesread==(long long)stat_buf.st_size,
	           "(%lld==%lld)\n"
		   "Problem likely occurred during file reading.\n",
		   (long long)bytesread, (long long)stat_buf.st_size);
	asfRequire((long long)bytesread==(long long)byteswritten,
	           "(%lld==%lld)\n"
	           "Problem likely occurred during file writing.\n",
		   (long long)bytesread, (long long)byteswritten);
	
	asfPrintStatus("\n"
	               "  Successfully wrote file '%s'\n"
	               "  in reverse endian order than '%s'.\n",
	               out_fname, in_fname);

	// Yay, success!
	exit(EXIT_SUCCESS);
}
Exemple #5
0
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);
}