int output_raster(int fd)
{
int i;
for (i = 0; i < page.rows; i++, at_row++) {
G_percent(i, page.rows, 2);
switch (format) {
case USE_CELL:
cell = raster.cell[i];
/* insert the NULL values */
G_insert_c_null_values(cell, null_flags[i], page.cols);
if (G_put_c_raster_row(fd, cell) < 0)
return -1;
break;
case USE_DCELL:
dcell = raster.dcell[i];
/* insert the NULL values */
G_insert_d_null_values(dcell, null_flags[i], page.cols);
if (G_put_d_raster_row(fd, dcell) < 0)
return -1;
break;
}
}
G_percent(1, 1, 1);
return configure_plot();
}
int gaussurf(char *out, /* Name of raster maps to be opened. */
double mean, double sigma /* Distribution parameters. */
)
{
int nrows, ncols; /* Number of cell rows and columns */
DCELL *row_out; /* Buffer just large enough to hold one */
/* row of the raster map layer. */
int fd_out; /* File descriptor - used to identify */
/* open raster maps. */
struct History history; /* cmd line history metadata */
int row_count, col_count;
/****** INITIALISE RANDOM NUMBER GENERATOR ******/
G_math_rand(-1 * getpid());
/****** OPEN CELL FILES AND GET CELL DETAILS ******/
fd_out = G_open_raster_new(out, DCELL_TYPE);
nrows = G_window_rows();
ncols = G_window_cols();
row_out = G_allocate_d_raster_buf();
/****** PASS THROUGH EACH CELL ASSIGNING RANDOM VALUE ******/
for (row_count = 0; row_count < nrows; row_count++) {
for (col_count = 0; col_count < ncols; col_count++)
*(row_out + col_count) =
(DCELL) (G_math_rand_gauss(2742, sigma) + mean);
/* Write contents row by row */
G_put_d_raster_row(fd_out, (DCELL *) row_out);
}
/****** CLOSE THE CELL FILE ******/
G_close_cell(fd_out);
G_short_history(out, "raster", &history);
G_command_history(&history);
G_write_history(out, &history);
return 0;
}
int main(int argc, char *argv[])
{
char *input;
char *output;
char *title;
FILE *fd;
int cf;
struct Cell_head cellhd;
CELL *cell;
FCELL *fcell;
DCELL *dcell;
int row, col;
int nrows, ncols;
static int missingval;
int rtype;
double mult_fact;
double x;
struct GModule *module;
struct History history;
struct
{
struct Option *input, *output, *type, *title, *mult;
} parm;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, import");
module->description =
_("Converts an ESRI ARC/INFO ascii raster file (GRID) "
"into a (binary) raster map layer.");
parm.input = G_define_option();
parm.input->key = "input";
parm.input->type = TYPE_STRING;
parm.input->required = YES;
parm.input->description =
_("ARC/INFO ASCII raster file (GRID) to be imported");
parm.input->gisprompt = "old_file,file,input";
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.type = G_define_option();
parm.type->key = "type";
parm.type->type = TYPE_STRING;
parm.type->required = NO;
parm.type->options = "CELL,FCELL,DCELL";
parm.type->answer = "FCELL";
parm.type->description = _("Storage type for resultant raster map");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "\"phrase\"";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.mult = G_define_option();
parm.mult->key = "mult";
parm.mult->type = TYPE_DOUBLE;
parm.mult->answer = "1.0";
parm.mult->required = NO;
parm.mult->description = _("Multiplier for ASCII data");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
input = parm.input->answer;
output = parm.output->answer;
if (title = parm.title->answer)
G_strip(title);
sscanf(parm.mult->answer, "%lf", &mult_fact);
if (strcmp("CELL", parm.type->answer) == 0)
rtype = CELL_TYPE;
else if (strcmp("DCELL", parm.type->answer) == 0)
rtype = DCELL_TYPE;
else
rtype = FCELL_TYPE;
if (strcmp("-", input) == 0) {
Tmp_file = G_tempfile();
if (NULL == (Tmp_fd = fopen(Tmp_file, "w+")))
G_fatal_error(_("Unable to open temporary file <%s>"), Tmp_file);
unlink(Tmp_file);
if (0 > file_cpy(stdin, Tmp_fd))
exit(EXIT_FAILURE);
fd = Tmp_fd;
}
else
fd = fopen(input, "r");
if (fd == NULL)
G_fatal_error(_("Unable to open input file <%s>"), input);
if (!gethead(fd, &cellhd, &missingval))
G_fatal_error(_("Can't get cell header"));
nrows = cellhd.rows;
ncols = cellhd.cols;
if (G_set_window(&cellhd) < 0)
G_fatal_error(_("Can't set window"));
if (nrows != G_window_rows())
G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows,
G_window_rows());
if (ncols != G_window_cols())
G_fatal_error(_("OOPS: cols changed from %d to %d"), ncols,
G_window_cols());
switch (rtype) {
case CELL_TYPE:
cell = G_allocate_c_raster_buf();
break;
case FCELL_TYPE:
fcell = G_allocate_f_raster_buf();
break;
case DCELL_TYPE:
dcell = G_allocate_d_raster_buf();
break;
}
cf = G_open_raster_new(output, rtype);
if (cf < 0)
G_fatal_error(_("Unable to create raster map <%s>"), output);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 5);
for (col = 0; col < ncols; col++) {
if (fscanf(fd, "%lf", &x) != 1) {
G_unopen_cell(cf);
G_fatal_error(_("Data conversion failed at row %d, col %d"),
row + 1, col + 1);
}
switch (rtype) {
case CELL_TYPE:
if ((int)x == missingval)
G_set_c_null_value(cell + col, 1);
else
cell[col] = (CELL) x *mult_fact;
break;
case FCELL_TYPE:
if ((int)x == missingval)
G_set_f_null_value(fcell + col, 1);
else
fcell[col] = (FCELL) x *mult_fact;
break;
case DCELL_TYPE:
if ((int)x == missingval)
G_set_d_null_value(dcell + col, 1);
else
dcell[col] = (DCELL) x *mult_fact;
break;
}
}
switch (rtype) {
case CELL_TYPE:
G_put_c_raster_row(cf, cell);
break;
case FCELL_TYPE:
G_put_f_raster_row(cf, fcell);
break;
case DCELL_TYPE:
G_put_d_raster_row(cf, dcell);
break;
}
}
/* G_message(_("CREATING SUPPORT FILES FOR %s"), output); */
G_close_cell(cf);
if (title)
G_put_cell_title(output, title);
G_short_history(output, "raster", &history);
G_command_history(&history);
G_write_history(output, &history);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *rastin, *rastout, *method;
struct History history;
char title[64];
char buf_nsres[100], buf_ewres[100];
struct Colors colors;
char *inmap;
int infile, outfile;
DCELL *outbuf;
int row, col;
struct Cell_head dst_w, src_w;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, resample");
module->description =
_("Resamples raster map layers to a finer grid using interpolation.");
rastin = G_define_standard_option(G_OPT_R_INPUT);
rastout = G_define_standard_option(G_OPT_R_OUTPUT);
method = G_define_option();
method->key = "method";
method->type = TYPE_STRING;
method->required = NO;
method->description = _("Interpolation method");
method->options = "nearest,bilinear,bicubic";
method->answer = "bilinear";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (G_strcasecmp(method->answer, "nearest") == 0)
neighbors = 1;
else if (G_strcasecmp(method->answer, "bilinear") == 0)
neighbors = 2;
else if (G_strcasecmp(method->answer, "bicubic") == 0)
neighbors = 4;
else
G_fatal_error(_("Invalid method: %s"), method->answer);
G_get_set_window(&dst_w);
inmap = G_find_cell2(rastin->answer, "");
if (!inmap)
G_fatal_error(_("Raster map <%s> not found"), rastin->answer);
/* set window to old map */
G_get_cellhd(rastin->answer, inmap, &src_w);
/* enlarge source window */
{
double north = G_row_to_northing(0.5, &dst_w);
double south = G_row_to_northing(dst_w.rows - 0.5, &dst_w);
int r0 = (int)floor(G_northing_to_row(north, &src_w) - 0.5) - 1;
int r1 = (int)floor(G_northing_to_row(south, &src_w) - 0.5) + 3;
double west = G_col_to_easting(0.5, &dst_w);
double east = G_col_to_easting(dst_w.cols - 0.5, &dst_w);
int c0 = (int)floor(G_easting_to_col(west, &src_w) - 0.5) - 1;
int c1 = (int)floor(G_easting_to_col(east, &src_w) - 0.5) + 3;
src_w.south -= src_w.ns_res * (r1 - src_w.rows);
src_w.north += src_w.ns_res * (-r0);
src_w.west -= src_w.ew_res * (-c0);
src_w.east += src_w.ew_res * (c1 - src_w.cols);
src_w.rows = r1 - r0;
src_w.cols = c1 - c0;
}
G_set_window(&src_w);
/* allocate buffers for input rows */
for (row = 0; row < neighbors; row++)
bufs[row] = G_allocate_d_raster_buf();
cur_row = -100;
/* open old map */
infile = G_open_cell_old(rastin->answer, inmap);
if (infile < 0)
G_fatal_error(_("Unable to open raster map <%s>"), rastin->answer);
/* reset window to current region */
G_set_window(&dst_w);
outbuf = G_allocate_d_raster_buf();
/* open new map */
outfile = G_open_raster_new(rastout->answer, DCELL_TYPE);
if (outfile < 0)
G_fatal_error(_("Unable to create raster map <%s>"), rastout->answer);
G_suppress_warnings(1);
/* otherwise get complaints about window changes */
switch (neighbors) {
case 1: /* nearest */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow0 = (int)floor(maprow_f + 0.5);
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol0 = (int)floor(mapcol_f + 0.5);
double c = bufs[0][mapcol0];
if (G_is_d_null_value(&c)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = c;
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
case 2: /* bilinear */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow0 = (int)floor(maprow_f);
double v = maprow_f - maprow0;
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol0 = (int)floor(mapcol_f);
int mapcol1 = mapcol0 + 1;
double u = mapcol_f - mapcol0;
double c00 = bufs[0][mapcol0];
double c01 = bufs[0][mapcol1];
double c10 = bufs[1][mapcol0];
double c11 = bufs[1][mapcol1];
if (G_is_d_null_value(&c00) ||
G_is_d_null_value(&c01) ||
G_is_d_null_value(&c10) || G_is_d_null_value(&c11)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = G_interp_bilinear(u, v, c00, c01, c10, c11);
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
case 4: /* bicubic */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow1 = (int)floor(maprow_f);
int maprow0 = maprow1 - 1;
double v = maprow_f - maprow1;
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol1 = (int)floor(mapcol_f);
int mapcol0 = mapcol1 - 1;
int mapcol2 = mapcol1 + 1;
int mapcol3 = mapcol1 + 2;
double u = mapcol_f - mapcol1;
double c00 = bufs[0][mapcol0];
double c01 = bufs[0][mapcol1];
double c02 = bufs[0][mapcol2];
double c03 = bufs[0][mapcol3];
double c10 = bufs[1][mapcol0];
double c11 = bufs[1][mapcol1];
double c12 = bufs[1][mapcol2];
double c13 = bufs[1][mapcol3];
double c20 = bufs[2][mapcol0];
double c21 = bufs[2][mapcol1];
double c22 = bufs[2][mapcol2];
double c23 = bufs[2][mapcol3];
double c30 = bufs[3][mapcol0];
double c31 = bufs[3][mapcol1];
double c32 = bufs[3][mapcol2];
double c33 = bufs[3][mapcol3];
if (G_is_d_null_value(&c00) ||
G_is_d_null_value(&c01) ||
G_is_d_null_value(&c02) ||
G_is_d_null_value(&c03) ||
G_is_d_null_value(&c10) ||
G_is_d_null_value(&c11) ||
G_is_d_null_value(&c12) ||
G_is_d_null_value(&c13) ||
G_is_d_null_value(&c20) ||
G_is_d_null_value(&c21) ||
G_is_d_null_value(&c22) ||
G_is_d_null_value(&c23) ||
G_is_d_null_value(&c30) ||
G_is_d_null_value(&c31) ||
G_is_d_null_value(&c32) || G_is_d_null_value(&c33)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = G_interp_bicubic(u, v,
c00, c01, c02, c03,
c10, c11, c12, c13,
c20, c21, c22, c23,
c30, c31, c32, c33);
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
}
G_percent(dst_w.rows, dst_w.rows, 2);
G_close_cell(infile);
G_close_cell(outfile);
/* record map metadata/history info */
sprintf(title, "Resample by %s interpolation", method->answer);
G_put_cell_title(rastout->answer, title);
G_short_history(rastout->answer, "raster", &history);
strncpy(history.datsrc_1, rastin->answer, RECORD_LEN);
history.datsrc_1[RECORD_LEN - 1] = '\0'; /* strncpy() doesn't null terminate if maxfill */
G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj);
G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj);
sprintf(history.datsrc_2, "Source map NS res: %s EW res: %s", buf_nsres,
buf_ewres);
G_command_history(&history);
G_write_history(rastout->answer, &history);
/* copy color table from source map */
if (G_read_colors(rastin->answer, inmap, &colors) < 0)
G_fatal_error(_("Unable to read color table for %s"), rastin->answer);
G_mark_colors_as_fp(&colors);
if (G_write_colors(rastout->answer, G_mapset(), &colors) < 0)
G_fatal_error(_("Unable to write color table for %s"),
rastout->answer);
return (EXIT_SUCCESS);
}
void write_row_file ( DCELL *row, int fd) {
G_put_d_raster_row (fd, row);
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd;
struct Range range;
char *name; /* input raster name */
char *result; /* output raster name */
char *mapset; /* mapset name */
DCELL *inrast; /* input buffer */
DCELL *outrast; /* output buffer */
int row,col;
int infd, outfd; /* file descriptor */
int verbose;
double *weights; /* array of weights */
DCELL **D_rows;
DCELL *tmp;
int nrows;
int ncols;
double min, max; /* raster map range */
RASTER_MAP_TYPE data_type; /* type of the map */
void *values; /* neighborhood values */
int n,i; /* number of neighborhood cells */
int size; /* matrix size */
double ssigma; /* sigma of the spatial part */
double csigma; /* sigma of the color part */
char title[1024]; /* map title */
struct GModule *module; /* GRASS module for parsing arguments */
struct
{
struct Option *input, *output;
struct Option *sigma_s, *sigma_c, *size;
struct Option *title;
} parm;
struct
{
struct Flag *quiet;
struct Flag *print_sigmas;
} flag;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env,
stores program name to
G_program_name
*/
/* initialize module */
module = G_define_module();
module->description = ("Gaussian filter for raster maps.");
/* Define the different options */
parm.input = G_define_option() ;
parm.input->key = "input";
parm.input->type = TYPE_STRING;
parm.input->required = YES;
parm.input->description= ("Name of an input layer" );
parm.output = G_define_option() ;
parm.output->key = "output";
parm.output->type = TYPE_STRING;
parm.output->required = YES;
parm.output->description= ("Name of an output layer");
parm.sigma_s = G_define_option() ;
parm.sigma_s->key = "ssigma";
parm.sigma_s->type = TYPE_DOUBLE;
parm.sigma_s->required = NO;
parm.sigma_s->description= ("Sigma for space part of the filter\n\t(default: 0.465*((size-1)/2)");
parm.sigma_c = G_define_option() ;
parm.sigma_c->key = "csigma";
parm.sigma_c->type = TYPE_DOUBLE;
parm.sigma_c->required = NO;
parm.sigma_c->description= ("Sigma for color part of the filter\n(default: 0.465*((color_range)/2)");
parm.size = G_define_option() ;
parm.size->key = "size";
parm.size->type = TYPE_INTEGER;
parm.size->required = YES;
parm.size->description= ("Size of the matrix (odd number)");
flag.print_sigmas = G_define_flag() ;
flag.print_sigmas->key = 's' ;
flag.print_sigmas->description = "Print calculated values for sigmas" ;
flag.quiet = G_define_flag() ;
flag.quiet->key = 'q' ;
flag.quiet->description = "Quiet" ;
/* options and flags pareser */
if (G_parser(argc, argv))
exit (-1);
/* stores options and flags to variables */
name = parm.input->answer;
result = parm.output->answer;
verbose = (! flag.quiet->answer);
sscanf(parm.size->answer, "%d", &size);
if (!parm.sigma_s->answer)
ssigma = 0.465*((size-1)/2);
else
sscanf(parm.sigma_s->answer, "%lf", &ssigma);
/* controlling the input values */
if (size%2 == 0)
G_fatal_error("Size <%d> is not odd number", size);
/* returs NULL if the map was not found in any mapset,
* mapset name otherwise*/
mapset = G_find_cell2 (name, "");
if (mapset == NULL)
G_fatal_error ("cell file [%s] not found", name);
/* color sigma next */
if (!parm.sigma_c->answer) {
if (G_read_range(name, mapset, &range) < 0)
G_fatal_error("Could not read the raster map range");
/* for raster maps with range from 0-255 the result
* should be around 60
*/
min = (double)range.min;
max = (double)range.max;
csigma = 0.456*(max - min)/2;
}
else
sscanf(parm.sigma_c->answer, "%lf", &csigma);
/* print if appropriate */
if (flag.print_sigmas->answer)
printf("Space sigma: %f\nColor sigma: %f\n", ssigma, csigma);
if (G_legal_filename (result) < 0)
G_fatal_error ("[%s] is an illegal name", result);
/* count weights */
weights = (double *)malloc(size * size * sizeof(double));
/* stores values of gauss. bell into 'weigts'*/
count_weights(weights, size, ssigma);
/* determine the inputmap type (CELL/FCELL/DCELL) */
data_type = G_raster_map_type(name, mapset);
/* G_open_cell_old - returns file destriptor (>0) */
if ( (infd = G_open_cell_old (name, mapset)) < 0)
G_fatal_error ("Cannot open cell file [%s]", name);
/* controlling, if we can open input raster */
if (G_get_cellhd (name, mapset, &cellhd) < 0)
G_fatal_error ("Cannot read file header of [%s]", name);
/* Allocate input buffer */
inrast = G_allocate_raster_buf(data_type);
/* Allocate output buffer, use input map data_type */
nrows = G_window_rows();
ncols = G_window_cols();
outrast = G_allocate_d_raster_buf();
/* Allocate values buffers */
values = (DCELL *) malloc(size * size * sizeof(DCELL));
/* allocating memory for rows */
D_rows = (DCELL **)malloc(size * sizeof(DCELL));
for (i = 0; i < size; i++) {
D_rows[i] = G_allocate_raster_buf(DCELL_TYPE);
}
if (values == NULL)
G_fatal_error("Cannot allocate memory");
/* controlling, if we can write the raster */
if ( (outfd = G_open_raster_new (result, data_type)) < 0)
G_fatal_error ("Could not open <%s>",result);
/* write first rows as NULL values */
for (row = 0; row < size/2; row++) {
G_set_d_null_value(outrast, ncols);
if (G_put_d_raster_row (outfd, outrast) < 0)
G_fatal_error ("Cannot write to <%s>",result);
}
/* allocate first size/2 rows */
for (row = 0; row < size; row++)
if (G_get_d_raster_row(infd, D_rows[row], row) < 0)
G_fatal_error ("Could not open <%s>",result);
/****************************************************************/
/* for each row inside the region */
for ( row = size/2; row < nrows - size/2; row++) {
if (verbose)
G_percent (row, nrows, 2);
/* allocate new last row */
G_get_d_raster_row(infd, D_rows[size-1], row+(size/2));
/*process the data */
for (col=0; col < ncols; col++){
/* skip the outside columns */
if ( (col - size/2) < 0 || ncols <= (col + size/2)) {
G_set_d_null_value(outrast, 1);
}
/* work only with columns, which are inside */
else {
/* store values of the matrix into arry 'values', 'n' is
* number of elements of the matrix */
n = D_gather(infd, values, D_rows, col, row,size);
((DCELL *)outrast)[col] = D_bilateral(values, ssigma, csigma, size, weights);
}
} /* for each column */
/* write raster row to output raster file */
G_put_d_raster_row (outfd, outrast);
/* switch rows */
tmp = D_rows[0];
for (i = 0; i < size; i++){
D_rows[i] = D_rows[i + 1];
}
D_rows[size-1] = tmp;
} /* for each row */
/* write last rows as NULL values */
for (i = 0; i < size/2; i++) {
G_set_d_null_value(outrast, ncols);
G_put_d_raster_row (outfd, outrast);
}
/* memory cleaning */
G_free(outrast);
G_free(inrast);
G_free(values);
for (i = 0; i < size; i++) {
G_free(D_rows[i]);
}
free((void *) D_rows);
/* closing rastr files */
G_close_cell (infd);
G_close_cell (outfd);
/* set the map title */
sprintf(title, "Bilateral filter of %s with %dx%d matrix: ssigma %.3f, csigma %.3f", name, size, size, ssigma, csigma );
G_put_cell_title (result, title );
return 0;
}
