static int asf_mosaic_utm(char **files, char *outfile, int zone,
double lat_lo, double lat_hi,
double lon_lo, double lon_hi,
double background_val)
{
project_parameters_t pp;
projection_type_t projection_type = UNIVERSAL_TRANSVERSE_MERCATOR;
pp.utm.zone = zone;
// force calculation of these values
pp.utm.lon0 = MAGIC_UNSET_DOUBLE;
pp.utm.lat0 = MAGIC_UNSET_DOUBLE;
int force = TRUE;
resample_method_t resample = RESAMPLE_BILINEAR;
double height = 0;
datum_type_t datum = WGS84_DATUM;
spheroid_type_t spheroid = WGS84_SPHEROID;
double ps = -1;
char overlap[25]="OVERLAY";
return asf_mosaic(&pp, projection_type, force, resample, height,
datum, spheroid, ps, TRUE, 0, files, outfile, background_val,
lat_lo, lat_hi, lon_lo, lon_hi, overlap, FALSE);
}
int main(int argc, char *argv[])
{
handle_common_asf_args(&argc, &argv, ASF_NAME_STRING);
if (argc>1 && (strcmp(argv[1], "-help")==0 || strcmp(argv[1],"--help")==0))
help();
if (argc<3) usage();
projection_type_t projection_type;
datum_type_t datum;
spheroid_type_t spheroid;
double pixel_size, average_height, background_val;
resample_method_t resample_method;
int force_flag;
char band_id[256]="";
project_parameters_t *pp
= get_geocode_options (&argc, &argv, &projection_type, &average_height,
&pixel_size, &datum, &spheroid, &resample_method,
&force_flag, band_id);
if (!pp)
usage();
extract_double_options(&argc, &argv, &background_val, "--background",
"-background", NULL);
if (ISNAN(background_val)) background_val = DEFAULT_NO_DATA_VALUE;
char *outfile = argv[1];
int i, n_inputs = argc - 2;
asfSplashScreen(argc, argv);
asfPrintStatus("Projection: ");
switch (projection_type)
{
case UNIVERSAL_TRANSVERSE_MERCATOR:
asfPrintStatus("Universal Transverse Mercator\n");
break;
case POLAR_STEREOGRAPHIC:
asfPrintStatus("Polar Stereographic\n");
break;
case ALBERS_EQUAL_AREA:
asfPrintStatus("Albers Conical Equal Area\n");
break;
case LAMBERT_AZIMUTHAL_EQUAL_AREA:
asfPrintStatus("Lambert Azimuthal Equal Area\n");
break;
case LAMBERT_CONFORMAL_CONIC:
asfPrintStatus("Lambert Conformal Conic\n");
break;
case EQUI_RECTANGULAR:
asfPrintStatus("Equirectangular\n");
break;
default:
break;
}
asfPrintStatus("Output file: %s\n", outfile);
//char **infiles = &argv[2];
//asfPrintStatus("Input files:\n");
//for (i = 0; i < n_inputs; ++i)
// asfPrintStatus(" %d: %s\n", i+1, infiles[i]);
// form array for asf_mosaic
char **files = MALLOC(sizeof(char*)*(n_inputs+1));
for (i = 0; i < n_inputs; ++i) {
int n = argc-i-1;
files[i] = MALLOC(sizeof(char)*(strlen(argv[n])+2));
//printf("File #%d: %s\n", i+1, argv[n]);
strcpy(files[i], argv[n]);
}
files[n_inputs] = NULL;
char *outfile_full = appendExt(outfile, ".img");
double lat_min = -999, lon_min = -999;
double lat_max = 999, lon_max = 999;
int multiband = 1;
int band_num = 0;
// FIXME: Overlap should be an option. Hardwired for now.
char overlap[25]="OVERLAY";
asf_mosaic(pp, projection_type, force_flag, resample_method,
average_height, datum, spheroid, pixel_size, multiband,
band_num, files, outfile, background_val, lat_min, lat_max,
lon_min, lon_max, overlap, FALSE);
free(outfile_full);
for (i=0; i<n_inputs; ++i)
FREE(files[i]);
FREE(files);
asfPrintStatus("Done.\n");
return 0;
}
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);
}
