uavsar_polsar *
read_uavsar_polsar_params(const char *dataFile, uavsar_type_t type)
{
uavsar_polsar *params = (uavsar_polsar *) MALLOC(sizeof(uavsar_polsar));
// Determine ID
char *dirName = (char *) MALLOC(sizeof(char) * 1024);
char *fileName = (char *) MALLOC(sizeof(char) * 1024);
split_dir_and_file(dataFile, dirName, fileName);
sprintf(params->id, "%s", stripExt(fileName));
// Read annotation file
char line[MAX_LINE], key[MAX_LINE], value[MAX_LINE];
FILE *fp = FOPEN(dataFile, "r");
while (fgets(line, MAX_LINE, fp)) {
if(!parse_annotation_line(line, key, value)) {
asfPrintWarning("Unable to parse line in annotation file: %s", line);
continue;
}
if (!strcmp(key, ""))
continue;
if (!strcmp(key, "Site Description"))
strcpy(params->site, value);
if (!strcmp(key, "Acquisition Mode"))
strcpy(params->acquisition_mode, value);
if (type == POLSAR_SLC) {
params->type = POLSAR_SLC;
if (!strcmp(key, "slc_mag.set_rows"))
params->row_count = atoi(value);
else if (!strcmp(key, "slc_mag.set_cols"))
params->column_count = atoi(value);
else if (!strcmp(key, "slc_mag.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "slc_mag.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "slc_mag.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "slc_mag.row_mult"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "slc_mag.col_mult"))
params->range_pixel_spacing = atof(value);
else if (!strcmp(key, "slc_mag.val_size"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "slc_mag.val_frmt"))
strcpy(params->value_format, value);
params->range_look_count = 1;
params->azimuth_look_count = 1;
if (!strcmp(key, "SLC Data Units"))
strcpy(params->data_units, value);
}
else if (type == POLSAR_MLC) {
params->type = POLSAR_MLC;
if (!strcmp(key, "mlc_pwr.set_rows"))
params->row_count = atoi(value);
else if (!strcmp(key, "mlc_pwr.set_cols"))
params->column_count = atoi(value);
else if (!strcmp(key, "mlc_pwr.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "mlc_pwr.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "mlc_pwr.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "mlc_pwr.row_mult"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "mlc_pwr.col_mult"))
params->range_pixel_spacing = atof(value);
else if (!strcmp(key, "mlc_pwr.val_size"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "mlc_pwr.val_frmt"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Number of Range Looks in MLC"))
params->range_look_count = atoi(value);
else if (!strcmp(key, "Number of Azimuth Looks in MLC"))
params->azimuth_look_count = atoi(value);
else if (!strcmp(key, "MLC Data Units"))
strcpy(params->data_units, value);
params->range_look_count = 1;
params->azimuth_look_count = 1;
}
else if (type == POLSAR_DAT) {
params->type = POLSAR_DAT;
if (!strcmp(key, "dat.set_rows"))
params->row_count = atoi(value);
else if (!strcmp(key, "dat.set_cols"))
params->column_count = atoi(value);
else if (!strcmp(key, "dat.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "dat.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "dat.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "dat.row_mult"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "dat.col_mult"))
params->range_pixel_spacing = atof(value);
else if (!strcmp(key, "dat.val_size"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "dat.val_frmt"))
strcpy(params->value_format, value);
params->range_look_count = 1;
params->azimuth_look_count = 1;
strcpy(params->data_units, MAGIC_UNSET_STRING);
}
else if (type == POLSAR_GRD) {
params->type = POLSAR_GRD;
if (!strcmp(key, "grd_pwr.set_rows"))
params->row_count = atoi(value);
else if (!strcmp(key, "grd_pwr.set_cols"))
params->column_count = atoi(value);
else if (!strcmp(key, "grd_pwr.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "grd_pwr.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "grd_pwr.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "grd_pwr.row_mult"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "grd_pwr.col_mult"))
params->range_pixel_spacing = atof(value);
else if (!strcmp(key, "grd_pwr.val_size"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "grd_pwr.val_frmt"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Number of Range Looks in MLC"))
params->range_look_count = atoi(value);
else if (!strcmp(key, "Number of Azimuth Looks in MLC"))
params->azimuth_look_count = atoi(value);
else if (!strcmp(key, "GRD Data Units"))
strcpy(params->data_units, value);
}
else if (type == POLSAR_HGT) {
params->type = POLSAR_HGT;
if (!strcmp(key, "hgt.set_rows"))
params->row_count = atoi(value);
else if (!strcmp(key, "hgt.set_cols"))
params->column_count = atoi(value);
else if (!strcmp(key, "hgt.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "hgt.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "hgt.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "hgt.row_mult"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "hgt.col_mult"))
params->range_pixel_spacing = atof(value);
else if (!strcmp(key, "hgt.val_size"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "hgt.val_frmt"))
strcpy(params->value_format, value);
params->range_look_count = 1;
params->azimuth_look_count = 1;
if (!strcmp(key, "HGT Data Units"))
strcpy(params->data_units, value);
}
if (!strcmp(key, "set_hddr"))
params->header_bytes = atoi(value);
else if (!strcmp(key, "set_tail"))
params->tail_bytes = atoi(value);
else if (!strcmp(key, "set_plat"))
params->lat_peg_point = atof(value);
else if (!strcmp(key, "set_plon"))
params->lon_peg_point = atof(value);
else if (!strcmp(key, "set_phdg"))
params->head_peg_point = atof(value);
else if (!strcmp(key, "val_endi"))
strcpy(params->endianess, value);
else if (!strcmp(key, "val_mult"))
params->data_scale = atof(value);
else if (!strcmp(key, "val_addr"))
params->data_shift = atof(value);
else if (!strcmp(key, "val_minv"))
params->min_value = atof(value);
else if (!strcmp(key, "val_maxv"))
params->max_value = atof(value);
else if (!strcmp(key, "Center Wavelength"))
params->wavelength = atof(value);
else if (!strcmp(key, "Ellipsoid Semi-major Axis"))
params->semi_major = atof(value);
else if (!strcmp(key, "Ellipsoid Eccentricity Squared"))
params->eccentricity = atof(value);
else if (!strcmp(key, "Look Direction"))
strcpy(params->look_direction, value);
else if (!strcmp(key, "Range Spacing per Bin"))
params->range_spacing = atof(value);
else if (!strcmp(key, "Azimuth Spacing"))
params->azimuth_spacing = atof(value);
else if (!strcmp(key, "Image Starting Range"))
params->slant_range_first_pixel = atof(value);
else if (!strcmp(key, "Global Average Yaw"))
params->yaw = atof(value);
else if (!strcmp(key, "Global Average Pitch"))
params->pitch = atof(value);
else if (!strcmp(key, "Global Average Roll"))
params->roll = atof(value);
else if (!strcmp(key, "Global Average ESA"))
params->steering_angle = atof(value);
else if (!strcmp(key, "Global Average Altitude"))
params->altitude = atof(value);
else if (!strcmp(key, "Average GPS Altitude"))
params->altitude = atof(value);
else if (!strcmp(key, "Global Average Terrain Height"))
params->terrain_height = atof(value);
else if (!strcmp(key, "Global Average Squint Angle"))
params->squint_angle = atof(value);
else if (!strcmp(key, "Pulse Length"))
params->pulse_length = atof(value);
else if (!strcmp(key, "Bandwidth"))
params->bandwidth = atof(value);
else if (!strcmp(key, "Approximate Upper Left Latitude"))
params->lat_upper_left = atof(value);
else if (!strcmp(key, "Approximate Upper Left Longitude"))
params->lon_upper_left = atof(value);
else if (!strcmp(key, "Approximate Upper Right Latitude"))
params->lat_upper_right = atof(value);
else if (!strcmp(key, "Approximate Upper Right Longitude"))
params->lon_upper_right = atof(value);
else if (!strcmp(key, "Approximate Lower Left Latitude"))
params->lat_lower_left = atof(value);
else if (!strcmp(key, "Approximate Lower Left Longitude"))
params->lon_lower_left = atof(value);
else if (!strcmp(key, "Approximate Lower Right Latitude"))
params->lat_lower_right = atof(value);
else if (!strcmp(key, "Approximate Lower Right Longitude"))
params->lon_lower_right = atof(value);
else if (!strcmp(key, "Date of Acquisition"))
strcpy(params->acquisition_date, value);
else if (!strcmp(key, "Processor Version Number"))
strcpy(params->processor, value);
}
FCLOSE(fp);
return params;
}
static void
process_item(GtkTreeIter *iter, Settings *user_settings, gboolean skip_done,
int is_first)
{
gchar *in_file, *out_full, *ancillary_file, *meta_file,
*status, *polsarpro_aux_info, *interferogram_file,
*coherence_file, *slave_metadata_file, *baseline_file,
*uavsar_type;
int pid, isPolSARPro = FALSE;
pid = getpid();
gtk_tree_model_get(GTK_TREE_MODEL(list_store), iter,
COL_INPUT_FILE, &in_file,
COL_ANCILLARY_FILE, &ancillary_file,
COL_METADATA_FILE, &meta_file,
COL_OUTPUT_FILE, &out_full,
COL_STATUS, &status,
COL_POLSARPRO_INFO, &polsarpro_aux_info,
COL_INTERFEROGRAM, &interferogram_file,
COL_COHERENCE, &coherence_file,
COL_SLAVE_METADATA, &slave_metadata_file,
COL_BASELINE, &baseline_file,
COL_UAVSAR_TYPE, &uavsar_type,
-1);
int image_data_type = extract_image_data_type(polsarpro_aux_info);
if (image_data_type >= 0 && image_data_type < 3)
isPolSARPro = TRUE;
if (strcmp(status, "Done") != 0 || !skip_done)
{
//char *in_basename = stripExt(in_file);
char *out_basename = stripExt(out_full);
char *out_nameonly = get_basename(out_full);
char *output_dir = getPath(out_full);
char *config_file, *cmd_output, *tmp_dir, *intermediates_file;
gchar *err_string;
/* Ensure we have access to the output directory */
if (!have_access_to_dir(output_dir, &err_string))
{
/* We don't -- issue a message in the "Status" column. */
gtk_list_store_set(list_store, iter, COL_STATUS, err_string, -1);
g_free(err_string);
//free(in_basename);
free(out_basename);
free(output_dir);
return;
}
tmp_dir = MALLOC(sizeof(char)*
(strlen(output_dir)+strlen(out_nameonly)+32));
if (strlen(output_dir) > 0) {
sprintf(tmp_dir, "%s%c%s-%s", output_dir, DIR_SEPARATOR,
out_nameonly, time_stamp_dir());
}
else {
sprintf(tmp_dir, "%s-%s", out_nameonly, time_stamp_dir());
}
create_clean_dir(tmp_dir);
set_asf_tmp_dir(tmp_dir);
config_file =
settings_to_config_file(user_settings,
in_file, ancillary_file, meta_file,
out_full, output_dir,
tmp_dir, polsarpro_aux_info,
interferogram_file, coherence_file,
slave_metadata_file, baseline_file, uavsar_type);
if (!config_file) {
err_string = "Error creating configuration file.";
gtk_list_store_set(list_store, iter, COL_STATUS, err_string, -1);
free(out_basename);
free(output_dir);
free(tmp_dir);
return;
}
cmd_output = do_convert(pid, iter, config_file, TRUE,
user_settings->keep_files, &intermediates_file);
err_string = check_for_error(cmd_output);
if (err_string) {
// unsuccessful
gtk_list_store_set(list_store, iter, COL_STATUS, err_string,
COL_LOG, cmd_output, -1);
FREE(err_string);
}
else {
// successful -- move to "completed" list
GtkTreeIter completed_iter;
move_to_completed_files_list(iter, &completed_iter, cmd_output,
intermediates_file);
set_thumbnail(&completed_iter, tmp_dir, out_full, isPolSARPro);
input_data_formats_changed();
refresh_file_names();
}
// for subsequent runs, save the imported dem & mask
settings_update_dem(user_settings, output_dir);
settings_update_mask(user_settings, output_dir);
free(config_file);
free(out_basename);
free(output_dir);
free(out_nameonly);
free(intermediates_file);
g_free(cmd_output);
if (!user_settings->keep_files)
remove_dir(tmp_dir);
free(tmp_dir);
}
g_free(status);
g_free(out_full);
g_free(ancillary_file);
g_free(meta_file);
g_free(in_file);
g_free(polsarpro_aux_info);
}
uavsar_insar *
read_uavsar_insar_params(const char *dataFile, uavsar_type_t type)
{
uavsar_insar *params = (uavsar_insar *) MALLOC(sizeof(uavsar_insar));
char time1[50]="", time2[50]="";
// Determine ID
char *dirName = (char *) MALLOC(sizeof(char) * 1024);
char *fileName = (char *) MALLOC(sizeof(char) * 1024);
split_dir_and_file(dataFile, dirName, fileName);
sprintf(params->id, "%s", stripExt(fileName));
// Read annotation file
char line[MAX_LINE], key[MAX_LINE], value[MAX_LINE];
FILE *fp = FOPEN(dataFile, "r");
while (fgets(line, MAX_LINE, fp)) {
if(!parse_annotation_line(line, key, value)) {
asfPrintWarning("Unable to parse line in annotation file: %s", line);
continue;
}
if(!strcmp(key, ""))
continue;
if (!strcmp(key, "Site Description"))
strcpy(params->site, value);
if (!strcmp(key, "Processing Mode"))
strcpy(params->processing_mode, value);
if (!strcmp(key, "Polarization"))
strcpy(params->polarization, value);
if (!strcmp(key, "Number of Looks in Range"))
params->range_look_count = atoi(value);
if (!strcmp(key, "Number of Looks in Azimuth"))
params->azimuth_look_count = atoi(value);
if (type == INSAR_INT) {
params->type = INSAR_INT;
if (!strcmp(key, "Interferogram Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Interferogram Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Interferogram Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_UNW) {
params->type = INSAR_UNW;
if (!strcmp(key, "Unwrapped Phase Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Unwrapped Phase Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Unwrapped Phase Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_COR) {
params->type = INSAR_COR;
if (!strcmp(key, "Correlation Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Correlation Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Correlation Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_AMP) {
params->type = INSAR_AMP;
if (!strcmp(key, "Amplitude Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Amplitude Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Amplitude Units"))
strcpy(params->data_units, value);
}
if (type >= INSAR_AMP && type <= INSAR_COR) {
if (!strcmp(key, "Slant Range Data Azimuth Lines"))
params->row_count = atoi(value);
else if (!strcmp(key, "Slant Range Data Range Samples"))
params->column_count = atoi(value);
else if (!strcmp(key, "slt.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "slt.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "slt.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "Slant Range Data at Near Range")) {
params->slant_range_first_pixel = atof(value);
params->slant_range_first_pixel /= 1000.0;
}
else if (!strcmp(key, "Slant Range Data Azimuth Spacing"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "Slant Range Data Range Spacing"))
params->range_pixel_spacing = atof(value);
}
else if (type >= INSAR_AMP_GRD && type <= INSAR_HGT_GRD) {
if (!strcmp(key, "Ground Range Data Latitude Lines"))
params->row_count = atoi(value);
else if (!strcmp(key, "Ground Range Data Longitude Samples"))
params->column_count = atoi(value);
else if (!strcmp(key, "grd.set_proj"))
strcpy(params->projection, value);
else if (!strcmp(key, "grd.row_addr"))
params->along_track_offset = atof(value);
else if (!strcmp(key, "grd.col_addr"))
params->cross_track_offset = atof(value);
else if (!strcmp(key, "Ground Range Data Latitude Spacing"))
params->azimuth_pixel_spacing = atof(value);
else if (!strcmp(key, "Ground Range Data Longitude Spacing"))
params->range_pixel_spacing = atof(value);
}
if (type == INSAR_INT_GRD) {
params->type = INSAR_INT_GRD;
if (!strcmp(key, "Interferogram Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Interferogram Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Interferogram Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_UNW_GRD) {
params->type = INSAR_UNW_GRD;
if (!strcmp(key, "Unwrapped Phase Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Unwrapped Phase Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Unwrapped Phase Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_COR_GRD) {
params->type = INSAR_COR_GRD;
if (!strcmp(key, "Correlation Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Correlation Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Correlation Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_AMP_GRD) {
params->type = INSAR_AMP_GRD;
if (!strcmp(key, "Amplitude Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "Amplitude Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "Amplitude Units"))
strcpy(params->data_units, value);
}
else if (type == INSAR_HGT_GRD) {
params->type = INSAR_HGT_GRD;
if (!strcmp(key, "DEM Bytes Per Pixel"))
params->bytes_per_pixel = atoi(value);
else if (!strcmp(key, "DEM Pixel Format"))
strcpy(params->value_format, value);
else if (!strcmp(key, "DEM Units"))
strcpy(params->data_units, value);
}
if (!strcmp(key, "set_hddr"))
params->header_bytes = atoi(value);
else if (!strcmp(key, "set_tail"))
params->tail_bytes = atoi(value);
else if (!strcmp(key, "set_plat"))
params->lat_peg_point = atof(value);
else if (!strcmp(key, "set_plon"))
params->lon_peg_point = atof(value);
else if (!strcmp(key, "set_phdg"))
params->head_peg_point = atof(value);
else if (!strcmp(key, "val_endi"))
strcpy(params->endianess, value);
else if (!strcmp(key, "val_mult"))
params->data_scale = atof(value);
else if (!strcmp(key, "val_addr"))
params->data_shift = atof(value);
else if (!strcmp(key, "val_minv"))
params->min_value = atof(value);
else if (!strcmp(key, "val_maxv"))
params->max_value = atof(value);
else if (!strcmp(key, "Center Wavelength"))
params->wavelength = atof(value);
else if (!strcmp(key, "Ellipsoid Semi-major Axis"))
params->semi_major = atof(value);
else if (!strcmp(key, "Ellipsoid Eccentricity Squared"))
params->eccentricity = atof(value);
else if (!strcmp(key, "Look Direction"))
strcpy(params->look_direction, value);
else if (!strcmp(key, "Range Spacing per Bin"))
params->range_spacing = atof(value);
else if (!strcmp(key, "Azimuth Spacing"))
params->azimuth_spacing = atof(value);
else if (!strcmp(key, "Image Starting Range"))
params->slant_range_first_pixel = atof(value);
else if (!strcmp(key, "Global Average Yaw"))
params->yaw = atof(value);
else if (!strcmp(key, "Global Average Pitch"))
params->pitch = atof(value);
else if (!strcmp(key, "Global Average Roll"))
params->roll = atof(value);
else if (!strcmp(key, "Global Average ESA"))
params->steering_angle = atof(value);
else if (!strcmp(key, "Global Average Altitude"))
params->altitude = atof(value);
else if (!strcmp(key, "Average GPS Altitude"))
params->altitude = atof(value);
else if (!strcmp(key, "Global Average Terrain Height"))
params->terrain_height = atof(value);
else if (!strcmp(key, "Global Average Squint Angle"))
params->squint_angle = atof(value);
else if (!strcmp(key, "Pulse Length"))
params->pulse_length = atof(value);
else if (!strcmp(key, "Bandwidth"))
params->bandwidth = atof(value);
else if (!strcmp(key, "Approximate Upper Left Latitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lat_upper_left = MAGIC_UNSET_DOUBLE;
else
params->lat_upper_left = atof(value);
}
else if (!strcmp(key, "Approximate Upper Left Longitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lon_upper_left = MAGIC_UNSET_DOUBLE;
else
params->lon_upper_left = atof(value);
}
else if (!strcmp(key, "Approximate Upper Right Latitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lat_upper_right = MAGIC_UNSET_DOUBLE;
else
params->lat_upper_right = atof(value);
}
else if (!strcmp(key, "Approximate Upper Right Longitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lon_upper_right = MAGIC_UNSET_DOUBLE;
else
params->lon_upper_right = atof(value);
}
else if (!strcmp(key, "Approximate Lower Left Latitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lat_lower_left = MAGIC_UNSET_DOUBLE;
else
params->lat_lower_left = atof(value);
}
else if (!strcmp(key, "Approximate Lower Left Longitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lon_lower_left = MAGIC_UNSET_DOUBLE;
else
params->lon_lower_left = atof(value);
}
else if (!strcmp(key, "Approximate Lower Right Latitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lat_lower_right = MAGIC_UNSET_DOUBLE;
else
params->lat_lower_right = atof(value);
}
else if (!strcmp(key, "Approximate Lower Right Longitude")) {
if (strcmp_case(value, "N/A") == 0)
params->lon_lower_right = MAGIC_UNSET_DOUBLE;
else
params->lon_lower_right = atof(value);
}
else if (!strcmp(key, "Time of Acquisition for Pass 1"))
strcpy(time1, value);
else if (!strcmp(key, "Time of Acquisition for Pass 2"))
strcpy(time2, value);
else if (!strcmp(key, "Processor Version Number"))
strcpy(params->processor, value);
}
FCLOSE(fp);
sprintf(params->acquisition_date, "%s, %s", time1, time2);
return params;
}
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;
}
