int main(int argc,char *argv[])
{
char infile1[256], infile2[256], infile3[256]; // Input file name
char outfile[256]; // Output file name
char tmpPath[1024];
browse_type_t mode = NOTYPE;
int i,j;
int sample_count;
double scale;
extern int currArg;
strcpy(tmpPath, "");
// Parse command line
if ((argc-currArg)<1) {
printf("Insufficient arguments.\n");
usage("");
}
while (currArg < (argc-2)) {
char *key = argv[currArg++];
if (strmatches(key, "-sentinel", "--sentinel", NULL)) {
CHECK_ARG(1);
scale = atof(GET_ARG(1));
mode = SENTINEL_DUAL;
}
else if (strmatches(key, "-tmpDir", "--tmpDir", NULL)) {
CHECK_ARG(1);
strcpy(tmpPath, GET_ARG(1));
}
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 {
--currArg;
break;
}
}
if ((argc-currArg) < 2) {
printf("Insufficient arguments.\n");
usage(argv[0]);
}
if (mode == NOTYPE && argc == 4)
mode = PALSAR_FBD;
else if (mode == NOTYPE && argc == 5)
mode = PALSAR_PLR;
if (!quietflag)
asfSplashScreen(argc, argv);
if (mode == PALSAR_FBD) {
asfPrintStatus("Creating colorized browse image from PALSAR FBD data\n");
create_name(infile1,argv[1],".img");
create_name(infile2,argv[2],".img");
create_name(outfile,argv[3],".img");
meta_parameters *meta1 = meta_read(infile1);
meta_parameters *meta2 = meta_read(infile2);
if (meta1->general->line_count != meta2->general->line_count ||
meta1->general->sample_count != meta2->general->sample_count)
{
asfPrintError("Images must be the same size!!!\n");
exit(1);
}
strcpy(meta1->general->bands,"HH");
strcpy(meta2->general->bands,"HV");
int pixel_count = meta1->general->line_count*meta1->general->sample_count;
float *buf1 = MALLOC(pixel_count * sizeof(float));
float *buf2 = MALLOC(pixel_count * sizeof(float));
float *buf3 = MALLOC(pixel_count * sizeof(float));
unsigned char *cbuf1, *cbuf2, *cbuf3;
FILE *fp1 = FOPEN(infile1, "r");
FILE *fp2 = FOPEN(infile2, "r");
FILE *ofp = FOPEN(outfile, "w");
char ofile1[256];
char ofile2[256];
strcpy(ofile1,argv[1]);
strcat(ofile1,"_DB.img");
strcpy(ofile2,argv[2]);
strcat(ofile2,"_DB.img");
printf("Creating output DB files %s and %s\n",ofile1,ofile2);
FILE *ofp1 = FOPEN(ofile1, "w");
FILE *ofp2 = FOPEN(ofile2, "w");
get_float_lines(fp1,meta1,0,meta1->general->line_count, buf1);
get_float_lines(fp2,meta2,0,meta2->general->line_count, buf2);
/* Convert data from sigma0 to dB */
sample_count = 0;
for (i=0; i<meta1->general->line_count; ++i) {
for (j=0; j<meta1->general->sample_count; ++j) {
if (meta_is_valid_double(buf1[sample_count])) {
if (buf1[sample_count] != 0)
buf1[sample_count] = 10.0 * log10f(buf1[sample_count]);
if (buf2[sample_count] != 0)
buf2[sample_count] = 10.0 * log10f(buf2[sample_count]);
}
sample_count++;
}
}
put_float_lines(ofp1, meta1, 0,meta1->general->line_count,buf1);
put_float_lines(ofp2, meta2, 0,meta1->general->line_count,buf2);
meta_write(meta1, ofile1);
meta_write(meta2, ofile2);
fclose(fp1);
fclose(fp2);
fclose(ofp1);
fclose(ofp2);
/* Scale the data to a byte range using given min/max values */
cbuf1 = my_floats_to_bytes(buf1,(long long) pixel_count, 0.0,MINMAX,-30.0,-1.0);
cbuf2 = my_floats_to_bytes(buf2,(long long) pixel_count, 0.0,MINMAX,-30.0,-10.0);
/*
cbuf1 = my_floats_to_bytes(buf1,(long long) pixel_count, 0.0,MINMAX,-31.0,7.1);
cbuf2 = my_floats_to_bytes(buf2,(long long) pixel_count, 0.0,MINMAX,-31.0,7.1);
*/
strcpy(ofile1,argv[1]);
strcat(ofile1,"_byte.img");
strcpy(ofile2,argv[2]);
strcat(ofile2,"_byte.img");
printf("Creating output byte files %s and %s\n",ofile1,ofile2);
ofp1 = FOPEN(ofile1, "w");
ofp2 = FOPEN(ofile2, "w");
meta1->general->data_type=REAL32;
meta2->general->data_type=REAL32;
sample_count = 0;
for (i=0; i<meta1->general->line_count; ++i) {
for (j=0; j<meta1->general->sample_count; ++j) {
buf1[sample_count] = (float) cbuf1[sample_count];
buf2[sample_count] = (float) cbuf2[sample_count];
sample_count++;
}
}
put_float_lines(ofp1,meta1,0,meta1->general->line_count,buf1);
put_float_lines(ofp2,meta2,0,meta2->general->line_count,buf2);
meta_write(meta1, ofile1);
meta_write(meta2, ofile2);
fclose(ofp1);
fclose(ofp2);
/* Create the third band for the color image */
sample_count = 0;
for (i=0; i<meta1->general->line_count; ++i) {
for (j=0; j<meta1->general->sample_count; ++j) {
if (buf2[sample_count] != 0) {
/*
buf3[sample_count] = (buf1[sample_count] / buf2[sample_count]);
*/
buf3[sample_count] = (buf1[sample_count] - buf2[sample_count]);
if (buf3[sample_count] < 1) buf3[sample_count] = 1;
else if (buf3[sample_count] > 255) buf3[sample_count] = 255;
} else buf3[sample_count] = 0;
sample_count++;
}
}
cbuf3 = my_floats_to_bytes(buf3,(long long) pixel_count, 0.0,SIGMA ,-25.0,-10.0);
sample_count = 0;
for (i=0; i<meta1->general->line_count; ++i) {
for (j=0; j<meta1->general->sample_count; ++j) {
buf3[sample_count] = (float) cbuf3[sample_count];
sample_count++;
}
}
/* Finally, create the 3 banded image we were looking for */
strcpy(meta1->general->bands,"HH,HV,DIV");
meta1->general->band_count=3;
put_band_float_lines(ofp,meta1,0,0,meta1->general->line_count,buf1);
put_band_float_lines(ofp,meta1,1,0,meta1->general->line_count,buf2);
put_band_float_lines(ofp,meta1,2,0,meta1->general->line_count,buf3);
meta_write(meta1,outfile);
}
else if (mode == PALSAR_PLR) {
/* Mode 1 - Create Color Browse from 3 bands using 3sigma stretch */
asfPrintStatus("Creating colorized browse image from PALSAR PLR data\n");
create_name(infile1,argv[1],".img");
create_name(infile2,argv[2],".img");
create_name(infile3,argv[3],".img");
create_name(outfile,argv[4],".img");
meta_parameters *meta1 = meta_read(infile1);
meta_parameters *meta2 = meta_read(infile2);
meta_parameters *meta3 = meta_read(infile3);
if (meta1->general->line_count != meta2->general->line_count ||
meta1->general->sample_count != meta2->general->sample_count)
{
asfPrintError("Images must be the same size!!!\n");
exit(1);
}
if (meta3->general->line_count != meta2->general->line_count ||
meta3->general->sample_count != meta2->general->sample_count)
{
asfPrintError("Images must be the same size!!!\n");
exit(1);
}
int pixel_count = meta1->general->line_count*meta1->general->sample_count;
float *buf1 = MALLOC(pixel_count * sizeof(float));
float *buf2 = MALLOC(pixel_count * sizeof(float));
float *buf3 = MALLOC(pixel_count * sizeof(float));
float *buf4 = MALLOC(pixel_count * sizeof(float));
unsigned char *cbuf1, *cbuf2, *cbuf3, *cbuf4;
FILE *fp1 = FOPEN(infile1, "r");
FILE *fp2 = FOPEN(infile2, "r");
FILE *fp3 = FOPEN(infile3, "r");
FILE *ofp = FOPEN(outfile, "w");
get_float_lines(fp1,meta1,0,meta1->general->line_count, buf1);
get_float_lines(fp2,meta2,0,meta2->general->line_count, buf2);
get_float_lines(fp3,meta3,0,meta3->general->line_count, buf3);
/* Convert data from sigma0 to dB */
sample_count = 0;
for (i=0; i<meta1->general->line_count; ++i) {
for (j=0; j<meta1->general->sample_count; ++j) {
if (meta_is_valid_double(buf1[sample_count])) {
if (buf1[sample_count] != 0)
buf1[sample_count] = 10.0 * log10f(buf1[sample_count]);
if (buf2[sample_count] != 0)
buf2[sample_count] = 10.0 * log10f(buf2[sample_count]);
if (buf3[sample_count] != 0)
buf3[sample_count] = 10.0 * log10f(buf3[sample_count]);
}
sample_count++;
}
}
/* Scale the data to a byte range using 3-sigma stretch values */
cbuf1 = my_floats_to_bytes(buf1,(long long) pixel_count, 0.0,SIGMA3,-30.0,-1.0);
cbuf2 = my_floats_to_bytes(buf2,(long long) pixel_count, 0.0,SIGMA3,-30.0,-10.0);
cbuf3 = my_floats_to_bytes(buf3,(long long) pixel_count, 0.0,SIGMA3,-30.0,-10.0);
meta1->general->data_type=REAL32;
//meta2->general->data_type=ASF_BYTE;
//meta3->general->data_type=ASF_BYTE;
sample_count = 0;
for (i=0; i<meta1->general->line_count; ++i) {
for (j=0; j<meta1->general->sample_count; ++j) {
buf1[sample_count] = (float) cbuf1[sample_count];
buf2[sample_count] = (float) cbuf2[sample_count];
buf3[sample_count] = (float) cbuf3[sample_count];
sample_count++;
}
}
/* Finally, create the 3 banded image we were looking for */
strcpy(meta1->general->bands,"HH,HV,VV");
meta1->general->band_count=3;
put_band_float_lines(ofp,meta1,0,0,meta1->general->line_count,buf1);
put_band_float_lines(ofp,meta1,1,0,meta1->general->line_count,buf2);
put_band_float_lines(ofp,meta1,2,0,meta1->general->line_count,buf3);
meta_write(meta1,outfile);
}
else if (mode == SENTINEL_DUAL) {
asfPrintStatus("Creating colorized browse image from Sentinel dual-pol "
"data\n");
if (strlen(tmpPath) > 0) {
create_name(infile1,argv[5],".img");
create_name(infile2,argv[6],".img");
create_name(outfile,argv[7],".tif");
}
else {
create_name(infile1,argv[3],".img");
create_name(infile2,argv[4],".img");
create_name(outfile,argv[5],".tif");
}
// Create temporary directory
char tmpDir[1024];
if (strlen(tmpPath) > 0)
sprintf(tmpDir, "%s%cbrowse-", tmpPath, DIR_SEPARATOR);
else
strcpy(tmpDir, "browse-");
strcat(tmpDir, time_stamp_dir());
create_clean_dir(tmpDir);
asfPrintStatus("Temp dir is: %s\n", tmpDir);
// Calculate ratio image
char tmpRatio[512], tmpRed[512], tmpGreen[512], tmpBlue[512], tmpIn[512];
char *inFiles[2];
inFiles[0] = (char *) MALLOC(sizeof(char)*255);
inFiles[1] = (char *) MALLOC(sizeof(char)*255);
strcpy(inFiles[0], infile1);
strcpy(inFiles[1], infile2);
sprintf(tmpRatio, "%s%cdiv.img", tmpDir, DIR_SEPARATOR);
raster_calc(tmpRatio, "a/b", 2, inFiles);
// Resample all three bands and scale to byte
meta_parameters *metaIn = meta_read(tmpRatio);
double scaleFactor = 1.0/(scale/metaIn->general->x_pixel_size);
meta_free(metaIn);
sprintf(tmpIn, "%s%cred.img", tmpDir, DIR_SEPARATOR);
resample(infile1, tmpIn, scaleFactor, scaleFactor);
sprintf(tmpRed, "%s%cred_byte.img", tmpDir, DIR_SEPARATOR);
floats_to_bytes_from_file(tmpIn, tmpRed, NULL, -40.0, SIGMA);
sprintf(tmpIn, "%s%cgreen.img", tmpDir, DIR_SEPARATOR);
resample(infile2, tmpIn, scaleFactor, scaleFactor);
sprintf(tmpGreen, "%s%cgreen_byte.img", tmpDir, DIR_SEPARATOR);
floats_to_bytes_from_file(tmpIn, tmpGreen, NULL, -40.0, SIGMA);
sprintf(tmpIn, "%s%cblue.img", tmpDir, DIR_SEPARATOR);
resample(tmpRatio, tmpIn, scaleFactor, scaleFactor);
sprintf(tmpBlue, "%s%cblue_byte.img", tmpDir, DIR_SEPARATOR);
floats_to_bytes_from_file(tmpIn, tmpBlue, NULL, -40.0, SIGMA);
// Layer stack the bands
char tmpBrowse[512];
sprintf(tmpBrowse, "%s%cbrowse.img", tmpDir, DIR_SEPARATOR);
FILE *fpOut = FOPEN(tmpBrowse, "w");
meta_parameters *metaOut = meta_read(tmpRed);
metaOut->general->band_count = 3;
metaIn = meta_read(tmpRed);
int line_count = metaIn->general->line_count;
int sample_count = metaIn->general->sample_count;
float *buf = (float *) MALLOC(sizeof(float)*line_count*sample_count);
FILE *fpIn = FOPEN(tmpBlue, "r");
get_float_lines(fpIn, metaIn, 0, line_count, buf);
put_band_float_lines(fpOut, metaOut, 0, 0, line_count, buf);
FCLOSE(fpIn);
fpIn = FOPEN(tmpGreen, "r");
get_float_lines(fpIn, metaIn, 0, line_count, buf);
put_band_float_lines(fpOut, metaOut, 1, 0, line_count, buf);
FCLOSE(fpIn);
fpIn = FOPEN(tmpRed, "r");
get_float_lines(fpIn, metaIn, 0, line_count, buf);
put_band_float_lines(fpOut, metaOut, 2, 0, line_count, buf);
FCLOSE(fpIn);
FCLOSE(fpOut);
FREE(buf);
strcpy(metaOut->general->bands, "red,green,blue");
meta_write(metaOut, tmpBrowse);
// Export to GeoTIFF
char *band_names[3] = { "blue", "green", "red" };
asf_export_bands(GEOTIFF, NONE, TRUE, FALSE, FALSE, FALSE, FALSE,
tmpBrowse, outfile, band_names, NULL, NULL);
// Clean up
asfPrintStatus("Removing temporary directory: %s\n", tmpDir);
remove_dir(tmpDir);
meta_free(metaIn);
meta_free(metaOut);
}
else
asfPrintError("Mode is not defined!\n");
asfPrintStatus("Done.\n");
exit(EXIT_SUCCESS);
}
int asf_export_with_lut(output_format_t format, scale_t sample_mapping,
char *lutFile, char *inFile, char *outFile)
{
return asf_export_bands(format, sample_mapping, 1, 0, 0,
lutFile, 0, inFile, outFile, NULL, NULL, NULL);
}
int asf_export(output_format_t format, scale_t sample_mapping,
char *in_base_name, char *output_name)
{
return asf_export_bands(format, sample_mapping, 0, 0, 0, NULL, 0,
in_base_name, output_name, NULL, NULL, NULL);
}
// Main program body.
int
main (int argc, char *argv[])
{
output_format_t format = 0;
meta_parameters *md;
char *in_base_name, *output_name;
char **band_names=NULL;
int rgb=0;
int true_color;
int false_color;
int num_bands_found;
int ignored[3] = {0, 0, 0};
int num_ignored = 0;
in_base_name = (char *) MALLOC(sizeof(char)*255);
output_name = (char *) MALLOC(sizeof(char)*255);
/**********************BEGIN COMMAND LINE PARSING STUFF**********************/
// Command line input goes in it's own structure.
command_line_parameters_t command_line;
strcpy (command_line.format, "");
command_line.size = NO_MAXIMUM_OUTPUT_SIZE;
strcpy (command_line.in_data_name, "");
strcpy (command_line.in_meta_name, "");
strcpy (command_line.output_name, "");
command_line.verbose = FALSE;
command_line.quiet = FALSE;
strcpy (command_line.leader_name, "");
strcpy (command_line.cal_params_file, "");
strcpy (command_line.cal_comment, "");
command_line.sample_mapping = 0;
strcpy(command_line.red_channel, "");
strcpy(command_line.green_channel, "");
strcpy(command_line.blue_channel, "");
strcpy(command_line.band, "");
strcpy(command_line.look_up_table_name, "");
int formatFlag, logFlag, quietFlag, byteFlag, rgbFlag, bandFlag, lutFlag;
int truecolorFlag, falsecolorFlag;
int needed_args = 3; //command & argument & argument
int ii;
char sample_mapping_string[25];
//Check to see which options were specified
if ( (checkForOption("--help", argc, argv) != FLAG_NOT_SET)
|| (checkForOption("-h", argc, argv) != FLAG_NOT_SET)
|| (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) {
print_help();
}
get_asf_share_dir_with_argv0(argv[0]);
handle_license_and_version_args(argc, argv, ASF_NAME_STRING);
formatFlag = checkForOption ("-format", argc, argv);
logFlag = checkForOption ("-log", argc, argv);
quietFlag = checkForOption ("-quiet", argc, argv);
byteFlag = checkForOption ("-byte", argc, argv);
rgbFlag = checkForOption ("-rgb", argc, argv);
bandFlag = checkForOption ("-band", argc, argv);
lutFlag = checkForOption ("-lut", argc, argv);
truecolorFlag = checkForOption("-truecolor", argc, argv);
falsecolorFlag = checkForOption("-falsecolor", argc, argv);
if ( formatFlag != FLAG_NOT_SET ) {
needed_args += 2; // Option & parameter.
}
if ( quietFlag != FLAG_NOT_SET ) {
needed_args += 1; // Option & parameter.
}
if ( logFlag != FLAG_NOT_SET ) {
needed_args += 2; // Option & parameter.
}
if ( byteFlag != FLAG_NOT_SET ) {
needed_args += 2; // Option & parameter.
}
if ( rgbFlag != FLAG_NOT_SET ) {
needed_args += 4; // Option & 3 parameters.
}
if ( bandFlag != FLAG_NOT_SET ) {
needed_args += 2; // Option & parameter.
}
if ( lutFlag != FLAG_NOT_SET ) {
needed_args += 2; // Option & parameter.
}
if ( truecolorFlag != FLAG_NOT_SET ) {
needed_args += 1; // Option only
}
if ( falsecolorFlag != FLAG_NOT_SET ) {
needed_args += 1; // Option only
}
if ( argc != needed_args ) {
print_usage (); // This exits with a failure.
}
// We also need to make sure the last three options are close to
// what we expect.
if ( argv[argc - 1][0] == '-' || argv[argc - 2][0] == '-' ) {
print_usage (); // This exits with a failure.
}
// Make sure any options that have parameters are followed by
// parameters (and not other options) Also make sure options'
// parameters don't bleed into required arguments.
if ( formatFlag != FLAG_NOT_SET ) {
if ( argv[formatFlag + 1][0] == '-' || formatFlag >= argc - 3 ) {
print_usage ();
}
}
if ( byteFlag != FLAG_NOT_SET ) {
if ( argv[byteFlag + 1][0] == '-' || byteFlag >= argc - 3 ) {
print_usage ();
}
}
if ( rgbFlag != FLAG_NOT_SET ) {
if (( argv[rgbFlag + 1][0] == '-' && argv[rgbFlag + 2][0] == '-' &&
argv[rgbFlag + 3][0] == '-' ) || rgbFlag >= argc - 5 ) {
print_usage ();
}
}
if ( bandFlag != FLAG_NOT_SET ) {
if ( argv[bandFlag + 1][0] == '-' || bandFlag >= argc - 3 ) {
print_usage ();
}
}
if ( lutFlag != FLAG_NOT_SET ) {
if ( argv[lutFlag + 1][0] == '-' || lutFlag >= argc - 3 ) {
print_usage ();
}
}
if ( logFlag != FLAG_NOT_SET ) {
if ( argv[logFlag + 1][0] == '-' || logFlag >= argc - 3 ) {
print_usage ();
}
}
// Make sure there are no flag incompatibilities
if ( (rgbFlag != FLAG_NOT_SET &&
(bandFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET))
||
(bandFlag != FLAG_NOT_SET &&
(rgbFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET))
||
(truecolorFlag != FLAG_NOT_SET &&
(bandFlag != FLAG_NOT_SET ||
rgbFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET))
||
(falsecolorFlag != FLAG_NOT_SET &&
(bandFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
rgbFlag != FLAG_NOT_SET))
)
{
asfPrintWarning("The following options may only be used one at a time:\n"
" %s\n %s\n %s\n %s\n %s\n %s\n",
"-rgb", "-truecolor", "-falsecolor", "-band");
print_help();
}
if ( (rgbFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET) &&
lutFlag != FLAG_NOT_SET
)
asfPrintError("Look up table option can only be used on single-band "
"images.\n");
if( logFlag != FLAG_NOT_SET ) {
strcpy(logFile, argv[logFlag+1]);
}
else {
sprintf(logFile, "tmp%i.log", (int)getpid());
}
logflag = TRUE; // Since we always log, set the old school logflag to true
fLog = FOPEN (logFile, "a");
// Set old school quiet flag (for use in our libraries)
quietflag = ( quietFlag != FLAG_NOT_SET ) ? TRUE : FALSE;
// We're good enough at this point... print the splash screen.
asfSplashScreen (argc, argv);
// Grab the input and output name
strcpy (in_base_name, argv[argc - 2]);
strcpy (output_name, argv[argc - 1]);
strcpy (command_line.output_name, output_name);
// If user added ".img", strip it.
char *ext = findExt(in_base_name);
if (ext && strcmp(ext, ".img") == 0) *ext = '\0';
// Set default output type
if( formatFlag != FLAG_NOT_SET ) {
strcpy (command_line.format, argv[formatFlag + 1]);
}
else {
// Default behavior: produce a geotiff.
strcpy (command_line.format, "geotiff");
}
// Compose input metadata name
strcpy (command_line.in_meta_name, in_base_name);
strcat (command_line.in_meta_name, ".meta");
// for some validation, need the metadata
md = meta_read (command_line.in_meta_name);
// Convert the string to upper case.
for ( ii = 0 ; ii < strlen (command_line.format) ; ++ii ) {
command_line.format[ii] = toupper (command_line.format[ii]);
}
if (strcmp (command_line.format, "PGM") == 0 &&
(rgbFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET)
)
{
asfPrintWarning("Greyscale PGM output is not compatible with color options:\n"
"(RGB, True Color, False Color, color look-up tables, etc\n)"
"...Defaulting to producing separate greyscale PGM files for available band.\n");
rgbFlag = FLAG_NOT_SET;
truecolorFlag = FLAG_NOT_SET;
falsecolorFlag = FLAG_NOT_SET;
}
// Set the default byte scaling mechanisms
if (md->optical) {
// for optical data, default sample mapping is NONE
command_line.sample_mapping = NONE;
}
// for other data, default is based on the output type
else if (strcmp (command_line.format, "TIFF") == 0 ||
strcmp (command_line.format, "TIF") == 0 ||
strcmp (command_line.format, "JPEG") == 0 ||
strcmp (command_line.format, "JPG") == 0 ||
strcmp (command_line.format, "PNG") == 0 ||
strcmp (command_line.format, "PGM") == 0 ||
strcmp (command_line.format, "PNG_ALPHA") == 0 ||
strcmp (command_line.format, "PNG_GE") == 0)
{
command_line.sample_mapping = SIGMA;
}
else if (strcmp (command_line.format, "GEOTIFF") == 0) {
command_line.sample_mapping = NONE;
}
if ( quietFlag != FLAG_NOT_SET )
command_line.quiet = TRUE;
else
command_line.quiet = FALSE;
// Set rgb combination
if ( rgbFlag != FLAG_NOT_SET ) {
int i;
for (i=0, num_ignored = 0; i<3; i++) {
ignored[i] = strncmp("IGNORE", uc(argv[rgbFlag + i + 1]), 6) == 0 ? 1 : 0;
num_ignored += ignored[i] ? 1 : 0;
}
asfRequire(num_ignored < 3,
"Cannot ignore all bands. Exported image would be blank.\n");
strcpy (command_line.red_channel, ignored[0] ? "Ignored" : argv[rgbFlag + 1]);
strcpy (command_line.green_channel, ignored[1] ? "Ignored" : argv[rgbFlag + 2]);
strcpy (command_line.blue_channel, ignored[2] ? "Ignored" : argv[rgbFlag + 3]);
// Check to see if the bands are numeric and in range
int r_channel = atoi(command_line.red_channel);
int g_channel = atoi(command_line.green_channel);
int b_channel = atoi(command_line.blue_channel);
/////////// Numeric channel case ////////////
// Remove trailing non-numeric characters from the channel number
// string and pad front end nicely with a zero
if (!ignored[0] && is_numeric(command_line.red_channel) &&
r_channel >= 1 && r_channel <= MAX_BANDS) {
sprintf(command_line.red_channel, "%02d", atoi(command_line.red_channel));
}
if (!ignored[1] && is_numeric(command_line.green_channel) &&
g_channel >= 1 && g_channel <= MAX_BANDS) {
sprintf(command_line.green_channel, "%02d", atoi(command_line.green_channel));
}
if (!ignored[2] && is_numeric(command_line.blue_channel) &&
b_channel >= 1 && b_channel <= MAX_BANDS) {
sprintf(command_line.blue_channel, "%02d", atoi(command_line.blue_channel));
}
}
// Set up the bands for true or false color optical data
true_color = false_color = 0;
int with_sigma = FALSE;
if (truecolorFlag != FLAG_NOT_SET || falsecolorFlag != FLAG_NOT_SET) {
int ALOS_optical = (md->optical && strncmp(md->general->sensor, "ALOS", 4) == 0) ? 1 : 0;
if (md->optical && truecolorFlag != FLAG_NOT_SET) {
if (ALOS_optical) {
with_sigma = TRUE;
strcpy(command_line.red_channel, "03");
strcpy(command_line.green_channel, "02");
strcpy(command_line.blue_channel, "01");
true_color = 1;
asfPrintStatus("Applying True Color contrast expansion to following channels:");
}
else {
char **bands = extract_band_names(md->general->bands, 3);
asfRequire(bands != NULL,
"-truecolor option specified for non-true color optical image.\n");
asfPrintWarning("Attempting to use the -truecolor option with non-ALOS\n"
"optical data.\n");
strcpy(command_line.red_channel, bands[2]);
strcpy(command_line.green_channel, bands[1]);
strcpy(command_line.blue_channel, bands[0]);
int i;
for (i=0; i<3; i++) {
FREE(bands[i]);
}
FREE(bands);
}
}
if (md->optical && falsecolorFlag != FLAG_NOT_SET) {
if (ALOS_optical) {
with_sigma = TRUE;
strcpy(command_line.red_channel, "04");
strcpy(command_line.green_channel, "03");
strcpy(command_line.blue_channel, "02");
false_color = 1;
asfPrintStatus("Applying False Color contrast expansion to the following channels:");
}
else {
char **bands = extract_band_names(md->general->bands, 4);
asfRequire(bands != NULL,
"-falsecolor option specified for an optical image with fewer than 4 bands.\n");
asfPrintWarning("Attempting to use the -falsecolor option with non-ALOS\n"
"optical data.\n");
strcpy(command_line.red_channel, bands[3]);
strcpy(command_line.green_channel, bands[2]);
strcpy(command_line.blue_channel, bands[1]);
int i;
for (i=0; i<3; i++) {
FREE(bands[i]);
}
FREE(bands);
}
}
if (!ALOS_optical && !md->optical) {
asfPrintError("-truecolor or -falsecolor option selected with non-optical data\n");
}
}
if (rgbFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET)
{
char red_band[16], green_band[16], blue_band[16];
asfPrintStatus("\nRed channel : %s %s\n", command_line.red_channel, sigma_str(with_sigma));
asfPrintStatus("Green channel: %s %s\n", command_line.green_channel, sigma_str(with_sigma));
asfPrintStatus("Blue channel : %s %s\n\n", command_line.blue_channel, sigma_str(with_sigma));
if (is_numeric(command_line.red_channel) &&
is_numeric(command_line.green_channel) &&
is_numeric(command_line.blue_channel))
{
sprintf(red_band, "%02d", atoi(command_line.red_channel));
sprintf(green_band, "%02d", atoi(command_line.green_channel));
sprintf(blue_band, "%02d", atoi(command_line.blue_channel));
band_names = find_bands(in_base_name, rgbFlag,
red_band,
green_band,
blue_band,
&num_bands_found);
}
else {
band_names = find_bands(in_base_name, rgbFlag,
command_line.red_channel,
command_line.green_channel,
command_line.blue_channel,
&num_bands_found);
}
}
// Set band
if ( bandFlag != FLAG_NOT_SET) {
strcpy (command_line.band, argv[bandFlag + 1]);
band_names = find_single_band(in_base_name, command_line.band,
&num_bands_found);
}
else if (rgbFlag == FLAG_NOT_SET &&
truecolorFlag == FLAG_NOT_SET &&
falsecolorFlag == FLAG_NOT_SET &&
bandFlag == FLAG_NOT_SET) {
bandFlag=1; // For proper messaging to the user
strcpy (command_line.band, "all");
band_names = find_single_band(in_base_name, command_line.band,
&num_bands_found);
}
// Read look up table name
if ( lutFlag != FLAG_NOT_SET) {
strcpy(command_line.look_up_table_name, argv[lutFlag + 1]);
rgb = 1;
}
// Set scaling mechanism
if ( byteFlag != FLAG_NOT_SET ) {
strcpy (sample_mapping_string, argv[byteFlag + 1]);
for ( ii = 0; ii < strlen(sample_mapping_string); ii++) {
sample_mapping_string[ii] = toupper (sample_mapping_string[ii]);
}
if ( strcmp (sample_mapping_string, "TRUNCATE") == 0 )
command_line.sample_mapping = TRUNCATE;
else if ( strcmp(sample_mapping_string, "MINMAX") == 0 )
command_line.sample_mapping = MINMAX;
else if ( strcmp(sample_mapping_string, "SIGMA") == 0 )
command_line.sample_mapping = SIGMA;
else if ( strcmp(sample_mapping_string, "HISTOGRAM_EQUALIZE") == 0 )
command_line.sample_mapping = HISTOGRAM_EQUALIZE;
else if ( strcmp(sample_mapping_string, "NONE") == 0 ) {
asfPrintWarning("Sample remapping method (-byte option) is set to NONE\n"
"which doesn't make sense. Defaulting to TRUNCATE...\n");
command_line.sample_mapping = TRUNCATE;
}
else
asfPrintError("Unrecognized byte scaling method '%s'.\n",
sample_mapping_string);
}
int is_polsarpro = (md->general->bands && strstr(md->general->bands, "POLSARPRO") != NULL) ? 1 : 0;
if ( !is_polsarpro &&
lutFlag != FLAG_NOT_SET &&
bandFlag == FLAG_NOT_SET &&
md->general->band_count > 1)
{
asfPrintError("Look up tables can only be applied to single band"
" images\n");
}
if ( !is_polsarpro &&
lutFlag != FLAG_NOT_SET &&
command_line.sample_mapping == NONE &&
md->general->data_type != BYTE &&
md->general->band_count == 1)
{
asfPrintError("Look up tables can only be applied to byte output"
" images\n");
}
// Report what is going to happen
if (rgbFlag != FLAG_NOT_SET ||
truecolorFlag != FLAG_NOT_SET ||
falsecolorFlag != FLAG_NOT_SET)
{
if (num_bands_found >= 3) {
asfPrintStatus("Exporting multiband image ...\n\n");
rgb = 1;
}
else {
asfPrintError("Not all RGB channels found.\n");
}
}
else if (bandFlag != FLAG_NOT_SET) {
if (strcmp_case(command_line.band, "ALL") == 0) {
if (multiband(command_line.format,
extract_band_names(md->general->bands, md->general->band_count),
md->general->band_count))
asfPrintStatus("Exporting multiband image ...\n\n");
else if (num_bands_found > 1)
asfPrintStatus("Exporting each band into individual greyscale files ...\n\n");
}
else if (num_bands_found == 1) {
if (lutFlag != FLAG_NOT_SET)
asfPrintStatus("Exporting band '%s' applying look up table ...\n\n",
command_line.band);
else
asfPrintStatus("Exporting band '%s' as greyscale ...\n\n",
command_line.band);
}
else
asfPrintError("Band could not be found in the image.\n");
}
else if (lutFlag != FLAG_NOT_SET)
asfPrintStatus("Exporting applying look up table.\n\n");
else
asfPrintStatus("Exporting as greyscale.\n\n");
//If user added ".img", strip it.
ext = findExt(in_base_name);
if (ext && strcmp(ext, ".img") == 0) *ext = '\0';
meta_free(md);
/***********************END COMMAND LINE PARSING STUFF***********************/
if ( strcmp (command_line.format, "ENVI") == 0 ) {
format = ENVI;
}
else if ( strcmp (command_line.format, "ESRI") == 0 ) {
format = ESRI;
}
else if ( strcmp (command_line.format, "GEOTIFF") == 0 ||
strcmp (command_line.format, "GEOTIF") == 0) {
format = GEOTIFF;
}
else if ( strcmp (command_line.format, "TIFF") == 0 ||
strcmp (command_line.format, "TIF") == 0) {
format = TIF;
}
else if ( strcmp (command_line.format, "JPEG") == 0 ||
strcmp (command_line.format, "JPG") == 0) {
format = JPEG;
}
else if ( strcmp (command_line.format, "PGM") == 0 ) {
format = PGM;
}
else if ( strcmp (command_line.format, "PNG") == 0 ) {
format = PNG;
}
else if ( strcmp (command_line.format, "PNG_ALPHA") == 0 ) {
format = PNG_ALPHA;
}
else if ( strcmp (command_line.format, "PNG_GE") == 0 ) {
format = PNG_GE;
}
else if ( strcmp (command_line.format, "KML") == 0 ) {
format = KML;
}
else if ( strcmp (command_line.format, "POLSARPRO") == 0 ) {
format = POLSARPRO_HDR;
}
else if ( strcmp (command_line.format, "HDF5") == 0 ) {
format = HDF;
}
else if ( strcmp (command_line.format, "NETCDF") == 0 ) {
format = NC;
}
else {
asfPrintError("Unrecognized output format specified\n");
}
/* Complex data generally can't be output into meaningful images, so
we refuse to deal with it. */
/*
md = meta_read (command_line.in_meta_name);
asfRequire ( md->general->data_type == BYTE
|| md->general->data_type == INTEGER16
|| md->general->data_type == INTEGER32
|| md->general->data_type == REAL32
|| md->general->data_type == REAL64,
"Cannot cope with complex data, exiting...\n");
meta_free (md);
*/
// Do that exporting magic!
asf_export_bands(format, command_line.sample_mapping, rgb,
true_color, false_color,
command_line.look_up_table_name,
in_base_name, command_line.output_name, band_names,
NULL, NULL);
// If the user didn't ask for a log file then nuke the one that's been kept
// since everything has finished successfully
if (logFlag == FLAG_NOT_SET) {
fclose (fLog);
remove(logFile);
}
for (ii = 0; ii<num_bands_found; ii++) {
FREE(band_names[ii]);
}
FREE(band_names);
FREE(in_base_name);
FREE(output_name);
exit (EXIT_SUCCESS);
}
