CPLErr GRASSRasterBand::ResetReading ( struct Cell_head *sNewWindow )
{
/* Check if the window has changed */
if ( sNewWindow->north != sOpenWindow.north || sNewWindow->south != sOpenWindow.south ||
sNewWindow->east != sOpenWindow.east || sNewWindow->west != sOpenWindow.west ||
sNewWindow->ew_res != sOpenWindow.ew_res || sNewWindow->ns_res != sOpenWindow.ns_res ||
sNewWindow->rows != sOpenWindow.rows || sNewWindow->cols != sOpenWindow.cols )
{
if( hCell >= 0 ) {
G_close_cell( hCell );
hCell = -1;
}
/* Set window */
G_set_window( sNewWindow );
/* Open raster */
G__setenv( "GISDBASE", ((GRASSDataset *)poDS)->pszGisdbase );
G__setenv( "LOCATION_NAME", ((GRASSDataset *)poDS)->pszLocation );
G__setenv( "MAPSET", pszMapset);
G_reset_mapsets();
G_add_mapset_to_search_path ( pszMapset );
if ( (hCell = G_open_cell_old( pszCellName, pszMapset)) < 0 ) {
CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster '%s'", pszCellName );
this->valid = false;
return CE_Failure;
}
G_copy((void *) &sOpenWindow, (void *) sNewWindow, sizeof(struct Cell_head));
}
else
{
/* The windows are identical, check current window */
struct Cell_head sCurrentWindow;
G_get_window ( &sCurrentWindow );
if ( sNewWindow->north != sCurrentWindow.north || sNewWindow->south != sCurrentWindow.south ||
sNewWindow->east != sCurrentWindow.east || sNewWindow->west != sCurrentWindow.west ||
sNewWindow->ew_res != sCurrentWindow.ew_res || sNewWindow->ns_res != sCurrentWindow.ns_res ||
sNewWindow->rows != sCurrentWindow.rows || sNewWindow->cols != sCurrentWindow.cols
)
{
/* Reset window */
G_set_window( sNewWindow );
}
}
return CE_None;
}
int zoom_pan_update(void *closure, int sxn, int syn, int button)
{
G_debug(2, "button = %d x = %d y = %d", button, sxn, syn);
if (button == 3)
return 1;
if (button == 1) {
double x = D_d_to_u_col(sxn);
double y = D_d_to_u_row(syn);
double dx = (window.east - window.west) / 2;
double dy = (window.north - window.south) / 2;
window.north = y + dy;
window.south = y - dy;
window.east = x + dx;
window.west = x - dx;
G_debug(2, "w = %f e = %f n = %f s = %f", window.west, window.east,
window.north, window.south);
G_adjust_Cell_head(&window, 0, 0);
G_put_window(&window);
G_set_window(&window);
display_redraw();
}
return 0;
}
/* Zoom - to region */
int zoom_region(void)
{
struct Cell_head win;
char *mapset;
G_debug(2, "zoom_region()");
driver_open();
mapset = G_find_file2("windows", var_getc(VAR_ZOOM_REGION), NULL);
if (mapset == NULL) {
G_warning(_("Cannot find window '%s'"), var_getc(VAR_ZOOM_REGION));
return 0;
}
G__get_window(&win, "windows", var_getc(VAR_ZOOM_REGION), mapset);
G_put_window(&win);
G_set_window(&win);
display_redraw();
driver_close();
G_debug(3, "zoom_region(): End");
return 1;
}
int main( int argc, char **argv )
{
char *mapset;
char *name;
int fp;
struct GModule *module;
struct Option *map;
struct Option *win;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->keywords = ( "display, raster" );
module->description = ( "Output raster map layers in a format suitable for display in QGIS" );
map = G_define_standard_option( G_OPT_R_MAP );
map->description = ( "Raster map to be displayed" );
win = G_define_option();
win->key = "window";
win->type = TYPE_DOUBLE;
win->multiple = YES;
win->description = "xmin,ymin,xmax,ymax,ncols,nrows";
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
/* Make sure map is available */
mapset = G_find_cell2( name, "" );
if ( mapset == NULL )
G_fatal_error(( "Raster map <%s> not found" ), name );
/* It can happen that GRASS data set is 'corrupted' and zone differs in WIND and
* cellhd, and G_open_cell_old fails, so it is better to read window from map */
/* G_get_window( &window ); */
G_get_cellhd( name, mapset, &window );
window.west = atof( win->answers[0] );
window.south = atof( win->answers[1] );
window.east = atof( win->answers[2] );
window.north = atof( win->answers[3] );
window.cols = atoi( win->answers[4] );
window.rows = atoi( win->answers[5] );
G_adjust_Cell_head( &window, 1, 1 );
G_set_window( &window );
fp = G_raster_map_is_fp( name, mapset );
/* use DCELL even if the map is FCELL */
if ( fp )
display( name, mapset, DCELL_TYPE );
else
display( name, mapset, CELL_TYPE );
exit( EXIT_SUCCESS );
}
int configure_plot(void)
{
int i, j;
int nrows;
int ncols;
nrows = region.rows - at_row;
if (nrows <= 0)
return DONE;
if (nrows > max_rows)
nrows = max_rows;
ncols = region.cols;
/* zero the raster */
switch (format) {
case USE_CHAR:
for (i = 0; i < nrows; i++)
for (j = 0; j < ncols; j++)
raster.c[i][j] = 0;
break;
case USE_UCHAR:
for (i = 0; i < nrows; i++)
for (j = 0; j < ncols; j++)
raster.u[i][j] = 0;
break;
case USE_SHORT:
for (i = 0; i < nrows; i++)
for (j = 0; j < ncols; j++)
raster.s[i][j] = 0;
break;
case USE_CELL:
for (i = 0; i < nrows; i++)
for (j = 0; j < ncols; j++)
raster.cell[i][j] = 0;
break;
}
/* change the region */
page.north = region.north - at_row * region.ns_res;
page.south = page.north - nrows * region.ns_res;
G_set_window(&page);
/* configure the plot routines */
G_setup_plot(-0.5, page.rows - 0.5, -0.5, page.cols - 0.5, move, cont);
return AGAIN;
}
int zoom_window_update(void *closure, int sxn, int syn, int button)
{
struct zoom_window *zw = closure;
if (zw->mode == 1) {
i_prompt_buttons(_("1. corner"), _("2. corner"), _("Quit"));
zw->next_mode = 2;
}
G_debug(2, "button = %d x = %d y = %d", button, sxn, syn);
if (button == 3)
return 1;
if (zw->mode == 2 && button == 2) {
double x1 = D_d_to_u_col(zw->sxo);
double y1 = D_d_to_u_row(zw->syo);
double x2 = D_d_to_u_col(sxn);
double y2 = D_d_to_u_row(syn);
G_debug(2, "x1 = %f x2 = %f y1 = %f y2 = %f", x1, x2, y1, y2);
window.north = y1 > y2 ? y1 : y2;
window.south = y1 < y2 ? y1 : y2;
window.west = x1 < x2 ? x1 : x2;
window.east = x1 > x2 ? x1 : x2;
G_debug(2, "w = %f e = %f n = %f s = %f", window.west, window.east,
window.north, window.south);
G_adjust_Cell_head(&window, 0, 0);
G_put_window(&window);
G_set_window(&window);
display_redraw();
i_prompt_buttons(_("1. corner"), _("1. corner"), _("Quit"));
zw->next_mode = 1;
}
zw->sxo = sxn;
zw->syo = syn;
zw->mode = zw->next_mode;
set_mode(zw->mode == 2 ? MOUSE_BOX : MOUSE_POINT);
set_location(zw->sxo, zw->syo);
return 0;
}
static void setup(void)
{
struct Cell_head region;
int t, b, l, r;
get_window(&t, &b, &l, &r);
/* Set the map region associated with graphics frame */
G_get_set_window(®ion);
if (G_set_window(®ion) < 0)
G_fatal_error(_("Can't set window"));
/* Determine conversion factors */
if (D_do_conversions(®ion, t, b, l, r))
G_fatal_error("Error calculating graphics-region conversions");
}
/*
* do_histogram() - Creates histogram for CELL
*
* RETURN: 0 on success / 1 on failure
*/
int do_histogram(char *name, char *mapset)
{
CELL *cell;
struct Cell_head cellhd;
struct Cell_stats statf;
int nrows, ncols;
int row;
int fd;
if (G_get_cellhd(name, mapset, &cellhd) < 0)
return 1;
G_set_window(&cellhd);
if ((fd = G_open_cell_old(name, mapset)) < 0)
return 1;
nrows = G_window_rows();
ncols = G_window_cols();
cell = G_allocate_cell_buf();
G_init_cell_stats(&statf);
/* Update statistics for each row */
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
if (G_get_map_row_nomask(fd, cell, row) < 0)
break;
G_update_cell_stats(cell, ncols, &statf);
}
/* Write histogram if it made it through the loop */
if (row == nrows)
G_write_histogram_cs(name, &statf);
G_free_cell_stats(&statf);
G_close_cell(fd);
G_free(cell);
if (row == nrows)
return 0;
return 1;
}
int get_cats(char *name, char *mapset)
{
int fd;
int row, nrows, ncols;
CELL *cell;
struct Cell_head cellhd;
/* set the window to the cell header */
if (G_get_cellhd(name, mapset, &cellhd) < 0)
G_fatal_error(_("Cannot read header of raster map <%s> in <%s>"),
name, mapset);
G_set_window(&cellhd);
/* open the raster map */
fd = G_open_cell_old(name, mapset);
if (fd < 0)
G_fatal_error(_("Cannot open cell file of raster map <%s> in <%s>"),
name, mapset);
nrows = G_window_rows();
ncols = G_window_cols();
cell = G_allocate_cell_buf();
G_init_cell_stats(&statf);
/* read the raster map */
G_verbose_message(_("Reading <%s> in <%s>"), name, mapset);
for (row = 0; row < nrows; row++) {
if (G_verbose() > G_verbose_std())
G_percent(row, nrows, 2);
if (G_get_c_raster_row_nomask(fd, cell, row) < 0)
exit(EXIT_SUCCESS);
G_update_cell_stats(cell, ncols, &statf);
}
/* done */
if (G_verbose() > G_verbose_std())
G_percent(row, nrows, 2);
G_close_cell(fd);
G_free(cell);
G_rewind_cell_stats(&statf);
return 0;
}
/* Zoom - default region */
int zoom_default(void)
{
struct Cell_head defwin;
G_debug(2, "zoom_default()");
driver_open();
G_get_default_window(&defwin);
G_put_window(&defwin);
G_set_window(&defwin);
display_redraw();
driver_close();
G_debug(3, "zoom_default(): End");
return 1;
}
/* Zoom - in / out (centre unchanged) */
int zoom_centre(double factor)
{
double xc, yc, dx, dy;
G_debug(2, "zoom_centre()");
driver_open();
G_debug(2, "1 n = %f s = %f", window.north, window.south);
dx = (window.east - window.west) / 2;
dy = (window.north - window.south) / 2;
xc = (window.east + window.west) / 2;
yc = (window.north + window.south) / 2;
G_debug(2, " yc = %f dy = %f", yc, dy);
window.north = yc + dy * factor;
window.south = yc - dy * factor;
window.east = xc + dx * factor;
window.west = xc - dx * factor;
G_debug(2, "2 n = %f s = %f", window.north, window.south);
G_adjust_Cell_head(&window, 0, 0);
G_debug(2, "3 n = %f s = %f", window.north, window.south);
G_put_window(&window);
G_set_window(&window);
display_redraw();
driver_close();
G_debug(3, "zoom_centre(): End");
return 1;
}
int main(int argc, char *argv[])
{
struct GModule *module;
int Out_proj;
int out_stat;
int old_zone, old_proj;
int i;
int stat;
char cmnd2[500];
char proj_out[20], proj_name[50], set_name[20];
char path[1024], buffa[1024], buffb[1024], answer[200], answer1[200];
char answer2[200], buff[1024];
char tmp_buff[20], *buf;
struct Key_Value *old_proj_keys, *out_proj_keys, *in_unit_keys;
double aa, e2;
double f;
FILE *FPROJ;
int exist = 0;
char spheroid[100];
int j, k, sph_check;
struct Cell_head cellhd;
char datum[100], dat_ellps[100], dat_params[100];
struct proj_parm *proj_parms;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("projection"));
module->description =
_("Interactively reset the location's projection settings.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (strcmp(G_mapset(), "PERMANENT") != 0)
G_fatal_error(_("You must be in the PERMANENT mapset to run g.setproj"));
/***
* no longer necessary, table is a static struct
* init_unit_table();
***/
sprintf(set_name, "PERMANENT");
G_file_name(path, "", PROJECTION_FILE, set_name);
/* get the output projection parameters, if existing */
/* Check for ownership here */
stat = G__mapset_permissions(set_name);
if (stat == 0) {
G_fatal_error(_("PERMANENT: permission denied"));
}
G_get_default_window(&cellhd);
if (-1 == G_set_window(&cellhd))
G_fatal_error(_("Current region cannot be set"));
if (G_get_set_window(&cellhd) == -1)
G_fatal_error(_("Retrieving and setting region failed"));
Out_proj = cellhd.proj;
old_zone = cellhd.zone;
old_proj = cellhd.proj;
if (access(path, 0) == 0) {
exist = 1;
FPROJ = fopen(path, "r");
old_proj_keys = G_fread_key_value(FPROJ);
fclose(FPROJ);
buf = G_find_key_value("name", old_proj_keys);
fprintf(stderr,
"\nWARNING: A projection file already exists for this location\n(Filename '%s')\n",
path);
fprintf(stderr,
"\nThis file contains all the parameters for the location's projection:\n %s\n",
buf);
fprintf(stderr,
"\n Overriding this information implies that the old projection parameters\n"
" were incorrect. If you change the parameters, all existing data will\n"
" be interpreted differently by the projection software.\n%c%c%c",
7, 7, 7);
fprintf(stderr,
" GRASS will not re-project your data automatically.\n\n");
if (!G_yes
(_("Would you still like to change some of the parameters?"),
0)) {
G_message(_("The projection information will not be updated"));
leave(SP_NOCHANGE);
}
}
out_proj_keys = G_create_key_value();
if (exist) {
buf = G_find_key_value("zone", old_proj_keys);
if (buf != NULL)
sscanf(buf, "%d", &zone);
if (zone != old_zone) {
G_warning(_("Zone in default geographic region definition: %d\n"
" is different from zone in PROJ_INFO file: %d"),
old_zone, zone);
old_zone = zone;
}
}
switch (Out_proj) {
case 0: /* No projection/units */
if (!exist) {
/* leap frog over code, and just make sure we remove the file */
G_warning(_("XY-location cannot be projected"));
goto write_file;
break;
}
case PROJECTION_UTM:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_UTM));
sprintf(proj_out, "utm");
break;
}
case PROJECTION_SP:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_SP));
sprintf(proj_out, "stp");
break;
}
case PROJECTION_LL:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_LL));
sprintf(proj_out, "ll");
break;
}
case PROJECTION_OTHER:
if (G_ask_proj_name(proj_out, proj_name) < 0)
leave(SP_NOCHANGE);
if (G_strcasecmp(proj_out, "LL") == 0)
Out_proj = PROJECTION_LL;
else if (G_strcasecmp(proj_out, "UTM") == 0)
Out_proj = PROJECTION_UTM;
else if (G_strcasecmp(proj_out, "STP") == 0)
Out_proj = PROJECTION_SP;
break;
default:
G_fatal_error(_("Unknown projection"));
}
cellhd.proj = Out_proj;
proj_parms = get_proj_parms(proj_out);
if (!proj_parms)
G_fatal_error(_("Projection %s is not specified in the file 'proj-parms.table'"),
proj_out);
G_set_key_value("name", proj_name, out_proj_keys);
sph_check = 0;
if (G_yes
(_("Do you wish to specify a geodetic datum for this location?"),
1)) {
char lbuf[100], lbufa[100];
if (exist &&
(G_get_datumparams_from_projinfo(old_proj_keys, lbuf, lbufa) ==
2)) {
G_strip(lbuf);
if ((i = G_get_datum_by_name(lbuf)) > 0) {
G_message(_("The current datum is %s (%s)"),
G_datum_name(i), G_datum_description(i));
if (G_yes
(_("Do you wish to change the datum (or datum transformation parameters)?"),
0))
sph_check = ask_datum(datum, dat_ellps, dat_params);
else {
sprintf(datum, lbuf);
sprintf(dat_params, lbufa);
sprintf(dat_ellps, G_datum_ellipsoid(i));
sph_check = 1;
G_message(_("The datum information has not been changed"));
}
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
if (sph_check > 0) {
char *paramkey, *paramvalue;
/* write out key/value pairs to out_proj_keys */
if (G_strcasecmp(datum, "custom") != 0)
G_set_key_value("datum", datum, out_proj_keys);
/* G_set_key_value("datumparams", dat_params, out_proj_keys); */
paramkey = strtok(dat_params, "=");
paramvalue = dat_params + strlen(paramkey) + 1;
G_set_key_value(paramkey, paramvalue, out_proj_keys);
sprintf(spheroid, "%s", dat_ellps);
}
else {
/***************** GET spheroid **************************/
if (Out_proj != PROJECTION_SP) { /* some projections have
* fixed spheroids */
if (G_strcasecmp(proj_out, "ALSK") == 0 ||
G_strcasecmp(proj_out, "GS48") == 0 ||
G_strcasecmp(proj_out, "GS50") == 0) {
sprintf(spheroid, "%s", "clark66");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "LABRD") == 0 ||
G_strcasecmp(proj_out, "NZMG") == 0) {
sprintf(spheroid, "%s", "international");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "SOMERC") == 0) {
sprintf(spheroid, "%s", "bessel");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "OB_TRAN") == 0) {
/* Hard coded to use "Equidistant Cylincrical"
* until g.setproj has been changed to run
* recurively, to allow input of options for
* a second projection, MHu991010 */
G_set_key_value("o_proj", "eqc", out_proj_keys);
sph_check = 2;
}
else {
if (exist &&
(buf =
G_find_key_value("ellps", old_proj_keys)) != NULL) {
strcpy(spheroid, buf);
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f)) {
/* if legal ellips. exist, ask wether or not to change it */
G_message(_("The current ellipsoid is %s"), spheroid);
if (G_yes
(_("Do you want to change ellipsoid parameter?"),
0))
sph_check = G_ask_ellipse_name(spheroid);
else {
G_message(_("The ellipse information has not been changed"));
sph_check = 1;
}
} /* the val is legal */
else
sph_check = G_ask_ellipse_name(spheroid);
}
else
sph_check = G_ask_ellipse_name(spheroid);
}
}
if (sph_check > 0) {
if (sph_check == 2) { /* ask radius */
if (exist) {
buf = G_find_key_value("a", old_proj_keys);
if ((buf != NULL) && (sscanf(buf, "%lf", &radius) == 1)) {
G_message(_("The radius is currently %f"), radius);
if (G_yes(_("Do you want to change the radius?"), 0))
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
}
}
else
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
} /* end ask radius */
}
}
/*** END get spheroid ***/
/* create the PROJ_INFO & PROJ_UNITS files, if required */
if (G_strcasecmp(proj_out, "LL") == 0) ;
else if (G_strcasecmp(proj_out, "STP") == 0)
get_stp_proj(buffb);
else if (sph_check != 2) {
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f) == 0)
G_fatal_error(_("Invalid input ellipsoid"));
}
write_file:
/*
** NOTE the program will (hopefully) never exit abnormally
** after this point. Thus we know the file will be completely
** written out once it is opened for write
*/
if (exist) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
goto write_units;
/*
** Include MISC parameters for PROJ_INFO
*/
if (G_strcasecmp(proj_out, "STP") == 0) {
for (i = 0; i < strlen(buffb); i++)
if (buffb[i] == ' ')
buffb[i] = '\t';
sprintf(cmnd2, "%s\t\n", buffb);
for (i = 0; i < strlen(cmnd2); i++) {
j = k = 0;
if (cmnd2[i] == '+') {
while (cmnd2[++i] != '=')
buffa[j++] = cmnd2[i];
buffa[j] = 0;
while (cmnd2[++i] != '\t' && cmnd2[i] != '\n' &&
cmnd2[i] != 0)
buffb[k++] = cmnd2[i];
buffb[k] = 0;
G_set_key_value(buffa, buffb, out_proj_keys);
}
}
}
else if (G_strcasecmp(proj_out, "LL") == 0) {
G_set_key_value("proj", "ll", out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
}
else {
if (sph_check != 2) {
G_set_key_value("proj", proj_out, out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
sprintf(tmp_buff, "%.10f", aa);
G_set_key_value("a", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", e2);
G_set_key_value("es", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", f);
G_set_key_value("f", tmp_buff, out_proj_keys);
}
else {
G_set_key_value("proj", proj_out, out_proj_keys);
/* G_set_key_value ("ellps", "sphere", out_proj_keys); */
sprintf(tmp_buff, "%.10f", radius);
G_set_key_value("a", tmp_buff, out_proj_keys);
G_set_key_value("es", "0.0", out_proj_keys);
G_set_key_value("f", "0.0", out_proj_keys);
}
for (i = 0;; i++) {
struct proj_parm *parm = &proj_parms[i];
struct proj_desc *desc;
if (!parm->name)
break;
desc = get_proj_desc(parm->name);
if (!desc)
break;
if (parm->ask) {
if (G_strcasecmp(desc->type, "bool") == 0) {
if (G_yes((char *)desc->desc, 0)) {
G_set_key_value(desc->key, "defined", out_proj_keys);
if (G_strcasecmp(parm->name, "SOUTH") == 0)
cellhd.zone = -abs(cellhd.zone);
}
}
else if (G_strcasecmp(desc->type, "lat") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 1, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "lon") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 0, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "float") == 0) {
double val;
while (!get_double(parm, desc, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
int val;
while (!get_int(parm, desc, &val)) ;
sprintf(tmp_buff, "%d", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "zone") == 0) {
if ((Out_proj == PROJECTION_UTM) && (old_zone != 0)) {
G_message(_("The UTM zone is now set to %d"),
old_zone);
if (!G_yes
(_("Do you want to change the UTM zone?"), 0)) {
G_message(_("UTM zone information has not been updated"));
zone = old_zone;
break;
}
else {
G_message(_("But if you change zone, all the existing "
"data will be interpreted by projection software. "
"GRASS will not automatically re-project or even "
"change the headers for existing maps."));
if (!G_yes
(_("Would you still like to change the UTM zone?"),
0)) {
zone = old_zone;
break;
}
}
} /* UTM */
while (!get_zone()) ;
sprintf(tmp_buff, "%d", zone);
G_set_key_value("zone", tmp_buff, out_proj_keys);
cellhd.zone = zone;
}
}
else if (parm->def_exists) {
/* don't ask, use the default */
if (G_strcasecmp(desc->type, "float") == 0 ||
G_strcasecmp(desc->type, "lat") == 0 ||
G_strcasecmp(desc->type, "lon") == 0) {
sprintf(tmp_buff, "%.10f", parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
sprintf(tmp_buff, "%d", (int)parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
}
} /* for OPTIONS */
}
/* create the PROJ_INFO & PROJ_UNITS files, if required */
G_write_key_value_file(path, out_proj_keys, &out_stat);
if (out_stat != 0) {
G_fatal_error(_("Error writing PROJ_INFO file <%s>"), path);
}
G_free_key_value(out_proj_keys);
if (exist)
G_free_key_value(old_proj_keys);
write_units:
G_file_name(path, "", UNIT_FILE, set_name);
/* if we got this far, the user
** already affirmed to write over old info
** so if units file is here, remove it.
*/
if (access(path, 0) == 0) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
leave(0);
{
in_unit_keys = G_create_key_value();
switch (Out_proj) {
case PROJECTION_UTM:
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
case PROJECTION_SP:
for (;;) {
do {
fprintf(stderr, "\nSpecify the correct units to use:\n");
fprintf(stderr, "Enter the corresponding number\n");
fprintf(stderr,
"1.\tUS Survey Foot (Default for State Plane 1927)\n");
fprintf(stderr, "2.\tInternational Foot\n");
fprintf(stderr, "3.\tMeter\n");
fprintf(stderr, ">");
} while (!G_gets(answer));
G_strip(answer);
if (strcmp(answer, "1") == 0) {
G_set_key_value("unit", "USfoot", in_unit_keys);
G_set_key_value("units", "USfeet", in_unit_keys);
G_set_key_value("meters", "0.30480060960121920243",
in_unit_keys);
break;
}
else if (strcmp(answer, "2") == 0) {
G_set_key_value("unit", "foot", in_unit_keys);
G_set_key_value("units", "feet", in_unit_keys);
G_set_key_value("meters", "0.3048", in_unit_keys);
break;
}
else if (strcmp(answer, "3") == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
}
else
fprintf(stderr, "\nInvalid Entry (number 1 - 3)\n");
}
break;
case PROJECTION_LL:
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
default:
if (G_strcasecmp(proj_out, "LL") != 0) {
fprintf(stderr, _("Enter plural form of units [meters]: "));
G_gets(answer);
if (strlen(answer) == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
else {
const struct proj_unit *unit;
G_strip(answer);
unit = get_proj_unit(answer);
if (unit) {
#ifdef FOO
if (G_strcasecmp(proj_out, "STP") == 0 &&
!strcmp(answer, "feet")) {
fprintf(stderr,
"%cPROJECTION 99 State Plane cannot be in FEET.\n",
7);
remove(path); /* remove file */
leave(SP_FATAL);
}
#endif
G_set_key_value("unit", unit->unit, in_unit_keys);
G_set_key_value("units", unit->units, in_unit_keys);
sprintf(buffb, "%.10f", unit->fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
else {
double unit_fact;
while (1) {
fprintf(stderr, _("Enter singular for unit: "));
G_gets(answer1);
G_strip(answer1);
if (strlen(answer1) > 0)
break;
}
while (1) {
fprintf(stderr,
_("Enter conversion factor from %s to meters: "),
answer);
G_gets(answer2);
G_strip(answer2);
if (!
(strlen(answer2) == 0 ||
(1 != sscanf(answer2, "%lf", &unit_fact))))
break;
}
G_set_key_value("unit", answer1, in_unit_keys);
G_set_key_value("units", answer, in_unit_keys);
sprintf(buffb, "%.10f", unit_fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
}
}
else {
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
} /* switch */
G_write_key_value_file(path, in_unit_keys, &out_stat);
if (out_stat != 0)
G_fatal_error(_("Error writing into UNITS output file <%s>"),
path);
G_free_key_value(in_unit_keys);
} /* if */
if (G__put_window(&cellhd, "", "DEFAULT_WIND") < 0)
G_fatal_error(_("Unable to write to DEFAULT_WIND region file"));
fprintf(stderr,
_("\nProjection information has been recorded for this location\n\n"));
if ((old_zone != zone) | (old_proj != cellhd.proj)) {
G_message(_("The geographic region information in WIND is now obsolete"));
G_message(_("Run g.region -d to update it"));
}
leave(0);
}
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);
}
GDALDataset *GRASSDataset::Open( GDALOpenInfo * poOpenInfo )
{
static int bDoneGISInit = FALSE;
char *pszMapset = NULL, *pszCell = NULL;
char **papszCells = NULL;
char **papszMapsets = NULL;
if( !bDoneGISInit )
{
G_set_error_routine( (GrassErrorHandler) Grass2CPLErrorHook );
G_gisinit_2( "GDAL", NULL, NULL, NULL );
}
/* -------------------------------------------------------------------- */
/* Check if this is a valid grass cell. */
/* -------------------------------------------------------------------- */
if( G_check_cell( poOpenInfo->pszFilename, &pszMapset, &pszCell ) )
{
papszCells = CSLAddString( papszCells, pszCell );
papszMapsets = CSLAddString( papszMapsets, pszMapset );
G_free( pszMapset );
G_free( pszCell );
}
/* -------------------------------------------------------------------- */
/* Check if this is a valid GRASS imagery group. */
/* -------------------------------------------------------------------- */
else if( I_check_group( poOpenInfo->pszFilename, &pszMapset, &pszCell ) )
{
struct Ref ref;
I_init_group_ref( &ref );
I_get_group_ref( pszCell, &ref );
for( int iRef = 0; iRef < ref.nfiles; iRef++ )
{
papszCells = CSLAddString( papszCells, ref.file[iRef].name );
papszMapsets = CSLAddString( papszMapsets, ref.file[iRef].mapset );
}
I_free_group_ref( &ref );
G_free( pszMapset );
G_free( pszCell );
}
else
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GRASSDataset *poDS;
poDS = new GRASSDataset();
/* notdef: should only allow read access to an existing cell, right? */
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
struct Cell_head sCellInfo;
if( G_get_cellhd( papszCells[0], papszMapsets[0], &sCellInfo ) != 0 )
{
/* notdef: report failure. */
return NULL;
}
poDS->nRasterXSize = sCellInfo.cols;
poDS->nRasterYSize = sCellInfo.rows;
G_set_window( &sCellInfo );
poDS->adfGeoTransform[0] = sCellInfo.west;
poDS->adfGeoTransform[1] = sCellInfo.ew_res;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = sCellInfo.north;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -1 * sCellInfo.ns_res;
/* -------------------------------------------------------------------- */
/* Try to get a projection definition. */
/* -------------------------------------------------------------------- */
char *pszProj4;
pszProj4 = G_get_cell_as_proj4( papszCells[0], papszMapsets[0] );
if( pszProj4 != NULL )
{
OGRSpatialReference oSRS;
if( oSRS.importFromProj4( pszProj4 ) == OGRERR_NONE )
{
oSRS.exportToWkt( &(poDS->pszProjection) );
}
G_free( pszProj4 );
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; papszCells[iBand] != NULL; iBand++ )
{
poDS->SetBand( iBand+1,
new GRASSRasterBand( poDS, iBand+1,
papszMapsets[iBand],
papszCells[iBand] ) );
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError( CE_Failure, CPLE_NotSupported,
"The GRASS driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
return poDS;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,query";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
x = atof( coor_opt->answers[0] );
y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols ) col--;
if ( row == window.rows ) row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:null\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int GRASS_LIB_EXPORT QgsGrassGisLib::G__gisinit( const char * version, const char * programName )
{
Q_UNUSED( version );
// We use this function also to init our fake lib
QgsDebugMsg( QString( "version = %1 programName = %2" ).arg( version ).arg( programName ) );
// Init providers path
int argc = 1;
char **argv = new char*[1];
argv[0] = qstrdup( programName );
// unfortunately it seems impossible to get QGIS prefix
// QCoreApplication::applicationDirPath() returns $GISBASE/lib on Linux
#if 0
QDir dir( QCoreApplication::applicationDirPath() );
dir.cdUp();
QString prefixPath = dir.absolutePath();
#endif
//QCoreApplication app( argc, argv ); // to init paths
QgsApplication app( argc, argv, false ); // to init paths
// TODO: WCS (network) fails with: "QTimer can only be used with threads started
// with QThread" because QCoreApplication::exec() was not called, but
// QCoreApplication::exec() goes to loop. We need to start QThread somehow.
// QGIS_PREFIX_PATH should be loaded by QgsApplication
//QString prefixPath = getenv( "QGIS_PREFIX_PATH" );
//if ( prefixPath.isEmpty() )
//{
// fatal( "Cannot get QGIS_PREFIX_PATH" );
//}
//QgsApplication::setPrefixPath( prefixPath, true );
QgsDebugMsg( "Plugin path: " + QgsApplication::pluginPath() );
QgsProviderRegistry::instance( QgsApplication::pluginPath() );
QgsDebugMsg( "qgisSettingsDirPath = " + app.qgisSettingsDirPath() );
G_set_error_routine( &errorRoutine );
G_set_gisrc_mode( G_GISRC_MODE_MEMORY );
G_setenv( "OVERWRITE", "1" ); // avoid checking if map exists
G_suppress_masking();
#if GRASS_VERSION_MAJOR<6 || (GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR <= 4)
G__init_null_patterns();
#endif
// Read projection if set
//mCrs.createFromOgcWmsCrs( "EPSG:900913" );
QString crsStr = getenv( "QGIS_GRASS_CRS" );
QgsDebugMsg( "Setting CRS to " + crsStr );
if ( !crsStr.isEmpty() )
{
if ( !mCrs.createFromProj4( crsStr ) )
{
fatal( "Cannot create CRS from QGIS_GRASS_CRS: " + crsStr );
}
//TODO: createFromProj4 used to save to the user database any new CRS
// this behavior was changed in order to separate creation and saving.
// Not sure if it necessary to save it here, should be checked by someone
// familiar with the code (should also give a more descriptive name to the generated CRS)
if ( mCrs.srsid() == 0 )
{
QString myName = QString( " * %1 (%2)" )
.arg( QObject::tr( "Generated CRS", "A CRS automatically generated from layer info get this prefix for description" ) )
.arg( mCrs.toProj4() );
mCrs.saveAsUserCRS( myName );
}
}
mDistanceArea.setSourceCrs( mCrs.srsid() );
// Read region fron environment variable
// QGIS_GRASS_REGION=west,south,east,north,cols,rows
#if 0
QString regionStr = getenv( "QGIS_GRASS_REGION" );
QStringList regionList = regionStr.split( "," );
if ( regionList.size() != 6 )
{
fatal( "Cannot read region from QGIS_GRASS_REGION environment variable" );
}
double xMin, yMin, xMax, yMax;
int cols, rows;
bool xMinOk, yMinOk, xMaxOk, yMaxOk, colsOk, rowsOk;
xMin = regionList.value( 0 ).toDouble( &xMinOk );
yMin = regionList.value( 1 ).toDouble( &yMinOk );
xMax = regionList.value( 2 ).toDouble( &xMaxOk );
yMax = regionList.value( 3 ).toDouble( &yMaxOk );
cols = regionList.value( 4 ).toInt( &colsOk );
rows = regionList.value( 5 ).toInt( &rowsOk );
if ( !xMinOk || !yMinOk || !xMaxOk || !yMaxOk || !colsOk || !rowsOk )
{
fatal( "Cannot parse QGIS_GRASS_REGION" );
}
struct Cell_head window;
window.west = xMin;
window.south = yMin;
window.east = xMax;
window.north = yMax;
window.rows = rows;
window.cols = cols;
char* err = G_adjust_Cell_head( &window, 1, 1 );
if ( err )
{
fatal( QString( err ) );
}
G_set_window( &window );
#endif
QString regionStr = getenv( "GRASS_REGION" );
if ( regionStr.isEmpty() )
{
fatal( "GRASS_REGION environment variable not set" );
}
QgsDebugMsg( "Getting region via true lib from GRASS_REGION: " + regionStr );
// GRASS true lib reads GRASS_REGION environment variable
G_get_window( &mWindow );
mExtent = QgsRectangle( mWindow.west, mWindow.south, mWindow.east, mWindow.north );
mRows = mWindow.rows;
mColumns = mWindow.cols;
mXRes = mExtent.width() / mColumns;
mYRes = mExtent.height() / mColumns;
QgsDebugMsg( "End" );
return 0;
}
GRASSRasterBand::GRASSRasterBand( GRASSDataset *poDS, int nBand,
const char * pszMapset,
const char * pszCellName )
{
struct Cell_head sCellInfo;
// Note: GISDBASE, LOCATION_NAME ans MAPSET was set in GRASSDataset::Open
this->poDS = poDS;
this->nBand = nBand;
this->valid = false;
this->pszCellName = G_store ( (char *) pszCellName );
this->pszMapset = G_store ( (char *) pszMapset );
G_get_cellhd( (char *) pszCellName, (char *) pszMapset, &sCellInfo );
nGRSType = G_raster_map_type( (char *) pszCellName, (char *) pszMapset );
/* -------------------------------------------------------------------- */
/* Get min/max values. */
/* -------------------------------------------------------------------- */
struct FPRange sRange;
if( G_read_fp_range( (char *) pszCellName, (char *) pszMapset,
&sRange ) == -1 )
{
bHaveMinMax = FALSE;
}
else
{
bHaveMinMax = TRUE;
G_get_fp_range_min_max( &sRange, &dfCellMin, &dfCellMax );
}
/* -------------------------------------------------------------------- */
/* Setup band type, and preferred nodata value. */
/* -------------------------------------------------------------------- */
// Negative values are also (?) stored as 4 bytes (format = 3)
// => raster with format < 3 has only positive values
// GRASS modules usually do not waste space and only the format necessary to keep
// full raster values range is used -> no checks if shorter type could be used
if( nGRSType == CELL_TYPE ) {
if ( sCellInfo.format == 0 ) { // 1 byte / cell -> possible range 0,255
if ( bHaveMinMax && dfCellMin > 0 ) {
this->eDataType = GDT_Byte;
dfNoData = 0.0;
} else if ( bHaveMinMax && dfCellMax < 255 ) {
this->eDataType = GDT_Byte;
dfNoData = 255.0;
} else { // maximum is not known or full range is used
this->eDataType = GDT_UInt16;
dfNoData = 256.0;
}
nativeNulls = false;
} else if ( sCellInfo.format == 1 ) { // 2 bytes / cell -> possible range 0,65535
if ( bHaveMinMax && dfCellMin > 0 ) {
this->eDataType = GDT_UInt16;
dfNoData = 0.0;
} else if ( bHaveMinMax && dfCellMax < 65535 ) {
this->eDataType = GDT_UInt16;
dfNoData = 65535;
} else { // maximum is not known or full range is used
CELL cval;
this->eDataType = GDT_Int32;
G_set_c_null_value ( &cval, 1);
dfNoData = (double) cval;
nativeNulls = true;
}
nativeNulls = false;
} else { // 3-4 bytes
CELL cval;
this->eDataType = GDT_Int32;
G_set_c_null_value ( &cval, 1);
dfNoData = (double) cval;
nativeNulls = true;
}
}
else if( nGRSType == FCELL_TYPE ) {
FCELL fval;
this->eDataType = GDT_Float32;
G_set_f_null_value ( &fval, 1);
dfNoData = (double) fval;
nativeNulls = true;
}
else if( nGRSType == DCELL_TYPE )
{
DCELL dval;
this->eDataType = GDT_Float64;
G_set_d_null_value ( &dval, 1);
dfNoData = (double) dval;
nativeNulls = true;
}
nBlockXSize = poDS->nRasterXSize;;
nBlockYSize = 1;
G_set_window( &(((GRASSDataset *)poDS)->sCellInfo) );
if ( (hCell = G_open_cell_old((char *) pszCellName, (char *) pszMapset)) < 0 ) {
CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster '%s'", pszCellName );
return;
}
G_copy((void *) &sOpenWindow, (void *) &(((GRASSDataset *)poDS)->sCellInfo), sizeof(struct Cell_head));
/* -------------------------------------------------------------------- */
/* Do we have a color table? */
/* -------------------------------------------------------------------- */
poCT = NULL;
if( G_read_colors( (char *) pszCellName, (char *) pszMapset, &sGrassColors ) == 1 )
{
int maxcolor;
CELL min, max;
G_get_color_range ( &min, &max, &sGrassColors);
if ( bHaveMinMax ) {
if ( max < dfCellMax ) {
maxcolor = max;
} else {
maxcolor = (int) ceil ( dfCellMax );
}
if ( maxcolor > GRASS_MAX_COLORS ) {
maxcolor = GRASS_MAX_COLORS;
CPLDebug( "GRASS", "Too many values, color table cut to %d entries.", maxcolor );
}
} else {
if ( max < GRASS_MAX_COLORS ) {
maxcolor = max;
} else {
maxcolor = GRASS_MAX_COLORS;
CPLDebug( "GRASS", "Too many values, color table set to %d entries.", maxcolor );
}
}
poCT = new GDALColorTable();
for( int iColor = 0; iColor <= maxcolor; iColor++ )
{
int nRed, nGreen, nBlue;
GDALColorEntry sColor;
#if GRASS_VERSION_MAJOR >= 7
if( Rast_get_c_color( &iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) )
#else
if( G_get_color( iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) )
#endif
{
sColor.c1 = nRed;
sColor.c2 = nGreen;
sColor.c3 = nBlue;
sColor.c4 = 255;
poCT->SetColorEntry( iColor, &sColor );
}
else
{
sColor.c1 = 0;
sColor.c2 = 0;
sColor.c3 = 0;
sColor.c4 = 0;
poCT->SetColorEntry( iColor, &sColor );
}
}
/* Create metadata enries for color table rules */
char key[200], value[200];
int rcount = G_colors_count ( &sGrassColors );
sprintf ( value, "%d", rcount );
this->SetMetadataItem( "COLOR_TABLE_RULES_COUNT", value );
/* Add the rules in reverse order */
for ( int i = rcount-1; i >= 0; i-- ) {
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
G_get_f_color_rule ( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &sGrassColors, i );
sprintf ( key, "COLOR_TABLE_RULE_RGB_%d", rcount-i-1 );
sprintf ( value, "%e %e %d %d %d %d %d %d", val1, val2, r1, g1, b1, r2, g2, b2 );
this->SetMetadataItem( key, value );
}
} else {
this->SetMetadataItem( "COLOR_TABLE_RULES_COUNT", "0" );
}
this->valid = true;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt, *north_opt, *south_opt, *east_opt, *west_opt, *rows_opt, *cols_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,size,query,info,colors,stats";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
north_opt = G_define_option();
north_opt->key = "north";
north_opt->type = TYPE_STRING;
south_opt = G_define_option();
south_opt->key = "south";
south_opt->type = TYPE_STRING;
east_opt = G_define_option();
east_opt->key = "east";
east_opt->type = TYPE_STRING;
west_opt = G_define_option();
west_opt->key = "west";
west_opt->type = TYPE_STRING;
rows_opt = G_define_option();
rows_opt->key = "rows";
rows_opt->type = TYPE_INTEGER;
cols_opt = G_define_option();
cols_opt->key = "cols";
cols_opt->type = TYPE_INTEGER;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster width and height
else if ( strcmp( "size", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%d,%d", window.cols, window.rows );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster informations
else if ( strcmp( "info", info_opt->answer ) == 0 )
{
struct FPRange range;
double zmin, zmax;
// Data type
RASTER_MAP_TYPE raster_type = G_raster_map_type( rast_opt->answer, "" );
fprintf( stdout, "TYPE:%d\n", raster_type );
// Statistics
if ( G_read_fp_range( rast_opt->answer, "", &range ) < 0 )
{
G_fatal_error(( "Unable to read range file" ) );
}
G_get_fp_range_min_max( &range, &zmin, &zmax );
fprintf( stdout, "MIN_VALUE:%.17e\n", zmin );
fprintf( stdout, "MAX_VALUE:%.17e\n", zmax );
}
else if ( strcmp( "colors", info_opt->answer ) == 0 )
{
// Color table
struct Colors colors;
int i, ccount;
if ( G_read_colors( rast_opt->answer, "", &colors ) == 1 )
{
//int maxcolor;
//CELL min, max;
//G_get_color_range ( &min, &max, &colors);
ccount = G_colors_count( &colors );
for ( i = ccount - 1; i >= 0; i-- )
{
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
G_get_f_color_rule( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &colors, i );
fprintf( stdout, "%.17e %.17e %d %d %d %d %d %d\n", val1, val2, r1, g1, b1, r2, g2, b2 );
}
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
//x = atof( coor_opt->answers[0] );
//y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
char buff[101];
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
// wait for coors from stdin
while ( fgets( buff, 100, stdin ) != 0 )
{
if ( sscanf( buff, "%lf%lf", &x, &y ) != 2 )
{
fprintf( stdout, "value:error\n" );
}
else
{
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols )
col--;
if ( row == window.rows )
row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:out\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
}
fflush( stdout );
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "stats", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
int ncols, nrows;
int row, col;
void *ptr;
double val;
double min = DBL_MAX;
double max = -DBL_MAX;
double sum = 0; // sum of values
int count = 0; // count of non null values
double mean = 0;
double squares_sum = 0; // sum of squares
double stdev = 0; // standard deviation
G_get_cellhd( rast_opt->answer, "", &window );
window.north = atof( north_opt->answer );
window.south = atof( south_opt->answer );
window.east = atof( east_opt->answer );
window.west = atof( west_opt->answer );
window.rows = ( int ) atoi( rows_opt->answer );
window.cols = ( int ) atoi( cols_opt->answer );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
ncols = G_window_cols();
nrows = G_window_rows();
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
// Calc stats is very slow for large rasters -> prefer optimization for speed over
// code length and readability (which is not currently true)
for ( row = 0; row < nrows; row++ )
{
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
for ( col = 0; col < ncols; col++ )
{
if ( rast_type == CELL_TYPE )
{
val = cell[col];
ptr = &( cell[col] );
}
else
{
val = dcell[col];
ptr = &( dcell[col] );
}
if ( ! G_is_null_value( ptr, rast_type ) )
{
if ( val < min ) min = val;
if ( val > max ) max = val;
sum += val;
count++;
squares_sum += pow( val, 2 );
}
}
}
mean = sum / count;
squares_sum -= count * pow( mean, 2 );
stdev = sqrt( squares_sum / ( count - 1 ) );
fprintf( stdout, "MIN:%.17e\n", min );
fprintf( stdout, "MAX:%.17e\n", max );
fprintf( stdout, "SUM:%.17e\n", sum );
fprintf( stdout, "MEAN:%.17e\n", mean );
fprintf( stdout, "COUNT:%d\n", count );
fprintf( stdout, "STDEV:%.17e\n", stdev );
fprintf( stdout, "SQSUM:%.17e\n", squares_sum );
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int make_new_cell_layer(void)
{
struct History hist;
void *rast;
int cellfd;
int tmpfd;
int row;
/* open the new raster map to contain the edited version of
the original cell layer. open our temporary file for read
and copy its contents to the layer */
G_set_window(&real_window);
cellfd = G_open_raster_new(new_name, map_type);
tmpfd = open(tempfile, 0);
lseek(tmpfd, 0L, 0);
rast = G_allocate_raster_buf(map_type);
fprintf(stderr, "\n +-------------------------------------------+\n");
fprintf(stderr, " | Saving new cell layer |\n");
fprintf(stderr, " +---------------------------------------");
for (row = 0; row < real_nrows; row++) {
if (read(tmpfd, rast, real_ncols * cellsize) !=
(real_ncols * cellsize))
error(1, "error writing raster map during copy");
G_put_raster_row(cellfd, rast, map_type);
G_percent(row, real_nrows, 5);
}
G_percent(100, 100, 5);
fprintf(stderr, "\n");
close(tmpfd);
G_close_cell(cellfd);
unlink(tempfile);
/* create and write cat, colr, quant, and hist support files
for the newly created layer */
if (colr_ok) {
G_write_colors(new_name, user_mapset, &colr);
G_free_colors(&colr);
colr_ok = 0;
}
if (cats_ok) {
cats.num = G_number_of_cats(new_name, user_mapset);
G_write_cats(new_name, &cats);
G_free_cats(&cats);
cats_ok = 0;
}
if (quant_ok) {
G_write_quant(new_name, G_mapset(), &quant);
G_quant_free(&quant);
cats_ok = 0;
}
/* construct some history information */
sprintf(hist.mapid, "%s", G_date());
sprintf(hist.title, "%s", new_name);
sprintf(hist.mapset, "%s", user_mapset);
sprintf(hist.creator, "%s", G_whoami());
sprintf(hist.maptype, "cell");
sprintf(hist.edhist[0],
"Generated by d.rast.edit from original raster map");
sprintf(hist.edhist[1], " %s in mapset %s ", orig_name, orig_mapset);
hist.edlinecnt = 2;
/* write history */
if (G_write_history(new_name, &hist) == -1)
error(0, "could not write history");
return 0;
}
int rectify(char *name, char *mapset, struct cache *ebuffer,
double aver_z, char *result, char *interp_method)
{
struct Cell_head cellhd;
int ncols, nrows;
int row, col;
double row_idx, col_idx;
int infd, outfd;
RASTER_MAP_TYPE map_type;
int cell_size;
void *trast, *tptr;
double n1, e1, z1;
double nx, ex, nx1, ex1, zx1;
struct cache *ibuffer;
select_current_env();
Rast_get_cellhd(name, mapset, &cellhd);
/* open the file to be rectified
* set window to cellhd first to be able to read file exactly
*/
Rast_set_input_window(&cellhd);
infd = Rast_open_old(name, mapset);
map_type = Rast_get_map_type(infd);
cell_size = Rast_cell_size(map_type);
ibuffer = readcell(infd, seg_mb_img, 0);
Rast_close(infd); /* (pmx) 17 april 2000 */
G_message(_("Rectify <%s@%s> (location <%s>)"),
name, mapset, G_location());
select_target_env();
G_set_window(&target_window);
G_message(_("into <%s@%s> (location <%s>) ..."),
result, G_mapset(), G_location());
nrows = target_window.rows;
ncols = target_window.cols;
if (strcmp(interp_method, "nearest") != 0) {
map_type = DCELL_TYPE;
cell_size = Rast_cell_size(map_type);
}
/* open the result file into target window
* this open must be first since we change the window later
* raster maps open for writing are not affected by window changes
* but those open for reading are
*/
outfd = Rast_open_new(result, map_type);
trast = Rast_allocate_output_buf(map_type);
for (row = 0; row < nrows; row++) {
n1 = target_window.north - (row + 0.5) * target_window.ns_res;
G_percent(row, nrows, 2);
Rast_set_null_value(trast, ncols, map_type);
tptr = trast;
for (col = 0; col < ncols; col++) {
DCELL *zp = CPTR(ebuffer, row, col);
e1 = target_window.west + (col + 0.5) * target_window.ew_res;
/* if target cell has no elevation, set to aver_z */
if (Rast_is_d_null_value(zp)) {
G_warning(_("No elevation available at row = %d, col = %d"), row, col);
z1 = aver_z;
}
else
z1 = *zp;
/* target coordinates e1, n1 to photo coordinates ex1, nx1 */
I_ortho_ref(e1, n1, z1, &ex1, &nx1, &zx1, &group.camera_ref,
group.XC, group.YC, group.ZC, group.M);
G_debug(5, "\t\tAfter ortho ref (photo cords): ex = %f \t nx = %f",
ex1, nx1);
/* photo coordinates ex1, nx1 to image coordinates ex, nx */
I_georef(ex1, nx1, &ex, &nx, group.E21, group.N21, 1);
G_debug(5, "\t\tAfter geo ref: ex = %f \t nx = %f", ex, nx);
/* convert to row/column indices of source raster */
row_idx = (cellhd.north - nx) / cellhd.ns_res;
col_idx = (ex - cellhd.west) / cellhd.ew_res;
/* resample data point */
interpolate(ibuffer, tptr, map_type, &row_idx, &col_idx, &cellhd);
tptr = G_incr_void_ptr(tptr, cell_size);
}
Rast_put_row(outfd, trast, map_type);
}
G_percent(1, 1, 1);
Rast_close(outfd); /* (pmx) 17 april 2000 */
G_free(trast);
close(ibuffer->fd);
release_cache(ibuffer);
Rast_get_cellhd(result, G_mapset(), &cellhd);
if (cellhd.proj == 0) { /* x,y imagery */
cellhd.proj = target_window.proj;
cellhd.zone = target_window.zone;
}
if (target_window.proj != cellhd.proj) {
cellhd.proj = target_window.proj;
G_warning(_("Raster map <%s@%s>: projection don't match current settings"),
name, mapset);
}
if (target_window.zone != cellhd.zone) {
cellhd.zone = target_window.zone;
G_warning(_("Raster map <%s@%s>: zone don't match current settings"),
name, mapset);
}
select_current_env();
return 1;
}
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);
}
int exec_rectify(char *extension, char *interp_method, char *angle_map)
{
char *name;
char *mapset;
char *result;
char *type = "raster";
int n;
struct Colors colr;
struct Categories cats;
struct History hist;
int colr_ok, cats_ok;
long start_time, rectify_time;
double aver_z;
int elevfd;
struct cache *ebuffer;
G_debug(1, "Open elevation raster: ");
/* open elevation raster */
select_target_env();
G_set_window(&target_window);
G_debug(1, "target window: rs=%d cs=%d n=%f s=%f w=%f e=%f\n",
target_window.rows, target_window.cols, target_window.north,
target_window.south, target_window.west, target_window.east);
elevfd = Rast_open_old(elev_name, elev_mapset);
if (elevfd < 0) {
G_fatal_error(_("Could not open elevation raster"));
return 1;
}
ebuffer = readcell(elevfd, seg_mb_elev, 1);
select_target_env();
Rast_close(elevfd);
/* get an average elevation of the control points */
/* this is used only if target cells have no elevation */
get_aver_elev(&group.control_points, &aver_z);
G_message("-----------------------------------------------");
/* rectify each file */
for (n = 0; n < group.group_ref.nfiles; n++) {
if (!ref_list[n])
continue;
name = group.group_ref.file[n].name;
mapset = group.group_ref.file[n].mapset;
result =
G_malloc(strlen(group.group_ref.file[n].name) + strlen(extension) + 1);
strcpy(result, group.group_ref.file[n].name);
strcat(result, extension);
G_debug(2, "ORTHO RECTIFYING:");
G_debug(2, "NAME %s", name);
G_debug(2, "MAPSET %s", mapset);
G_debug(2, "RESULT %s", result);
G_debug(2, "select_current_env...");
select_current_env();
cats_ok = Rast_read_cats(name, mapset, &cats) >= 0;
colr_ok = Rast_read_colors(name, mapset, &colr) > 0;
/* Initialze History */
if (Rast_read_history(name, mapset, &hist) < 0)
Rast_short_history(result, type, &hist);
G_debug(2, "reading was fine...");
time(&start_time);
G_debug(2, "Starting the rectification...");
if (rectify(name, mapset, ebuffer, aver_z, result, interp_method)) {
G_debug(2, "Done. Writing results...");
select_target_env();
if (cats_ok) {
Rast_write_cats(result, &cats);
Rast_free_cats(&cats);
}
if (colr_ok) {
Rast_write_colors(result, G_mapset(), &colr);
Rast_free_colors(&colr);
}
/* Write out History */
Rast_command_history(&hist);
Rast_write_history(result, &hist);
select_current_env();
time(&rectify_time);
report(rectify_time - start_time, 1);
}
else
report((long)0, 0);
G_free(result);
}
close(ebuffer->fd);
release_cache(ebuffer);
if (angle_map) {
camera_angle(angle_map);
}
return 0;
}
int main( int argc, char **argv )
{
char *mapset = 0;
char *name = 0;
struct GModule *module;
struct Option *map;
struct Option *win;
struct Option *format;
struct Cell_head window;
RASTER_MAP_TYPE raster_type;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Output raster map layers in a format suitable for display in QGIS" );
map = G_define_standard_option( G_OPT_R_MAP );
map->description = ( "Raster map to be displayed" );
format = G_define_option();
format->key = "format";
format->type = TYPE_STRING;
format->description = "format";
format->options = "color,value";
win = G_define_option();
win->key = "window";
win->type = TYPE_DOUBLE;
win->multiple = YES;
win->description = "xmin,ymin,xmax,ymax,ncols,nrows";
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
/* Make sure map is available */
#if GRASS_VERSION_MAJOR < 7
mapset = G_find_cell2( name, "" );
if ( !mapset )
G_fatal_error( ( "Raster map <%s> not found" ), name );
#else
mapset = "";
#endif
/* It can happen that GRASS data set is 'corrupted' and zone differs in WIND and
* cellhd, and G_open_cell_old fails, so it is better to read window from map */
/* G_get_window( &window ); */
G_get_cellhd( name, mapset, &window );
window.west = atof( win->answers[0] );
window.south = atof( win->answers[1] );
window.east = atof( win->answers[2] );
window.north = atof( win->answers[3] );
window.cols = atoi( win->answers[4] );
window.rows = atoi( win->answers[5] );
G_adjust_Cell_head( &window, 1, 1 );
G_set_window( &window );
G_suppress_masking(); // must be after G_set_window()
raster_type = G_raster_map_type( name, "" );
display( name, mapset, raster_type, format->answer );
exit( EXIT_SUCCESS );
}
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);
}
/*
* main function
*/
int main(int argc, char *argv[])
{
/* struct Cell_head window; database window */
struct Cell_head cellhd; /* it stores region information,
and header information of rasters */
char *name, *name2; /* input raster name */
char *result; /* output raster name */
char *mapset; /* mapset name */
void *inrast; /* input buffer */
unsigned char *outrast; /* output buffer */
int nrows, ncols;
int row, col;
int infd, outfd; /* file descriptor */
int verbose;
struct History history; /* holds meta-data (title, comments,..) */
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *input, *output, *input2; /* options */
FILE *in; /*file for Path loss factors*/
struct Flag *flag1; /* flags */
char buffer_out[1000];
strcpy(buffer_out,getenv("GISBASE"));
strcat(buffer_out,"/etc/radio_coverage/lossfactors_new.txt");
/*G_message(_("1!! Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);
buffer_out=strcat(buffer_path,buffer_path1);
G_message(_("Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);*/
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
module->keywords = _("raster, clutter");
module->description = _("Clutter convert module");
/* Define the different options as defined in gis.h */
input = G_define_standard_option(G_OPT_R_INPUT);
input2 = G_define_standard_option(G_OPT_F_INPUT);
input2->key = "Path_loss_values";
input2->type = TYPE_STRING;
input2->required = YES;
input2->answer = buffer_out;//getenv("GISBASE"); //strcat(buffer_path1,(char *)getenv("GISBASE"));//,"/etc/radio_coverage");
input2->gisprompt = "old_file,file,input";
input2->description = _("Path loss factors for land usage");
/* Define the different flags */
flag1 = G_define_flag();
flag1->key = 'o';
flag1->description = _("Old_Cipher");
output = G_define_standard_option(G_OPT_R_OUTPUT);
/* options and flags parser */
if (G_parser(argc, argv))
{
exit(EXIT_FAILURE);
}
/*G_message(_("1!! Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);
strcat(buffer_path,buffer_path1);
G_message(_("Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);
input2->answer = buffer_path;//getenv("GISBASE"); //strcat(buffer_path1,(char *)getenv("GISBASE"));//,"/etc/radio_coverage");*/
/* stores options and flags to variables */
name = input->answer;
name2 = input2->answer;
result = output->answer;
verbose = (flag1->answer);
G_message(_("Verbose: %d"),verbose);
/* returns NULL if the map was not found in any mapset,
* mapset name otherwise */
//G_message(_("3_START"));
mapset = G_find_cell2(name, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), name);
if (G_legal_filename(result) < 0)
G_fatal_error(_("<%s> is an illegal file name"), result);
/* G_open_cell_old - returns file destriptor (>0) */
if ((infd = G_open_cell_old(name, mapset)) < 0)
G_fatal_error(_("Unable to open raster map <%s>"), name);
/* controlling, if we can open input raster */
if (G_get_cellhd(name, mapset, &cellhd) < 0)
G_fatal_error(_("Unable to read file header of <%s>"), name);
G_debug(3, "number of rows %d", cellhd.rows);
G_set_window(&cellhd);
G_get_set_window(&cellhd);
/* Allocate input buffer */
inrast = G_allocate_raster_buf(FCELL_TYPE);
/* Allocate output buffer, use input map data_type */
nrows = G_window_rows();
ncols = G_window_cols();
outrast = G_allocate_raster_buf(FCELL_TYPE);
G_message(_("nrows %d and ncols %d"),nrows,ncols);
/* controlling, if we can write the raster */
if ((outfd = G_open_raster_new(result, FCELL_TYPE)) < 0)
G_fatal_error(_("Unable to create raster map <%s>"), result);
/* do Clutter Convert */
/* open file for model tuning parameters*/
char fileName[150];
strcpy (fileName, name2);
//G_message(_("Path: %s"),name2);
if( (in = fopen(fileName,"r")) == NULL )
G_fatal_error(_("Unable to open file <%s>"), fileName);
char buffer[256];
double terr_path_loss[100];
int counter=0;
fgets (buffer, 250, in);
while(fgets(buffer,250,in)!=NULL){
sscanf(buffer,"%lf %lf", &terr_path_loss[counter]);
counter++;
}
int cipher_cont=0;
/* old or new clutter */
if (verbose == 1)
{
cipher_cont=1;
G_message(_("Parameter UR: %f, GP: %f, RP: %f, GI: %f, GL: %f, GM: %f, GR: %f, VO: %f, KM: %f, OD: %f"), terr_path_loss[0], terr_path_loss[1], terr_path_loss[2], terr_path_loss[3], terr_path_loss[4], terr_path_loss[5], terr_path_loss[6], terr_path_loss[7], terr_path_loss[8], terr_path_loss[9]);
}
else if (verbose == 0)
{
cipher_cont=11;
G_message(_("Parameter UR1: %f, UR2: %f, UR3: %f, UR4: %f, UR5: %f, GI: %f, GL: %f, GM: %f, GR: %f, VO: %f, KM: %f, OD: %f"), terr_path_loss[0], terr_path_loss[1], terr_path_loss[2], terr_path_loss[3], terr_path_loss[4], terr_path_loss[5], terr_path_loss[6], terr_path_loss[7], terr_path_loss[8], terr_path_loss[9], terr_path_loss[10], terr_path_loss[11]);
}
G_message(_("Counter: %d"),counter);
G_message(_("cipher_cont: %d"),cipher_cont);
G_message(_("START"));
/* for each row */
for (row = 0; row < nrows; row++)
{
FCELL f_in, f_out;
/* read input map */
if (G_get_raster_row(infd, inrast, row, FCELL_TYPE) < 0)
G_fatal_error(_("Unable to read raster map <%s> row %d"), name, row);
/* process the data */
for (col = 0; col < ncols; col++)
{
f_in = ((FCELL *) inrast)[col];
//G_message(_("Input data: %d"),(int)f_in);
f_out = terr_path_loss[(int)f_in-cipher_cont];
//G_message(_("Output data: %f"),(double)f_out);
((FCELL *) outrast)[col] = f_out;
}
/* write raster row to output raster map */
if (G_put_raster_row(outfd, outrast, FCELL_TYPE) < 0)
G_fatal_error(_("Failed writing raster map <%s>"), result);
}
//G_message(_("END_clutconvert_test"));
G_message(_("END"));
/* memory cleanup */
G_free(inrast);
G_free(outrast);
/* closing raster maps */
G_close_cell(infd);
G_close_cell(outfd);
/* add command line incantation to history file */
G_short_history(result, "raster", &history);
G_command_history(&history);
G_write_history(result, &history);
exit(EXIT_SUCCESS);
}
int main( int argc, char **argv )
{
char *name = nullptr;
struct Option *map;
struct Cell_head window;
G_gisinit( argv[0] );
G_define_module();
map = G_define_standard_option( G_OPT_R_OUTPUT );
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
#ifdef Q_OS_WIN
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
//setvbuf( stdin, NULL, _IONBF, BUFSIZ );
// setting _IONBF on stdout works on windows correctly, data written immediately even without fflush(stdout)
//setvbuf( stdout, NULL, _IONBF, BUFSIZ );
#endif
QgsGrassDataFile stdinFile;
stdinFile.open( stdin );
QDataStream stdinStream( &stdinFile );
QFile stdoutFile;
stdoutFile.open( stdout, QIODevice::WriteOnly | QIODevice::Unbuffered );
QDataStream stdoutStream( &stdoutFile );
qint32 proj, zone;
stdinStream >> proj >> zone;
QgsRectangle extent;
qint32 rows, cols;
stdinStream >> extent >> cols >> rows;
checkStream( stdinStream );
QString err = QgsGrass::setRegion( &window, extent, rows, cols );
if ( !err.isEmpty() )
{
G_fatal_error( "Cannot set region: %s", err.toUtf8().constData() );
}
window.proj = ( int ) proj;
window.zone = ( int ) zone;
G_set_window( &window );
Qgis::DataType qgis_type;
qint32 type;
stdinStream >> type;
checkStream( stdinStream );
qgis_type = ( Qgis::DataType )type;
RASTER_MAP_TYPE grass_type;
switch ( qgis_type )
{
case Qgis::Int32:
grass_type = CELL_TYPE;
break;
case Qgis::Float32:
grass_type = FCELL_TYPE;
break;
case Qgis::Float64:
grass_type = DCELL_TYPE;
break;
default:
G_fatal_error( "QGIS data type %d not supported", qgis_type );
return 1;
}
cf = Rast_open_new( name, grass_type );
if ( cf < 0 )
{
G_fatal_error( "Unable to create raster map <%s>", name );
return 1;
}
void *buf = Rast_allocate_buf( grass_type );
int expectedSize = cols * QgsRasterBlock::typeSize( qgis_type );
bool isCanceled = false;
QByteArray byteArray;
for ( int row = 0; row < rows; row++ )
{
stdinStream >> isCanceled;
checkStream( stdinStream );
if ( isCanceled )
{
break;
}
double noDataValue;
stdinStream >> noDataValue;
stdinStream >> byteArray;
checkStream( stdinStream );
if ( byteArray.size() != expectedSize )
{
G_fatal_error( "Wrong byte array size, expected %d bytes, got %d, row %d / %d", expectedSize, byteArray.size(), row, rows );
return 1;
}
qint32 *cell = nullptr;
float *fcell = nullptr;
double *dcell = nullptr;
if ( grass_type == CELL_TYPE )
cell = ( qint32 * ) byteArray.data();
else if ( grass_type == FCELL_TYPE )
fcell = ( float * ) byteArray.data();
else if ( grass_type == DCELL_TYPE )
dcell = ( double * ) byteArray.data();
void *ptr = buf;
for ( int col = 0; col < cols; col++ )
{
if ( grass_type == CELL_TYPE )
{
if ( ( CELL )cell[col] == ( CELL )noDataValue )
{
Rast_set_c_null_value( ( CELL * )ptr, 1 );
}
else
{
Rast_set_c_value( ptr, ( CELL )( cell[col] ), grass_type );
}
}
else if ( grass_type == FCELL_TYPE )
{
if ( ( FCELL )fcell[col] == ( FCELL )noDataValue )
{
Rast_set_f_null_value( ( FCELL * )ptr, 1 );
}
else
{
Rast_set_f_value( ptr, ( FCELL )( fcell[col] ), grass_type );
}
}
else if ( grass_type == DCELL_TYPE )
{
if ( ( DCELL )dcell[col] == ( DCELL )noDataValue )
{
Rast_set_d_null_value( ( DCELL * )ptr, 1 );
}
else
{
Rast_set_d_value( ptr, ( DCELL )dcell[col], grass_type );
}
}
ptr = G_incr_void_ptr( ptr, Rast_cell_size( grass_type ) );
}
Rast_put_row( cf, buf, grass_type );
#ifndef Q_OS_WIN
// Because stdin is somewhere buffered on Windows (not clear if in QProcess or by Windows)
// we cannot in QgsGrassImport wait for this because it hangs. Setting _IONBF on stdin does not help
// and there is no flush() on QProcess.
// OTOH, smaller stdin buffer is probably blocking QgsGrassImport so that the import can be canceled immediately.
stdoutStream << ( bool )true; // row written
stdoutFile.flush();
#endif
}
if ( isCanceled )
{
Rast_unopen( cf );
}
else
{
Rast_close( cf );
struct History history;
Rast_short_history( name, "raster", &history );
Rast_command_history( &history );
Rast_write_history( name, &history );
}
exit( EXIT_SUCCESS );
}
int describe(char *name, char *mapset, int compact, char *no_data_str,
int range, int windowed, int nsteps, int as_int, int skip_nulls)
{
int fd;
struct Cell_stats statf;
CELL *buf, *b;
int nrows, ncols;
int row, col;
struct Cell_head window;
CELL negmin = 0, negmax = 0, zero = 0, posmin = 0, posmax = 0;
CELL null = 0;
RASTER_MAP_TYPE map_type;
struct Quant q;
struct FPRange r;
DCELL dmin, dmax;
int (*get_row) ();
if (windowed) {
get_row = G_get_c_raster_row;
}
else {
char msg[100];
if (G_get_cellhd(name, mapset, &window) < 0) {
sprintf(msg, "can't get cell header for [%s] in [%s]", name,
mapset);
G_fatal_error(msg);
}
G_set_window(&window);
get_row = G_get_c_raster_row_nomask;
}
fd = G_open_cell_old(name, mapset);
if (fd < 0)
return 0;
map_type = G_get_raster_map_type(fd);
if (as_int)
map_type = CELL_TYPE; /* read as int */
/* allocate the cell buffer */
buf = G_allocate_cell_buf();
if (map_type != CELL_TYPE && range)
/* this will make it report fp range */
{
range = 0;
nsteps = 1;
}
/* start the cell stats */
if (!range) {
G_init_cell_stats(&statf);
}
else {
zero = 0;
negmin = 0;
negmax = 0;
posmin = 0;
posmax = 0;
null = 0;
dmin = 0.0;
dmax = 0.0;
}
/* set up quantization rules */
if (map_type != CELL_TYPE) {
G_quant_init(&q);
G_read_fp_range(name, mapset, &r);
G_get_fp_range_min_max(&r, &dmin, &dmax);
G_quant_add_rule(&q, dmin, dmax, 1, nsteps);
G_set_quant_rules(fd, &q);
}
nrows = G_window_rows();
ncols = G_window_cols();
G_verbose_message("Reading [%s in %s] ...", name, mapset);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
if ((*get_row) (fd, b = buf, row) < 0)
break;
if (range) {
for (col = ncols; col-- > 0; b++) {
if (G_is_c_null_value(b))
null = 1;
else if (*b == 0)
zero = 1;
else if (*b < 0) {
if (!negmin)
negmin = negmax = *b;
else if (*b > negmax)
negmax = *b;
else if (*b < negmin)
negmin = *b;
}
else {
if (!posmin)
posmin = posmax = *b;
else if (*b > posmax)
posmax = *b;
else if (*b < posmin)
posmin = *b;
}
}
}
else
G_update_cell_stats(buf, ncols, &statf);
}
G_percent(nrows, nrows, 2);
G_close_cell(fd);
G_free(buf);
if (range) {
if (compact)
compact_range_list(negmin, negmax, zero, posmin, posmax, null,
no_data_str, skip_nulls);
else
range_list(negmin, negmax, zero, posmin, posmax, null,
no_data_str, skip_nulls);
}
else {
G_rewind_cell_stats(&statf);
if (compact)
compact_list(&statf, dmin, dmax, no_data_str, skip_nulls,
map_type, nsteps);
else
long_list(&statf, dmin, dmax, no_data_str, skip_nulls, map_type,
nsteps);
G_free_cell_stats(&statf);
}
return 1;
}
int IL_resample_output_2d(struct interp_params *params, double zmin, double zmax, /* min,max input z-values */
double zminac, double zmaxac, /* min,max interpolated values */
double c1min, double c1max, double c2min, double c2max, double gmin, double gmax, double ertot, /* total interplating func. error */
char *input, /* input file name */
double *dnorm, struct Cell_head *outhd, /* Region with desired resolution */
struct Cell_head *winhd, /* Current region */
char *smooth, int n_points)
/*
* Creates output files as well as history files and color tables for
* them.
*/
{
FCELL *cell1; /* cell buffer */
int cf1 = 0, cf2 = 0, cf3 = 0, cf4 = 0, cf5 = 0, cf6 = 0; /* cell file descriptors */
int nrows, ncols; /* current region rows and columns */
int i; /* loop counter */
char *mapset;
float dat1, dat2;
struct Colors colors, colors2;
double value1, value2;
struct History hist, hist1, hist2, hist3, hist4, hist5;
struct _Color_Rule_ *rule;
char *maps, *type;
int cond1, cond2;
cond2 = ((params->pcurv != NULL) ||
(params->tcurv != NULL) || (params->mcurv != NULL));
cond1 = ((params->slope != NULL) || (params->aspect != NULL) || cond2);
/* change region to output cell file region */
fprintf(stderr,
"Temporarily changing the region to desired resolution...\n");
if (G_set_window(outhd) < 0) {
fprintf(stderr, "Cannot set region to output region!\n");
return -1;
}
mapset = G_mapset();
cell1 = G_allocate_f_raster_buf();
if (params->elev != NULL) {
cf1 = G_open_fp_cell_new(params->elev);
if (cf1 < 0) {
fprintf(stderr, "unable to create raster map %s\n", params->elev);
return -1;
}
}
if (params->slope != NULL) {
cf2 = G_open_fp_cell_new(params->slope);
if (cf2 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->slope);
return -1;
}
}
if (params->aspect != NULL) {
cf3 = G_open_fp_cell_new(params->aspect);
if (cf3 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->aspect);
return -1;
}
}
if (params->pcurv != NULL) {
cf4 = G_open_fp_cell_new(params->pcurv);
if (cf4 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->pcurv);
return -1;
}
}
if (params->tcurv != NULL) {
cf5 = G_open_fp_cell_new(params->tcurv);
if (cf5 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->tcurv);
return -1;
}
}
if (params->mcurv != NULL) {
cf6 = G_open_fp_cell_new(params->mcurv);
if (cf6 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->mcurv);
return -1;
}
}
nrows = outhd->rows;
if (nrows != params->nsizr) {
fprintf(stderr, "first change your rows number(%d) to %d!\n",
nrows, params->nsizr);
return -1;
}
ncols = outhd->cols;
if (ncols != params->nsizc) {
fprintf(stderr, "first change your rows number(%d) to %d!\n",
ncols, params->nsizc);
return -1;
}
if (params->elev != NULL) {
fseek(params->Tmp_fd_z, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_z, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_z);
if (G_put_f_raster_row(cf1, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->slope != NULL) {
fseek(params->Tmp_fd_dx, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_dx, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_dx);
/*
* for (ii==0;ii<params->nsizc;ii++) { fprintf(stderr,"ii=%d ",ii);
* fprintf(stderr,"%f ",cell1[ii]); }
* fprintf(stderr,"params->nsizc=%d \n",params->nsizc);
*/
if (G_put_f_raster_row(cf2, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->aspect != NULL) {
fseek(params->Tmp_fd_dy, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_dy, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_dy);
if (G_put_f_raster_row(cf3, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->pcurv != NULL) {
fseek(params->Tmp_fd_xx, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_xx, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_xx);
if (G_put_f_raster_row(cf4, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->tcurv != NULL) {
fseek(params->Tmp_fd_yy, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_yy, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_yy);
if (G_put_f_raster_row(cf5, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->mcurv != NULL) {
fseek(params->Tmp_fd_xy, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_xy, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_xy);
if (G_put_f_raster_row(cf6, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (cf1)
G_close_cell(cf1);
if (cf2)
G_close_cell(cf2);
if (cf3)
G_close_cell(cf3);
if (cf4)
G_close_cell(cf4);
if (cf5)
G_close_cell(cf5);
if (cf6)
G_close_cell(cf6);
/* write colormaps and history for output cell files */
/* colortable for elevations */
maps = G_find_file("cell", input, "");
if (params->elev != NULL) {
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", input);
return -1;
}
G_init_colors(&colors2);
/*
* G_mark_colors_as_fp(&colors2);
*/
if (G_read_colors(input, maps, &colors) >= 0) {
if (colors.modular.rules) {
rule = colors.modular.rules;
while (rule->next)
rule = rule->next;
for (; rule; rule = rule->prev) {
value1 = rule->low.value * params->zmult;
value2 = rule->high.value * params->zmult;
G_add_modular_d_raster_color_rule(&value1, rule->low.red,
rule->low.grn,
rule->low.blu, &value2,
rule->high.red,
rule->high.grn,
rule->high.blu,
&colors2);
}
}
if (colors.fixed.rules) {
rule = colors.fixed.rules;
while (rule->next)
rule = rule->next;
for (; rule; rule = rule->prev) {
value1 = rule->low.value * params->zmult;
value2 = rule->high.value * params->zmult;
G_add_d_raster_color_rule(&value1, rule->low.red,
rule->low.grn, rule->low.blu,
&value2, rule->high.red,
rule->high.grn, rule->high.blu,
&colors2);
}
}
maps = NULL;
maps = G_find_file("cell", params->elev, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->elev);
return -1;
}
if (G_write_colors(params->elev, maps, &colors2) < 0) {
fprintf(stderr, "Cannot write color table\n");
return -1;
}
G_quantize_fp_map_range(params->elev, mapset,
zminac - 0.5, zmaxac + 0.5,
(CELL) (zminac - 0.5),
(CELL) (zmaxac + 0.5));
}
else
fprintf(stderr,
"No color table for input file -- will not create color table\n");
}
/* colortable for slopes */
if (cond1 & (!params->deriv)) {
G_init_colors(&colors);
G_add_color_rule(0, 255, 255, 255, 2, 255, 255, 0, &colors);
G_add_color_rule(2, 255, 255, 0, 5, 0, 255, 0, &colors);
G_add_color_rule(5, 0, 255, 0, 10, 0, 255, 255, &colors);
G_add_color_rule(10, 0, 255, 255, 15, 0, 0, 255, &colors);
G_add_color_rule(15, 0, 0, 255, 30, 255, 0, 255, &colors);
G_add_color_rule(30, 255, 0, 255, 50, 255, 0, 0, &colors);
G_add_color_rule(50, 255, 0, 0, 90, 0, 0, 0, &colors);
if (params->slope != NULL) {
maps = NULL;
maps = G_find_file("cell", params->slope, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->slope);
return -1;
}
G_write_colors(params->slope, maps, &colors);
G_quantize_fp_map_range(params->slope, mapset, 0., 90., 0, 90);
type = "raster";
G_short_history(params->slope, type, &hist1);
if (params->elev != NULL)
sprintf(hist1.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist1.datsrc_1, "raster map %s", input);
hist1.edlinecnt = 1;
G_write_history(params->slope, &hist1);
}
/* colortable for aspect */
G_init_colors(&colors);
G_add_color_rule(0, 255, 255, 255, 0, 255, 255, 255, &colors);
G_add_color_rule(1, 255, 255, 0, 90, 0, 255, 0, &colors);
G_add_color_rule(90, 0, 255, 0, 180, 0, 255, 255, &colors);
G_add_color_rule(180, 0, 255, 255, 270, 255, 0, 0, &colors);
G_add_color_rule(270, 255, 0, 0, 360, 255, 255, 0, &colors);
if (params->aspect != NULL) {
maps = NULL;
maps = G_find_file("cell", params->aspect, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->aspect);
return -1;
}
G_write_colors(params->aspect, maps, &colors);
G_quantize_fp_map_range(params->aspect, mapset, 0., 360., 0, 360);
type = "raster";
G_short_history(params->aspect, type, &hist2);
if (params->elev != NULL)
sprintf(hist2.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist2.datsrc_1, "raster map %s", input);
hist2.edlinecnt = 1;
G_write_history(params->aspect, &hist2);
}
/* colortable for curvatures */
if (cond2) {
G_init_colors(&colors);
dat1 = (FCELL) amin1(c1min, c2min);
dat2 = (FCELL) - 0.01;
G_add_f_raster_color_rule(&dat1, 50, 0, 155,
&dat2, 0, 0, 255, &colors);
dat1 = dat2;
dat2 = (FCELL) - 0.001;
G_add_f_raster_color_rule(&dat1, 0, 0, 255,
&dat2, 0, 127, 255, &colors);
dat1 = dat2;
dat2 = (FCELL) - 0.00001;
G_add_f_raster_color_rule(&dat1, 0, 127, 255,
&dat2, 0, 255, 255, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.00;
G_add_f_raster_color_rule(&dat1, 0, 255, 255,
&dat2, 200, 255, 200, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.00001;
G_add_f_raster_color_rule(&dat1, 200, 255, 200,
&dat2, 255, 255, 0, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.001;
G_add_f_raster_color_rule(&dat1, 255, 255, 0,
&dat2, 255, 127, 0, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.01;
G_add_f_raster_color_rule(&dat1, 255, 127, 0,
&dat2, 255, 0, 0, &colors);
dat1 = dat2;
dat2 = (FCELL) amax1(c1max, c2max);
G_add_f_raster_color_rule(&dat1, 255, 0, 0,
&dat2, 155, 0, 20, &colors);
maps = NULL;
if (params->pcurv != NULL) {
maps = G_find_file("cell", params->pcurv, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->pcurv);
return -1;
}
G_write_colors(params->pcurv, maps, &colors);
fprintf(stderr, "color map written\n");
G_quantize_fp_map_range(params->pcurv, mapset,
dat1, dat2,
(CELL) (dat1 * MULT),
(CELL) (dat2 * MULT));
type = "raster";
G_short_history(params->pcurv, type, &hist3);
if (params->elev != NULL)
sprintf(hist3.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist3.datsrc_1, "raster map %s", input);
hist3.edlinecnt = 1;
G_write_history(params->pcurv, &hist3);
}
if (params->tcurv != NULL) {
maps = NULL;
maps = G_find_file("cell", params->tcurv, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->tcurv);
return -1;
}
G_write_colors(params->tcurv, maps, &colors);
G_quantize_fp_map_range(params->tcurv, mapset,
dat1, dat2, (CELL) (dat1 * MULT),
(CELL) (dat2 * MULT));
type = "raster";
G_short_history(params->tcurv, type, &hist4);
if (params->elev != NULL)
sprintf(hist4.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist4.datsrc_1, "raster map %s", input);
hist4.edlinecnt = 1;
G_write_history(params->tcurv, &hist4);
}
if (params->mcurv != NULL) {
maps = NULL;
maps = G_find_file("cell", params->mcurv, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->mcurv);
return -1;
}
G_write_colors(params->mcurv, maps, &colors);
G_quantize_fp_map_range(params->mcurv, mapset,
dat1, dat2,
(CELL) (dat1 * MULT),
(CELL) (dat2 * MULT));
type = "raster";
G_short_history(params->mcurv, type, &hist5);
if (params->elev != NULL)
sprintf(hist5.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist5.datsrc_1, "raster map %s", input);
hist5.edlinecnt = 1;
G_write_history(params->mcurv, &hist5);
}
}
}
if (params->elev != NULL) {
maps = G_find_file("cell", params->elev, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found \n", params->elev);
return -1;
}
G_short_history(params->elev, "raster", &hist);
if (smooth != NULL)
sprintf(hist.edhist[0], "tension=%f, smoothing=%s",
params->fi * 1000. / (*dnorm), smooth);
else
sprintf(hist.edhist[0], "tension=%f",
params->fi * 1000. / (*dnorm));
sprintf(hist.edhist[1], "dnorm=%f, zmult=%f", *dnorm, params->zmult);
sprintf(hist.edhist[2], "KMAX=%d, KMIN=%d, errtotal=%f", params->kmax,
params->kmin, sqrt(ertot / n_points));
sprintf(hist.edhist[3], "zmin_data=%f, zmax_data=%f", zmin, zmax);
sprintf(hist.edhist[4], "zmin_int=%f, zmax_int=%f", zminac, zmaxac);
sprintf(hist.datsrc_1, "raster map %s", input);
hist.edlinecnt = 5;
G_write_history(params->elev, &hist);
}
/* change region to initial region */
fprintf(stderr, "Changing the region back to initial...\n");
if (G_set_window(winhd) < 0) {
fprintf(stderr, "Cannot set region to back to initial region!\n");
return -1;
}
return 1;
}
