static int read_colors(const char *name, const char *mapset,
struct Colors *colors)
{
FILE *fd;
int stat;
char buf[1024];
fd = G_fopen_old_misc(RASTER3D_DIRECTORY, RASTER3D_COLOR_ELEMENT, name, mapset);
if (!fd)
return -2;
/*
* first line in 4.0 color files is %
* otherwise it is pre 4.0
*/
if (fgets(buf, sizeof buf, fd) == NULL) {
fclose(fd);
return -1;
}
G_fseek(fd, 0L, 0);
G_strip(buf);
if (*buf == '%') { /* 4.0 format */
stat = read_new_colors(fd, colors);
colors->version = 0; /* 4.0 format */
}
else {
stat = read_old_colors(fd, colors);
colors->version = -1; /* pre 4.0 format */
}
fclose(fd);
return stat;
}
/*!
* \brief Read the first line of a file in cell_misc/
*
* Read the first line of data from a cell_misc/ meta-data file.
*
* \param element metadata component filename
* \param name
* \param mapset
* \param *str string to be populated with data
* \return dynamically-allocated string on success
* \return NULL on error
*/
static char *misc_read_line(const char *elem,
const char *name, const char *mapset)
{
char buff[GNAME_MAX];
FILE *fp;
buff[0] = '\0';
if (G_find_file2_misc("cell_misc", elem, name, mapset) == NULL)
return NULL;
fp = G_fopen_old_misc("cell_misc", elem, name, mapset);
if (!fp) {
G_warning(_("Unable to read <%s> for raster map <%s@%s>"),
elem, name, mapset);
return NULL;
}
if (G_getl2(buff, sizeof(buff) - 1, fp) == 0) {
/* file is empty */
*buff = '\0';
}
if (fclose(fp) != 0)
G_fatal_error(_("Error closing <%s> metadata file for raster map <%s@%s>"),
elem, name, mapset);
return *buff ? G_store(buff) : NULL;
}
/*!
* \brief Read the first line of a file in cell_misc/
*
* Read the first line of data from a cell_misc/ meta-data file.
*
* \param element metadata component filename
* \param name
* \param mapset
* \param *str string to be populated with data
* \return 0 on success
* \return -1, EOF (fclose() result) on error
*/
int G__raster_misc_read_line(const char *elem, const char *name,
const char *mapset, char *str)
{
FILE *fd;
char buff[GNAME_MAX];
buff[0] = '\0';
if (G_find_file2_misc("cell_misc", elem, name, mapset) == NULL)
return -1;
fd = G_fopen_old_misc("cell_misc", elem, name, mapset);
if (!fd) {
G_warning(_("Can't read %s for [%s in %s]"), elem, name, mapset);
return -1;
}
if (G_getl2(buff, sizeof(buff) - 1, fd) == 0) {
/* file is empty */
return fclose(fd);
}
strcpy(str, buff);
return fclose(fd);
}
FILE *I_fopen_group_file_old(const char *group, const char *file)
{
FILE *fd;
/* find file first */
if (!I_find_group_file(group, file)) {
G_warning(_("Unable to find file [%s] of group [%s in %s]"),
file, group, G_mapset());
return ((FILE *) NULL);
}
fd = G_fopen_old_misc("group", file, group, G_mapset());
if (!fd)
G_warning(_("Unable to open file [%s] of group [%s in %s]"),
file, group, G_mapset());
return fd;
}
FILE *I_fopen_subgroup_file_old(const char *group,
const char *subgroup, const char *file)
{
FILE *fd;
char element[GNAME_MAX * 2];
/* find file first */
if (!I_find_subgroup_file(group, subgroup, file)) {
G_warning(_("Unable to find file [%s] for subgroup [%s] of group [%s in %s]"),
file, subgroup, group, G_mapset());
return ((FILE *) NULL);
}
/* get subgroup element name */
sprintf(element, "subgroup/%s/%s", subgroup, file);
fd = G_fopen_old_misc("group", element, group, G_mapset());
if (!fd)
G_warning(_("Unable to open file [%s] for subgroup [%s] of group [%s in %s]"),
file, subgroup, group, G_mapset());
return fd;
}
/*!
* \brief Read raster range (CELL)
*
* This routine reads the range information for the raster map
* <i>name</i> in <i>mapset</i> into the <i>range</i> structure.
*
* A diagnostic message is printed and -1 is returned if there is an error
* reading the range file. Otherwise, 0 is returned.
*
* Old range file (those with 4 numbers) should treat zeros in this
* file as NULL-values. New range files (those with just 2 numbers)
* should treat these numbers as real data (zeros are real data in
* this case). An empty range file indicates that the min, max are
* undefined. This is a valid case, and the result should be an
* initialized range struct with no defined min/max. If the range file
* is missing and the map is a floating-point map, this function will
* create a default range by calling G_construct_default_range().
*
* \param name map name
* \param mapset mapset name
* \param[out] range pointer to Range structure which holds range info
*
* \return -1 on error
* \return 1 on success
* \return 2 if range is empty
* \return 3 if raster map is floating-point, get range from quant rules
*/
int Rast_read_range(const char *name, const char *mapset, struct Range *range)
{
FILE *fd;
CELL x[4];
char buf[200];
int n, count;
struct Quant quant;
struct FPRange drange;
Rast_init_range(range);
fd = NULL;
/* if map is not integer, read quant rules, and get limits */
if (Rast_map_type(name, mapset) != CELL_TYPE) {
DCELL dmin, dmax;
if (Rast_read_quant(name, mapset, &quant) < 0) {
G_warning(_("Unable to read quant rules for raster map <%s>"),
G_fully_qualified_name(name, mapset));
return -1;
}
if (Rast_quant_is_truncate(&quant) || Rast_quant_is_round(&quant)) {
if (Rast_read_fp_range(name, mapset, &drange) >= 0) {
Rast_get_fp_range_min_max(&drange, &dmin, &dmax);
if (Rast_quant_is_truncate(&quant)) {
x[0] = (CELL) dmin;
x[1] = (CELL) dmax;
}
else { /* round */
if (dmin > 0)
x[0] = (CELL) (dmin + .5);
else
x[0] = (CELL) (dmin - .5);
if (dmax > 0)
x[1] = (CELL) (dmax + .5);
else
x[1] = (CELL) (dmax - .5);
}
}
else
return -1;
}
else
Rast_quant_get_limits(&quant, &dmin, &dmax, &x[0], &x[1]);
Rast_update_range(x[0], range);
Rast_update_range(x[1], range);
return 3;
}
if (G_find_file2_misc("cell_misc", "range", name, mapset)) {
fd = G_fopen_old_misc("cell_misc", "range", name, mapset);
if (!fd) {
G_warning(_("Unable to read range file for <%s>"),
G_fully_qualified_name(name, mapset));
return -1;
}
/* if range file exists but empty */
if (!fgets(buf, sizeof buf, fd)) {
if (fd)
fclose(fd);
return 2;
}
x[0] = x[1] = x[2] = x[3] = 0;
count = sscanf(buf, "%d%d%d%d", &x[0], &x[1], &x[2], &x[3]);
/* if wrong format */
if (count <= 0) {
if (fd)
fclose(fd);
G_warning(_("Unable to read range file for <%s>"),
G_fully_qualified_name(name, mapset));
return -1;
}
for (n = 0; n < count; n++) {
/* if count==4, the range file is old (4.1) and 0's in it
have to be ignored */
if (count < 4 || x[n])
Rast_update_range((CELL) x[n], range);
}
fclose(fd);
}
return 1;
}
/*!
\brief Get GDAL link settings for given raster map
\param name map name
\param mapset name of mapset
\return pointer to GDAL_link structure
\return NULL if link not found
*/
struct GDAL_link *Rast_get_gdal_link(const char *name, const char *mapset)
{
#ifdef GDAL_LINK
GDALDatasetH data;
GDALRasterBandH band;
GDALDataType type;
RASTER_MAP_TYPE req_type;
#endif
const char *filename;
int band_num;
struct GDAL_link *gdal;
RASTER_MAP_TYPE map_type;
FILE *fp;
struct Key_Value *key_val;
const char *p;
DCELL null_val;
int hflip, vflip;
if (!G_find_raster2(name, mapset))
return NULL;
map_type = Rast_map_type(name, mapset);
if (map_type < 0)
return NULL;
fp = G_fopen_old_misc("cell_misc", "gdal", name, mapset);
if (!fp)
return NULL;
key_val = G_fread_key_value(fp);
fclose(fp);
if (!key_val)
return NULL;
filename = G_find_key_value("file", key_val);
if (!filename)
return NULL;
p = G_find_key_value("band", key_val);
if (!p)
return NULL;
band_num = atoi(p);
if (!band_num)
return NULL;
p = G_find_key_value("null", key_val);
if (!p)
return NULL;
if (strcmp(p, "none") == 0)
Rast_set_d_null_value(&null_val, 1);
else
null_val = atof(p);
hflip = G_find_key_value("hflip", key_val) ? 1 : 0;
vflip = G_find_key_value("vflip", key_val) ? 1 : 0;
#ifdef GDAL_LINK
p = G_find_key_value("type", key_val);
if (!p)
return NULL;
type = atoi(p);
switch (type) {
case GDT_Byte:
case GDT_Int16:
case GDT_UInt16:
case GDT_Int32:
case GDT_UInt32:
req_type = CELL_TYPE;
break;
case GDT_Float32:
req_type = FCELL_TYPE;
break;
case GDT_Float64:
req_type = DCELL_TYPE;
break;
default:
return NULL;
}
if (req_type != map_type)
return NULL;
Rast_init_gdal();
data = (*pGDALOpen) (filename, GA_ReadOnly);
if (!data)
return NULL;
band = (*pGDALGetRasterBand) (data, band_num);
if (!band) {
(*pGDALClose) (data);
return NULL;
}
#endif
gdal = G_calloc(1, sizeof(struct GDAL_link));
gdal->filename = G_store(filename);
gdal->band_num = band_num;
gdal->null_val = null_val;
gdal->hflip = hflip;
gdal->vflip = vflip;
#ifdef GDAL_LINK
gdal->data = data;
gdal->band = band;
gdal->type = type;
#endif
return gdal;
}
int main(int argc, char *argv[])
{
/* Global variable & function declarations */
char Cellmap_orig[50];
FILE *realfp, *imagfp; /* the input and output file descriptors */
int outputfd, maskfd; /* the input and output file descriptors */
char *realmapset, *imagmapset; /* the input mapset names */
struct Cell_head orig_wind, realhead;
CELL *cell_row, *maskbuf = NULL;
int i, j; /* Loop control variables */
int or, oc; /* Original dimensions of image */
int rows, cols; /* Smallest powers of 2 >= number of rows & columns */
long totsize; /* Total number of data points */
int halfrows, halfcols;
double *data[2]; /* Data structure containing real & complex values of FFT */
struct Option *op1, *op2, *op3;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
module->keywords = _("imagery, FFT");
module->description =
_("Inverse Fast Fourier Transform (IFFT) for image processing.");
/* define options */
op1 = G_define_standard_option(G_OPT_R_INPUT);
op1->key = "real_image";
op1->description = _("Name of input raster map (image fft, real part)");
op2 = G_define_standard_option(G_OPT_R_INPUT);
op2->key = "imaginary_image";
op2->description = _("Name of input raster map (image fft, imaginary part");
op3 = G_define_standard_option(G_OPT_R_OUTPUT);
op3->key = "output_image";
op3->description = _("Name for output raster map");
/*call parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
strcpy(Cellmap_real, op1->answer);
strcpy(Cellmap_imag, op2->answer);
strcpy(Cellmap_orig, op3->answer);
/* open input raster map */
if ((realmapset = G_find_cell(Cellmap_real, "")) == NULL)
G_fatal_error(_("Raster map <%s> not found"),
Cellmap_real);
if ((realfp =
G_fopen_old_misc("cell_misc", "fftreal", Cellmap_real,
realmapset)) == NULL)
G_fatal_error(_("Unable to open real-image in the 'cell_misc' directory. "
"Raster map probably wasn't created by i.fft"));
if ((imagmapset = G_find_cell(Cellmap_imag, "")) == NULL)
G_fatal_error(_("Raster map <%s> not found"),
Cellmap_imag);
if ((imagfp =
G_fopen_old_misc("cell_misc", "fftimag", Cellmap_imag,
imagmapset)) == NULL)
G_fatal_error(_("Unable to open imaginary-image in the 'cell_misc' directory. "
"Raster map probably wasn't created by i.fft"));
/* check command line args for validity */
if (G_legal_filename(Cellmap_orig) < 0)
G_fatal_error(_("<%s> is an illegal file name"),
Cellmap_orig);
/* get and compare the original window data */
get_orig_window(&orig_wind, realmapset, imagmapset);
or = orig_wind.rows;
oc = orig_wind.cols;
G_get_cellhd(Cellmap_real, realmapset, &realhead);
G_set_window(&realhead); /* set the window to the whole cell map */
/* get the rows and columns in the current window */
rows = G_window_rows();
cols = G_window_cols();
totsize = rows * cols;
halfrows = rows / 2;
halfcols = cols / 2;
G_verbose_message(_("Power 2 values: %d rows %d columns"), rows, cols);
/* Allocate appropriate memory for the structure containing
the real and complex components of the FFT. DATA[0] will
contain the real, and DATA[1] the complex component.
*/
data[0] = (double *)G_malloc((rows * cols) * sizeof(double));
data[1] = (double *)G_malloc((rows * cols) * sizeof(double));
/* Initialize real & complex components to zero */
G_message(_("Reading raster maps..."));
{
fread((char *)data[0], sizeof(double), totsize, realfp);
fread((char *)data[1], sizeof(double), totsize, imagfp);
}
/* Read in cell map values */
G_message(_("Masking raster maps..."));
maskfd = G_maskfd();
if (maskfd >= 0)
maskbuf = G_allocate_cell_buf();
if (maskfd >= 0) {
for (i = 0; i < rows; i++) {
double *data0, *data1;
data0 = data[0] + i * cols;
data1 = data[1] + i * cols;
G_get_map_row(maskfd, maskbuf, i);
for (j = 0; j < cols; j++, data0++, data1++) {
if (maskbuf[j] == (CELL) 0) {
*(data0) = 0.0;
*(data1) = 0.0;
}
}
}
}
G_message(_("Rotating data..."));
/* rotate the data array for standard display */
for (i = 0; i < rows; i++) {
double temp;
for (j = 0; j < halfcols; j++) {
temp = *(data[0] + i * cols + j);
*(data[0] + i * cols + j) = *(data[0] + i * cols + j + halfcols);
*(data[0] + i * cols + j + halfcols) = temp;
temp = *(data[1] + i * cols + j);
*(data[1] + i * cols + j) = *(data[1] + i * cols + j + halfcols);
*(data[1] + i * cols + j + halfcols) = temp;
}
}
for (i = 0; i < halfrows; i++) {
double temp;
for (j = 0; j < cols; j++) {
temp = *(data[0] + i * cols + j);
*(data[0] + i * cols + j) =
*(data[0] + (i + halfrows) * cols + j);
*(data[0] + (i + halfrows) * cols + j) = temp;
temp = *(data[1] + i * cols + j);
*(data[1] + i * cols + j) =
*(data[1] + (i + halfrows) * cols + j);
*(data[1] + (i + halfrows) * cols + j) = temp;
}
}
/* close input cell maps and release the row buffers */
fclose(realfp);
fclose(imagfp);
if (maskfd >= 0) {
G_close_cell(maskfd);
G_free(maskbuf);
}
/* perform inverse FFT */
G_message(_("Starting Inverse FFT..."));
fft(1, data, totsize, cols, rows);
/* set up a window for the transform cell map */
G_set_window(&orig_wind);
/* open the output cell map and allocate a cell row buffer */
if ((outputfd = G_open_cell_new(Cellmap_orig)) < 0)
G_fatal_error(_("Unable to create raster map <%s>"),
Cellmap_orig);
cell_row = G_allocate_cell_buf();
/* Write out result to a new cell map */
G_message(_("Writing data..."));
for (i = 0; i < or; i++) {
for (j = 0; j < oc; j++) {
*(cell_row + j) = (CELL) (*(data[0] + i * cols + j) + 0.5);
}
G_put_raster_row(outputfd, cell_row, CELL_TYPE);
G_percent(i+1, or, 2);
}
G_close_cell(outputfd);
G_free(cell_row);
{
struct Colors colors;
struct Range range;
CELL min, max;
/* make a real component color table */
G_read_range(Cellmap_orig, G_mapset(), &range);
G_get_range_min_max(&range, &min, &max);
G_make_grey_scale_colors(&colors, min, max);
G_write_colors(Cellmap_orig, G_mapset(), &colors);
}
/* Release memory resources */
G_free(data[0]);
G_free(data[1]);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
static int
read_cats(const char *name, const char *mapset, struct Categories *pcats)
/* adapted from G__read_cats */
{
FILE *fd;
char buff[1024];
CELL cat;
DCELL val1, val2;
int old;
long num = -1;
fd = G_fopen_old_misc(RASTER3D_DIRECTORY, RASTER3D_CATS_ELEMENT, name, mapset);
if (!fd)
return -2;
/* Read the number of categories */
if (G_getl(buff, sizeof(buff), fd) == 0)
goto error;
if (sscanf(buff, "# %ld", &num) == 1)
old = 0;
else if (sscanf(buff, "%ld", &num) == 1)
old = 1;
/* Read the title for the file */
if (G_getl(buff, sizeof(buff), fd) == 0)
goto error;
G_strip(buff);
Rast_init_cats(buff, pcats);
if (num >= 0)
pcats->num = num;
if (!old) {
char fmt[256];
float m1, a1, m2, a2;
if (G_getl(fmt, sizeof(fmt), fd) == 0)
goto error;
/* next line contains equation coefficients */
if (G_getl(buff, sizeof(buff), fd) == 0)
goto error;
if (sscanf(buff, "%f %f %f %f", &m1, &a1, &m2, &a2) != 4)
goto error;
Rast_set_cats_fmt(fmt, m1, a1, m2, a2, pcats);
}
/* Read all category names */
for (cat = 0;; cat++) {
char label[1024];
if (G_getl(buff, sizeof(buff), fd) == 0)
break;
if (old)
Rast_set_c_cat(&cat, &cat, buff, pcats);
else {
*label = 0;
if (sscanf(buff, "%1s", label) != 1)
continue;
if (*label == '#')
continue;
*label = 0;
/* try to read a range of data */
if (sscanf(buff, "%lf:%lf:%[^\n]", &val1, &val2, label) == 3)
Rast_set_cat(&val1, &val2, label, pcats, DCELL_TYPE);
else if (sscanf(buff, "%d:%[^\n]", &cat, label) >= 1)
Rast_set_cat(&cat, &cat, label, pcats, CELL_TYPE);
else if (sscanf(buff, "%lf:%[^\n]", &val1, label) >= 1)
Rast_set_cat(&val1, &val1, label, pcats, DCELL_TYPE);
else
goto error;
}
}
fclose(fd);
return 0;
error:
fclose(fd);
return -1;
}