/******************************************************************************
MODULE: open_output
PURPOSE: Set up the output data structure. Open the output file for write
and read access.
RETURN VALUE:
Type = Output_t
Value Description
----- -----------
NULL Error occurred opening the file
not-NULL Successful completion
NOTES:
******************************************************************************/
Output_t *open_output
(
Espa_internal_meta_t *in_meta, /* I: input metadata structure */
Input_t *input, /* I: input band data structure */
bool toa /* I: set this structure up for the TOA
bands vs. the SR bands */
)
{
Output_t *this = NULL;
char FUNC_NAME[] = "open_output"; /* function name */
char errmsg[STR_SIZE]; /* error message */
char *upper_str = NULL; /* upper case version of the SI short name */
char *mychar = NULL; /* pointer to '_' */
char scene_name[STR_SIZE]; /* scene name for the current scene */
char production_date[MAX_DATE_LEN+1]; /* current date/time for production */
time_t tp; /* time structure */
struct tm *tm = NULL; /* time structure for UTC time */
int ib; /* looping variable for bands */
int refl_indx = -1; /* band index in XML file for the reflectance
band */
Espa_band_meta_t *bmeta = NULL; /* pointer to the band metadata array
within the output structure */
int nband = NBAND_TTL_OUT; /* number of output bands to be created */
/* Create the Output data structure */
this = (Output_t *) malloc (sizeof (Output_t));
if (this == NULL)
{
sprintf (errmsg, "Error allocating Output data structure");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
/* Find the representative band for metadata information. Use band 1. */
for (ib = 0; ib < in_meta->nbands; ib++)
{
if (!strcmp (in_meta->band[ib].name, "band1") &&
!strncmp (in_meta->band[ib].product, "L1", 2))
{
/* this is the index we'll use for reflectance band info */
refl_indx = ib;
break;
}
}
/* Make sure we found the L1G/T band 1 */
if (refl_indx == -1)
{
sprintf (errmsg, "Unable to find the L1G/T band 1 bands in the "
"XML file for initializing the output metadata.");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
/* Initialize the internal metadata for the output product. The global
metadata won't be updated, however the band metadata will be updated
and used later for appending to the original XML file. */
init_metadata_struct (&this->metadata);
/* Copy the instrument type */
this->inst = input->meta.inst;
/* Allocate memory for the total bands */
if (allocate_band_metadata (&this->metadata, nband) != SUCCESS)
{
sprintf (errmsg, "Allocating band metadata.");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
bmeta = this->metadata.band;
/* Determine the scene name */
strcpy (scene_name, in_meta->band[refl_indx].file_name);
mychar = strrchr (scene_name, '_');
if (mychar != NULL)
*mychar = '\0';
/* Get the current date/time (UTC) for the production date of each band */
if (time (&tp) == -1)
{
sprintf (errmsg, "Unable to obtain the current time.");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
tm = gmtime (&tp);
if (tm == NULL)
{
sprintf (errmsg, "Converting time to UTC.");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
if (strftime (production_date, MAX_DATE_LEN, "%Y-%m-%dT%H:%M:%SZ", tm) == 0)
{
sprintf (errmsg, "Formatting the production date/time.");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
/* Populate the data structure, using information from the reflectance
bands */
this->open = false;
this->nband = nband;
this->nlines = input->size.nlines;
this->nsamps = input->size.nsamps;
for (ib = 0; ib < this->nband; ib++)
this->fp_bin[ib] = NULL;
for (ib = 0; ib < nband; ib++)
{
strncpy (bmeta[ib].short_name, in_meta->band[refl_indx].short_name, 3);
bmeta[ib].short_name[3] = '\0';
if (toa)
{
strcat (bmeta[ib].short_name, "TOA");
if ((ib == SR_BAND10) || (ib == SR_BAND11))
strcpy (bmeta[ib].product, "toa_bt");
else
strcpy (bmeta[ib].product, "toa_refl");
}
else
{
strcat (bmeta[ib].short_name, "SR");
strcpy (bmeta[ib].product, "sr_refl");
}
bmeta[ib].nlines = this->nlines;
bmeta[ib].nsamps = this->nsamps;
bmeta[ib].pixel_size[0] = input->size.pixsize[0];
bmeta[ib].pixel_size[1] = input->size.pixsize[1];
strcpy (bmeta[ib].pixel_units, "meters");
sprintf (bmeta[ib].app_version, "l8_surface_reflectance_%s",
SR_VERSION);
strcpy (bmeta[ib].production_date, production_date);
/* Handle the cloud band differently. If this is only TOA then we
don't need to process the cloud mask. If this is SR, then we don't
need to process the cirrus or thermal bands. */
if (toa && ib == SR_CLOUD)
continue;
else if (!toa &&
((ib == SR_BAND9) || (ib == SR_BAND10) || (ib == SR_BAND11)))
continue;
else if (ib == SR_CLOUD)
{
bmeta[ib].data_type = ESPA_UINT8;
bmeta[ib].fill_value = CLOUD_FILL_VALUE;
strcpy (bmeta[ib].name, "sr_cloud");
strcpy (bmeta[ib].long_name, "surface reflectance cloud mask");
strcpy (bmeta[ib].category, "qa");
strcpy (bmeta[ib].data_units, "bitmap");
/* Set up cloud bitmap information */
if (allocate_bitmap_metadata (&bmeta[ib], 8) != SUCCESS)
{
sprintf (errmsg, "Allocating cloud bitmap.");
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
/* Identify the bitmap values for the mask */
strcpy (bmeta[ib].bitmap_description[0], "cirrus cloud");
strcpy (bmeta[ib].bitmap_description[1], "cloud");
strcpy (bmeta[ib].bitmap_description[2], "adjacent to cloud");
strcpy (bmeta[ib].bitmap_description[3], "cloud shadow");
strcpy (bmeta[ib].bitmap_description[4], "aerosol");
strcpy (bmeta[ib].bitmap_description[5], "aerosol");
strcpy (bmeta[ib].bitmap_description[6], "unused");
strcpy (bmeta[ib].bitmap_description[7], "internal test");
}
else
{
bmeta[ib].data_type = ESPA_INT16;
bmeta[ib].fill_value = FILL_VALUE;
strcpy (bmeta[ib].category, "image");
strcpy (bmeta[ib].data_units, "reflectance");
if (ib == SR_BAND10 || ib == SR_BAND11) /* thermal bands */
{
bmeta[ib].scale_factor = SCALE_FACTOR_TH;
bmeta[ib].valid_range[0] = MIN_VALID_TH;
bmeta[ib].valid_range[1] = MAX_VALID_TH;
}
else
{
bmeta[ib].scale_factor = SCALE_FACTOR;
bmeta[ib].valid_range[0] = MIN_VALID;
bmeta[ib].valid_range[1] = MAX_VALID;
}
if (ib >= SR_BAND1 && ib <= SR_BAND7)
{
if (toa)
{
sprintf (bmeta[ib].name, "toa_band%d", ib+1);
sprintf (bmeta[ib].long_name, "band %d top-of-atmosphere "
"reflectance", ib+1);
}
else
{
sprintf (bmeta[ib].name, "sr_band%d", ib+1);
sprintf (bmeta[ib].long_name, "band %d surface reflectance",
ib+1);
}
}
else if (ib == SR_BAND9) /* cirrus band */
{ /* band 9 is only atmospherically corrected */
sprintf (bmeta[ib].name, "toa_band%d", ib+2);
sprintf (bmeta[ib].long_name, "band %d top-of-atmosphere "
"reflectance", ib+2);
}
else if (ib == SR_BAND10 || ib == SR_BAND11) /* thermal bands */
{
sprintf (bmeta[ib].name, "toa_band%d", ib+2);
sprintf (bmeta[ib].long_name, "band %d at-satellite brightness "
"temperature", ib+2);
sprintf (bmeta[ib].data_units, "temperature (kelvin)");
}
}
/* Set up the filename with the scene name and band name and open the
file for read/write access. Don't open if this is OLI-only and
these are the thermal bands. */
if ((ib != SR_BAND10 && ib != SR_BAND11) || this->inst != INST_OLI)
{
sprintf (bmeta[ib].file_name, "%s_%s.img", scene_name,
bmeta[ib].name);
this->fp_bin[ib] = open_raw_binary (bmeta[ib].file_name, "w+");
if (this->fp_bin[ib] == NULL)
{
sprintf (errmsg, "Unable to open output band %d file: %s", ib,
bmeta[ib].file_name);
error_handler (true, FUNC_NAME, errmsg);
return (NULL);
}
}
/* Free the memory for the upper-case string */
free (upper_str);
} /* for ib */
this->open = true;
/* Successful completion */
return this;
}
/******************************************************************************
MODULE: main
PURPOSE: Creates the Landsat solar and view/satellite per-pixel angles. Both
the zenith and azimuth angles are created for each angle type for the
representative band.
RETURN VALUE:
Type = int
Value Description
----- -----------
ERROR Error creating the angle bands
SUCCESS No errors encountered
NOTES:
1. Angles are written in degrees and scaled by 100.
2. There are 4 bands written for the representative band: solar zenith, solar
azimuth, sensor zenith, sensor azimuth.
3. The landsat_per_pixel_angles library expects an array of solar/satellite
azimuth/zenith pointers for all the input bands, as that's the possible
full list of output bands. So, even though we are not processing all the
bands in the output list, we still need to provide an array of that size.
This requires us to keep track of the indices for each of the output bands
into the array of input bands, for both ETM and TM arrays.
******************************************************************************/
int main (int argc, char** argv)
{
char FUNC_NAME[] = "create_angle_bands"; /* function name */
char errmsg[STR_SIZE]; /* error message */
char tmpstr[STR_SIZE]; /* temporary string */
char tmpfile[STR_SIZE]; /* temporary filename */
char ang_infile[STR_SIZE]; /* input angle coefficient filename */
char outfile[STR_SIZE]; /* output base filename for angle bands */
char band_list[STR_SIZE]; /* char array of list of bands to process */
char etm_list[] = "4"; /* list of ETM bands to process */
char tm_list[] = "4"; /* list of TM bands to process */
char production_date[MAX_DATE_LEN+1]; /* current date/year for production */
char band_angle[NANGLE_BANDS][STR_SIZE] = {"solar zenith", "solar azimuth",
"sensor zenith", "sensor azimuth"};
char *cptr = NULL; /* pointer to file extension */
char *xml_infile = NULL; /* input XML filename */
bool process_l7 = false; /* are we processing L7 vs. L4-5 */
bool process_l45 = false; /* are we processing L4-5 vs. L7 */
int i; /* looping variable for bands */
int curr_bnd; /* current input band location */
int curr_band; /* current input band number */
int curr_bndx; /* index of current input band */
int curr_index; /* index of current output band in the input
band array */
int etm_nbands = 1; /* number of ETM bands to process for PPA */
int tm_nbands = 1; /* number of TM bands to process for PPA */
int landsat_nbands; /* number of bands to process for PPA */
int *landsat_bands = NULL; /* array of output bands to be processed;
set to point to either etm_bands or
tm_bands */
int etm_bands[] = {4}; /* output bands to be processed */
int tm_bands[] = {4}; /* output bands to be processed */
int *band_indx = NULL; /* array of indices for the output bands within
the full set of input bands; set to point
to either etm_band_indx or tm_band_indx */
int etm_band_indx[] = {3}; /* index in the overall input bands for
the output bands [1,2,3,4,5,61,62,7,8] */
int tm_band_indx[] = {3}; /* index in the overall input bands for
the output bands [1,2,3,4,5,6,7,8] */
int out_nbands; /* number of output bands to be written */
int nlines[L7_NBANDS]; /* number of lines for each band */
int nsamps[L7_NBANDS]; /* number of samples for each band */
Angle_band_t ang; /* looping variable for solar/senor angle */
short *solar_zenith[L7_NBANDS]; /* array of pointers for the solar zenith
angle array, one per band */
short *solar_azimuth[L7_NBANDS]; /* array of pointers for the solar azimuth
angle array, one per band */
short *sat_zenith[L7_NBANDS]; /* array of pointers for the satellite
zenith angle array, one per band */
short *sat_azimuth[L7_NBANDS]; /* array of pointers for the satellite
azimuth angle array, one per band */
short *curr_angle = NULL; /* pointer to the current angle array */
time_t tp; /* time structure */
struct tm *tm = NULL; /* time structure for UTC time */
FILE *fptr=NULL; /* file pointer */
Envi_header_t envi_hdr; /* output ENVI header information */
Espa_internal_meta_t xml_metadata;
/* XML metadata structure to be populated by
reading the input XML metadata file */
Espa_band_meta_t *bmeta=NULL; /* pointer to array of bands metadata */
Espa_global_meta_t *gmeta=NULL; /* pointer to the global metadata struct */
Espa_band_meta_t *out_bmeta = NULL; /* band metadata for angle bands */
Espa_internal_meta_t out_meta; /* output metadata for angle bands */
/* Read the command-line arguments */
if (get_args (argc, argv, &xml_infile) != SUCCESS)
{ /* get_args already printed the error message */
exit (ERROR);
}
printf ("Processing the per-pixel angle bands for L4-7 ...\n");
/* Validate the input metadata file */
if (validate_xml_file (xml_infile) != SUCCESS)
{ /* Error messages already written */
return (ERROR);
}
/* Initialize the metadata structure */
init_metadata_struct (&xml_metadata);
/* Parse the metadata file into our internal metadata structure; also
allocates space as needed for various pointers in the global and band
metadata */
if (parse_metadata (xml_infile, &xml_metadata) != SUCCESS)
{ /* Error messages already written */
return (ERROR);
}
bmeta = xml_metadata.band;
gmeta = &xml_metadata.global;
/* Determine which instrument is being processed */
if (!strncmp (gmeta->instrument, "ETM", 3))
process_l7 = true;
else
process_l45 = true;
/* Determine the angle coefficient filename and the output file basename */
strcpy (ang_infile, xml_infile);
cptr = strchr (ang_infile, '.');
strcpy (cptr, "_ANG.txt");
strcpy (outfile, xml_infile);
cptr = strchr (outfile, '.');
*cptr = '\0';
/* Initialize the output metadata structure. The global metadata will
not be used and will not be valid. */
init_metadata_struct (&out_meta);
/* Determine the number of output bands */
if (process_l7)
{
landsat_bands = etm_bands;
landsat_nbands = etm_nbands;
out_nbands = landsat_nbands * NANGLE_BANDS;
band_indx = etm_band_indx;
strcpy (band_list, etm_list);
}
else
{
landsat_bands = tm_bands;
landsat_nbands = tm_nbands;
out_nbands = landsat_nbands * NANGLE_BANDS;
band_indx = tm_band_indx;
strcpy (band_list, tm_list);
}
/* Allocate memory for the output bands */
if (allocate_band_metadata (&out_meta, out_nbands) != SUCCESS)
{
sprintf (errmsg, "Cannot allocate memory for the %d angle bands",
out_nbands);
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Get the current date/time (UTC) for the production date of each band */
if (time (&tp) == -1)
{
sprintf (errmsg, "Unable to obtain the current time.");
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
tm = gmtime (&tp);
if (tm == NULL)
{
sprintf (errmsg, "Converting time to UTC.");
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
if (strftime (production_date, MAX_DATE_LEN, "%Y-%m-%dT%H:%M:%SZ", tm) == 0)
{
sprintf (errmsg, "Formatting the production date/time.");
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Initialize the Landsat angle bands to NULL */
init_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
/* Create the Landsat angle bands for the specified bands. Create a full
resolution product. */
if (landsat_per_pixel_angles (ang_infile, 1, band_list, solar_zenith,
solar_azimuth, sat_zenith, sat_azimuth, nlines, nsamps) != SUCCESS)
{ /* Error messages already written */
free_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
exit (ERROR);
}
/* Setup the XML file for these bands */
for (i = 0; i < out_nbands; i++)
{
/* Set up the band metadata for the current band */
out_bmeta = &out_meta.band[i];
strcpy (out_bmeta->product, "angle_bands");
strcpy (out_bmeta->source, "level1");
strcpy (out_bmeta->category, "image");
/* Setup filename-related items for all four bands: solar zenith,
solar azimuth, sensor zenith, sensor azimuth. L4-5 and L8 band
numbers follow a normal numbering scheme. L7 band numbering
needs a little help to get it correct. */
curr_bnd = i / NANGLE_BANDS + 1; /* current input band number */
curr_bndx = curr_bnd - 1; /* index of current input band */
curr_band = landsat_bands[curr_bndx]; /* actual band number */
curr_index = band_indx[curr_bndx]; /* index in output array */
switch (i % NANGLE_BANDS)
{
case (SOLAR_ZEN): /* solar zenith */
/* Determine the output file for the solar zenith band */
snprintf (tmpfile, sizeof (tmpfile),
"%s_b%d_solar_zenith.img", outfile, curr_band);
sprintf (out_bmeta->name, "solar_zenith_band%d", curr_band);
strncpy (tmpstr, bmeta[curr_bndx].short_name, 4);
tmpstr[4] = '\0';
sprintf (out_bmeta->short_name, "%sSOLZEN", tmpstr);
sprintf (out_bmeta->long_name,
"band %d solar zenith angles", curr_band);
break;
case (SOLAR_AZ): /* solar azimuth */
/* Determine the output file for the solar azimuth band */
snprintf (tmpfile, sizeof (tmpfile),
"%s_b%d_solar_azimuth.img", outfile, curr_band);
sprintf (out_bmeta->name, "solar_azimuth_band%d",
curr_band);
strncpy (tmpstr, bmeta[curr_bndx].short_name, 4);
tmpstr[4] = '\0';
sprintf (out_bmeta->short_name, "%sSOLAZ", tmpstr);
sprintf (out_bmeta->long_name,
"band %d solar azimuth angles", curr_band);
break;
case (SENSOR_ZEN): /* sensor zenith */
/* Determine the output file for the sensor zenith band */
snprintf (tmpfile, sizeof (tmpfile),
"%s_b%d_sensor_zenith.img", outfile, curr_band);
sprintf (out_bmeta->name, "sensor_zenith_band%d",
curr_band);
strncpy (tmpstr, bmeta[curr_bndx].short_name, 4);
tmpstr[4] = '\0';
sprintf (out_bmeta->short_name, "%sSENZEN", tmpstr);
sprintf (out_bmeta->long_name,
"band %d sensor zenith angles", curr_band);
break;
case (SENSOR_AZ): /* sensor azimuth */
/* Determine the output file for the sensor azimuth band */
snprintf (tmpfile, sizeof (tmpfile),
"%s_b%d_sensor_azimuth.img", outfile, curr_band);
sprintf (out_bmeta->name, "sensor_azimuth_band%d",
curr_band);
strncpy (tmpstr, bmeta[curr_bndx].short_name, 4);
tmpstr[4] = '\0';
sprintf (out_bmeta->short_name, "%sSENAZ", tmpstr);
sprintf (out_bmeta->long_name,
"band %d sensor azimuth angles", curr_band);
break;
}
snprintf (out_bmeta->file_name, sizeof (out_bmeta->file_name), "%s",
tmpfile);
out_bmeta->data_type = ESPA_INT16;
out_bmeta->fill_value = ANGLE_BAND_FILL;
out_bmeta->scale_factor = ANGLE_BAND_SCALE_FACT;
strcpy (out_bmeta->data_units, "degrees");
out_bmeta->nlines = nlines[curr_index];
out_bmeta->nsamps = nsamps[curr_index];
out_bmeta->pixel_size[0] = bmeta[curr_bndx].pixel_size[0];
out_bmeta->pixel_size[1] = bmeta[curr_bndx].pixel_size[1];
strcpy (out_bmeta->pixel_units, bmeta[curr_bndx].pixel_units);
sprintf (out_bmeta->app_version, "create_angle_bands_%s",
ESPA_COMMON_VERSION);
strcpy (out_bmeta->production_date, production_date);
}
/* Loop through the four different angle files and write them for each
band */
for (ang = 0; ang < NANGLE_BANDS; ang++)
{
/* Write the angle bands */
for (i = 0; i < landsat_nbands; i++)
{
/* Determine the index of this band in the overall list of input
bands */
curr_index = band_indx[i];
/* Grab the correct data array to be written for this angle
band */
switch (ang)
{
case (SOLAR_ZEN):
curr_angle = &solar_zenith[curr_index][0];
break;
case (SOLAR_AZ):
curr_angle = &solar_azimuth[curr_index][0];
break;
case (SENSOR_ZEN):
curr_angle = &sat_zenith[curr_index][0];
break;
case (SENSOR_AZ):
curr_angle = &sat_azimuth[curr_index][0];
break;
default:
free_per_pixel_angles (solar_zenith, solar_azimuth,
sat_zenith, sat_azimuth);
sprintf (errmsg, "Invalid angle type %d", ang);
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Open the output file for this band */
out_bmeta = &out_meta.band[i*NANGLE_BANDS + ang];
fptr = open_raw_binary (out_bmeta->file_name, "wb");
if (!fptr)
{
free_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
sprintf (errmsg, "Unable to open the %s file",
band_angle[ang]);
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Write the data for this band */
if (write_raw_binary (fptr, nlines[curr_index], nsamps[curr_index],
sizeof (short), curr_angle) != SUCCESS)
{
free_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
sprintf (errmsg, "Unable to write to the %s file",
band_angle[ang]);
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Close the file for this band */
close_raw_binary (fptr);
/* Create the ENVI header */
if (create_envi_struct (out_bmeta, gmeta, &envi_hdr) != SUCCESS)
{
free_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
sprintf (errmsg, "Error creating the ENVI header file.");
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Write the ENVI header */
sprintf (tmpfile, "%s", out_bmeta->file_name);
sprintf (&tmpfile[strlen(tmpfile)-3], "hdr");
if (write_envi_hdr (tmpfile, &envi_hdr) != SUCCESS)
{
free_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
sprintf (errmsg, "Writing the ENVI header file: %s.",
tmpfile);
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
} /* for i < landsat_nbands */
} /* for ang < NANGLE_BANDS */
/* Free the pointers */
free_per_pixel_angles (solar_zenith, solar_azimuth, sat_zenith,
sat_azimuth);
/* Append the solar/sensor angle bands to the XML file */
if (append_metadata (out_nbands, out_meta.band, xml_infile) != SUCCESS)
{
sprintf (errmsg, "Appending solar/sensor angle bands to the XML file.");
error_handler (true, FUNC_NAME, errmsg);
exit (ERROR);
}
/* Free the input and output XML metadata */
free_metadata (&xml_metadata);
free_metadata (&out_meta);
/* Free the pointers */
free (xml_infile);
/* Successful completion */
exit (SUCCESS);
}