int begin_rasterization(int nrows, int f)
{
int i, size;
int pages;
/* otherwise get complaints about window changes */
G_suppress_warnings(1);
format = f;
max_rows = nrows;
if (max_rows <= 0)
max_rows = 512;
G_get_set_window(®ion);
G_get_set_window(&page);
pages = (region.rows + max_rows - 1) / max_rows;
if (max_rows > region.rows)
max_rows = region.rows;
size = max_rows * region.cols;
switch (format) {
case USE_CELL:
raster.cell =
(CELL **) G_calloc(max_rows * sizeof(char), sizeof(CELL *));
raster.cell[0] = (CELL *) G_calloc(size * sizeof(char), sizeof(CELL));
for (i = 1; i < max_rows; i++)
raster.cell[i] = raster.cell[i - 1] + region.cols;
dot = cell_dot;
break;
case USE_DCELL:
raster.dcell =
(DCELL **) G_calloc(max_rows * sizeof(char), sizeof(DCELL *));
raster.dcell[0] =
(DCELL *) G_calloc(size * sizeof(char), sizeof(DCELL));
for (i = 1; i < max_rows; i++)
raster.dcell[i] = raster.dcell[i - 1] + region.cols;
dot = dcell_dot;
break;
}
null_flags = (char **)G_calloc(max_rows * sizeof(char), sizeof(char *));
null_flags[0] = (char *)G_calloc(size * sizeof(char), sizeof(char));
for (i = 1; i < max_rows; i++)
null_flags[i] = null_flags[i - 1] + region.cols;
at_row = 0;
configure_plot();
return pages;
}
/*!
* \brief Initiate a pde geometry data structure with a 3d region
*
* If the projection is not planimetric, a double array will be created based on the
* number of rows of the provided region
*
* \param region3d RASTER3D_Region *
* \param geodata N_geom_data * - if a NULL pointer is given, a new structure will be allocatet and returned
*
* \return N_geom_data *
* */
N_geom_data *N_init_geom_data_3d(RASTER3D_Region * region3d, N_geom_data * geodata)
{
N_geom_data *geom = geodata;
struct Cell_head region2d;
#pragma omp critical
{
G_debug(2,
"N_init_geom_data_3d: initializing the geometry structure");
if (geom == NULL)
geom = N_alloc_geom_data();
geom->dz = region3d->tb_res * G_database_units_to_meters_factor(); /*this function is not thread safe */
geom->depths = region3d->depths;
geom->dim = 3;
/*convert the 3d into a 2d region and begin the area calculation */
G_get_set_window(®ion2d); /*this function is not thread safe */
Rast3d_region_to_cell_head(region3d, ®ion2d);
}
return N_init_geom_data_2d(®ion2d, geom);
}
/*!
\brief Query cartographic projection
This routine returns a code indicating the projection for the active
region. The current values are (see gis.h)
- PROJECTION_XY 0 - x,y (Raw imagery)
- PROJECTION_UTM 1 - UTM Universal Transverse Mercator
- PROJECTION_SP 2 - State Plane (in feet) - not used, removed
- PROJECTION_LL 3 - Latitude-Longitude
- PROJECTION_OTHER 99 - others
Others may be added in the future.
\return projection code (see above)
*/
int G_projection(void)
{
struct Cell_head window;
G_get_set_window(&window);
return window.proj;
}
double P_estimate_splinestep(struct Map_info *Map, double *dens, double *dist)
{
int type, npoints = 0;
double xmin = 0, xmax = 0, ymin = 0, ymax = 0;
double x, y, z;
struct line_pnts *points;
struct line_cats *categories;
struct bound_box region_box;
struct Cell_head orig;
G_get_set_window(&orig);
Vect_region_box(&orig, ®ion_box);
points = Vect_new_line_struct();
categories = Vect_new_cats_struct();
Vect_rewind(Map);
while ((type = Vect_read_next_line(Map, points, categories)) > 0) {
if (!(type & GV_POINT))
continue;
x = points->x[0];
y = points->y[0];
if (points->z != NULL)
z = points->z[0];
else
z = 0.0;
/* only use points in current region */
if (Vect_point_in_box(x, y, z, ®ion_box)) {
npoints++;
if (npoints > 1) {
if (xmin > x)
xmin = x;
else if (xmax < x)
xmax = x;
if (ymin > y)
ymin = y;
else if (ymax < y)
ymax = y;
}
else {
xmin = xmax = x;
ymin = ymax = y;
}
}
}
if (npoints > 0) {
/* estimated average distance between points in map units */
*dist = sqrt(((xmax - xmin) * (ymax - ymin)) / npoints);
/* estimated point density as number of points per square map unit */
*dens = npoints / ((xmax - xmin) * (ymax - ymin));
return 0;
}
else {
return -1;
}
}
/*!
\brief Graphics frame setup
This is a high level D call. It does a full setup for the current
graphics frame.
Note: Connection to driver must already be made.
Sets the source coordinate system to the current region, and
adjusts the destination coordinate system to preserve the aspect
ratio.
Performs a full setup for the current graphics frame:
- Makes sure there is a current graphics frame (will create a full-screen
one, if not);
- Sets the region coordinates so that the graphics frame and the active
module region agree (may change active module region to do this); and
- Performs graphic frame/region coordinate conversion initialization.
If <b>clear</b> is true, the frame is cleared (same as running
<i>d.erase</i>.) Otherwise, it is not cleared.
\param clear 1 to clear frame (visually and coordinates)
*/
void D_setup(int clear)
{
struct Cell_head region;
double dt, db, dl, dr;
D_get_window(&dt, &db, &dl, &dr);
G_get_set_window(®ion);
Rast_set_window(®ion);
D_do_conversions(®ion, dt, db, dl, dr);
if (clear)
D_erase(DEFAULT_BG_COLOR);
}
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");
}
/* *************************************************************** */
int io_bench_2d(void)
{
int sum = 0, res = 0;
char buff[1024];
struct Cell_head region;
N_array_2d *data1;
N_array_2d *data2;
N_array_2d *data3;
N_array_2d *tmp;
G_get_set_window(®ion);
data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
fill_array_2d(data1);
fill_array_2d(data2);
fill_array_2d(data3);
/*raster IO methods */
N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
N_free_array_2d(tmp);
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
N_free_array_2d(tmp);
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
N_free_array_2d(tmp);
sprintf(buff,
"g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
system(buff);
N_free_array_2d(data1);
N_free_array_2d(data2);
N_free_array_2d(data3);
return sum;
}
void update_input_region(char* raster, char* region, struct Cell_head &window, double &offset, bool ®ion3D) {
if (region){ /* region= */
G_get_element_window(&window, "windows", region, "");
offset = window.bottom;
if (window.top != window.bottom)
region3D = true;
}
else if (raster) {
struct FPRange range;
double zmin, zmax;
Rast_get_cellhd(raster, "", &window);
Rast_read_fp_range(raster, "", &range);
Rast_get_fp_range_min_max(&range, &zmin, &zmax);
offset = zmin;
}
else { // current region
G_get_set_window(&window);
offset = 0;
}
}
/*
* 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)
{
int colorg = 0;
int colorb = 0;
int colort = 0;
int colorbg = 0;
double size = 0., gsize = 0.; /* initialize to zero */
double east, north;
int do_text, fontsize, mark_type, line_width, dirn;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *fsize, *tcolor, *lwidth,
*direction, *bgcolor;
struct Flag *noborder, *notext, *geogrid, *nogrid, *wgs84, *cross,
*fiducial, *dot, *align;
struct pj_info info_in; /* Proj structures */
struct pj_info info_out; /* Proj structures */
struct Cell_head wind;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
G_add_keyword(_("graticule"));
module->description =
_("Overlays a user-specified grid "
"in the active display frame on the graphics monitor.");
opt2 = G_define_option();
opt2->key = "size";
opt2->key_desc = "value";
opt2->type = TYPE_STRING;
opt2->required = YES;
opt2->label = _("Size of grid to be drawn (in map units)");
opt2->description =
_("0 for north-south resolution of the current region. "
"In map units or DDD:MM:SS format. "
"Example: \"1000\" or \"0:10\"");
opt3 = G_define_standard_option(G_OPT_M_COORDS);
opt3->key = "origin";
opt3->answer = "0,0";
opt3->multiple = NO;
opt3->description = _("Lines of the grid pass through this coordinate");
direction = G_define_option();
direction->key = "direction";
direction->type = TYPE_STRING;
direction->required = NO;
direction->answer = "both";
direction->options = "both,east-west,north-south";
direction->description =
_("Draw only east-west lines, north-south lines, or both ");
direction->guisection = _("Disable");
lwidth = G_define_option();
lwidth->key = "width";
lwidth->type = TYPE_DOUBLE;
lwidth->required = NO;
lwidth->description = _("Grid line width");
opt1 = G_define_standard_option(G_OPT_C);
opt1->answer = "gray";
opt1->label = _("Grid color");
opt1->guisection = _("Color");
opt4 = G_define_standard_option(G_OPT_C);
opt4->key = "border_color";
opt4->label = _("Border color");
opt4->guisection = _("Color");
tcolor = G_define_standard_option(G_OPT_C);
tcolor->key = "text_color";
tcolor->answer = "gray";
tcolor->label = _("Text color");
tcolor->guisection = _("Color");
bgcolor = G_define_standard_option(G_OPT_CN);
bgcolor->key = "bgcolor";
bgcolor->answer = "none";
bgcolor->label = _("Background color");
bgcolor->guisection = _("Color");
fsize = G_define_option();
fsize->key = "fontsize";
fsize->type = TYPE_INTEGER;
fsize->required = NO;
fsize->answer = "9";
fsize->options = "1-72";
fsize->description = _("Font size for gridline coordinate labels");
align = G_define_flag();
align->key = 'a';
align->description =
_("Align the origin to the east-north corner of the current region");
geogrid = G_define_flag();
geogrid->key = 'g';
geogrid->description =
_("Draw geographic grid (referenced to current ellipsoid)");
geogrid->guisection = _("Draw");
wgs84 = G_define_flag();
wgs84->key = 'w';
wgs84->description =
_("Draw geographic grid (referenced to WGS84 ellipsoid)");
wgs84->guisection = _("Draw");
cross = G_define_flag();
cross->key = 'c';
cross->description = _("Draw '+' marks instead of grid lines");
cross->guisection = _("Draw");
dot = G_define_flag();
dot->key = 'd';
dot->description = _("Draw '.' marks instead of grid lines");
dot->guisection = _("Draw");
fiducial = G_define_flag();
fiducial->key = 'f';
fiducial->description = _("Draw fiducial marks instead of grid lines");
fiducial->guisection = _("Draw");
nogrid = G_define_flag();
nogrid->key = 'n';
nogrid->description = _("Disable grid drawing");
nogrid->guisection = _("Disable");
noborder = G_define_flag();
noborder->key = 'b';
noborder->description = _("Disable border drawing");
noborder->guisection = _("Disable");
notext = G_define_flag();
notext->key = 't';
notext->description = _("Disable text drawing");
notext->guisection = _("Disable");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* do some checking */
if (nogrid->answer && noborder->answer)
G_fatal_error(_("Both grid and border drawing are disabled"));
if (wgs84->answer)
geogrid->answer = 1; /* -w implies -g */
if (geogrid->answer && G_projection() == PROJECTION_LL)
G_fatal_error(_("Geo-grid option not available for LL projection, use without -g/-w"));
if (geogrid->answer && G_projection() == PROJECTION_XY)
G_fatal_error(_("Geo-grid option not available for XY projection, use without -g/-w"));
if (notext->answer)
do_text = FALSE;
else
do_text = TRUE;
if (lwidth->answer) {
line_width = atoi(lwidth->answer);
if (line_width < 0 || line_width > 1e3)
G_fatal_error("Invalid line width");
}
else
line_width = 0;
fontsize = atoi(fsize->answer);
mark_type = MARK_GRID;
if (cross->answer + fiducial->answer + dot->answer > 1)
G_fatal_error(_("Choose a single mark style"));
if (cross->answer)
mark_type = MARK_CROSS;
if (fiducial->answer)
mark_type = MARK_FIDUCIAL;
if (dot->answer)
mark_type = MARK_DOT;
if (G_strcasecmp(direction->answer, "both") == 0)
dirn = DIRN_BOTH;
else if (G_strcasecmp(direction->answer, "east-west") == 0)
dirn = DIRN_LAT;
else if (G_strcasecmp(direction->answer, "north-south") == 0)
dirn = DIRN_LON;
else
G_fatal_error("Invalid direction: %s", direction->answer);
if (align->answer || strcmp(opt2->answer, "0") == 0)
G_get_element_window(&wind, "", "WIND", G_mapset());
if (strcmp(opt2->answer, "0") == 0) {
if (geogrid->answer)
gsize = wind.ns_res;
else
size = wind.ns_res;
}
else {
/* get grid size */
if (geogrid->answer) {
if (!G_scan_resolution(opt2->answer, &gsize, PROJECTION_LL) ||
gsize <= 0.0)
G_fatal_error(_("Invalid geo-grid size <%s>"), opt2->answer);
}
else {
if (!G_scan_resolution(opt2->answer, &size, G_projection()) ||
size <= 0.0)
G_fatal_error(_("Invalid grid size <%s>"), opt2->answer);
}
}
if (align->answer) {
/* reduce accumulated errors when ew_res is not the same as ns_res. */
struct Cell_head w;
G_get_set_window(&w);
east =
wind.west +
(int)((w.west - wind.west) / wind.ew_res) * wind.ew_res;
north =
wind.south +
(int)((w.south - wind.south) / wind.ns_res) * wind.ns_res;
}
else {
/* get grid easting start */
if (!G_scan_easting(opt3->answers[0], &east, G_projection())) {
G_usage();
G_fatal_error(_("Illegal east coordinate <%s>"),
opt3->answers[0]);
}
/* get grid northing start */
if (!G_scan_northing(opt3->answers[1], &north, G_projection())) {
G_usage();
G_fatal_error(_("Illegal north coordinate <%s>"),
opt3->answers[1]);
}
}
/* Setup driver and check important information */
D_open_driver();
/* Parse and select grid color */
colorg = D_parse_color(opt1->answer, FALSE);
/* Parse and select border color */
colorb = D_parse_color(opt4->answer, FALSE);
/* Parse and select text color */
colort = D_parse_color(tcolor->answer, FALSE);
/* Parse and select background color */
colorbg = D_parse_color(bgcolor->answer, TRUE);
D_setup(0);
/* draw grid */
if (!nogrid->answer) {
if (geogrid->answer) {
/* initialzie proj stuff */
init_proj(&info_in, &info_out, wgs84->answer);
plot_geogrid(gsize, info_in, info_out, do_text, colorg, colort,
colorbg, fontsize, mark_type, line_width, dirn);
}
else {
/* Do the grid plotting */
plot_grid(size, east, north, do_text, colorg, colort, colorbg,
fontsize, mark_type, line_width, dirn);
}
}
/* Draw border */
if (!noborder->answer) {
/* Set border color */
D_use_color(colorb);
/* Do the border plotting */
plot_border(size, east, north, dirn);
}
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int m1;
struct FPRange range;
DCELL cellmin, cellmax;
FCELL *cellrow, fcellmin;
struct GModule *module;
struct
{
struct Option *input, *elev, *slope, *aspect, *pcurv, *tcurv, *mcurv,
*smooth, *maskmap, *zmult, *fi, *segmax, *npmin, *res_ew, *res_ns,
*overlap, *theta, *scalex;
} parm;
struct
{
struct Flag *deriv, *cprght;
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("resample"));
module->description =
_("Reinterpolates and optionally computes topographic analysis from "
"input raster map to a new raster map (possibly with "
"different resolution) using regularized spline with "
"tension and smoothing.");
parm.input = G_define_standard_option(G_OPT_R_INPUT);
parm.res_ew = G_define_option();
parm.res_ew->key = "ew_res";
parm.res_ew->type = TYPE_DOUBLE;
parm.res_ew->required = YES;
parm.res_ew->description = _("Desired east-west resolution");
parm.res_ns = G_define_option();
parm.res_ns->key = "ns_res";
parm.res_ns->type = TYPE_DOUBLE;
parm.res_ns->required = YES;
parm.res_ns->description = _("Desired north-south resolution");
parm.elev = G_define_option();
parm.elev->key = "elev";
parm.elev->type = TYPE_STRING;
parm.elev->required = NO;
parm.elev->gisprompt = "new,cell,raster";
parm.elev->description = _("Output z-file (elevation) map");
parm.elev->guisection = _("Output");
parm.slope = G_define_option();
parm.slope->key = "slope";
parm.slope->type = TYPE_STRING;
parm.slope->required = NO;
parm.slope->gisprompt = "new,cell,raster";
parm.slope->description = _("Output slope map (or fx)");
parm.slope->guisection = _("Output");
parm.aspect = G_define_option();
parm.aspect->key = "aspect";
parm.aspect->type = TYPE_STRING;
parm.aspect->required = NO;
parm.aspect->gisprompt = "new,cell,raster";
parm.aspect->description = _("Output aspect map (or fy)");
parm.aspect->guisection = _("Output");
parm.pcurv = G_define_option();
parm.pcurv->key = "pcurv";
parm.pcurv->type = TYPE_STRING;
parm.pcurv->required = NO;
parm.pcurv->gisprompt = "new,cell,raster";
parm.pcurv->description = _("Output profile curvature map (or fxx)");
parm.pcurv->guisection = _("Output");
parm.tcurv = G_define_option();
parm.tcurv->key = "tcurv";
parm.tcurv->type = TYPE_STRING;
parm.tcurv->required = NO;
parm.tcurv->gisprompt = "new,cell,raster";
parm.tcurv->description = _("Output tangential curvature map (or fyy)");
parm.tcurv->guisection = _("Output");
parm.mcurv = G_define_option();
parm.mcurv->key = "mcurv";
parm.mcurv->type = TYPE_STRING;
parm.mcurv->required = NO;
parm.mcurv->gisprompt = "new,cell,raster";
parm.mcurv->description = _("Output mean curvature map (or fxy)");
parm.mcurv->guisection = _("Output");
parm.smooth = G_define_option();
parm.smooth->key = "smooth";
parm.smooth->type = TYPE_STRING;
parm.smooth->required = NO;
parm.smooth->gisprompt = "old,cell,raster";
parm.smooth->description = _("Name of raster map containing smoothing");
parm.smooth->guisection = _("Settings");
parm.maskmap = G_define_option();
parm.maskmap->key = "maskmap";
parm.maskmap->type = TYPE_STRING;
parm.maskmap->required = NO;
parm.maskmap->gisprompt = "old,cell,raster";
parm.maskmap->description = _("Name of raster map to be used as mask");
parm.maskmap->guisection = _("Settings");
parm.overlap = G_define_option();
parm.overlap->key = "overlap";
parm.overlap->type = TYPE_INTEGER;
parm.overlap->required = NO;
parm.overlap->answer = OVERLAP;
parm.overlap->description = _("Rows/columns overlap for segmentation");
parm.overlap->guisection = _("Settings");
parm.zmult = G_define_option();
parm.zmult->key = "zmult";
parm.zmult->type = TYPE_DOUBLE;
parm.zmult->answer = ZMULT;
parm.zmult->required = NO;
parm.zmult->description = _("Multiplier for z-values");
parm.zmult->guisection = _("Settings");
parm.fi = G_define_option();
parm.fi->key = "tension";
parm.fi->type = TYPE_DOUBLE;
parm.fi->answer = TENSION;
parm.fi->required = NO;
parm.fi->description = _("Spline tension value");
parm.fi->guisection = _("Settings");
parm.theta = G_define_option();
parm.theta->key = "theta";
parm.theta->type = TYPE_DOUBLE;
parm.theta->required = NO;
parm.theta->description = _("Anisotropy angle (in degrees)");
parm.theta->guisection = _("Anisotropy");
parm.scalex = G_define_option();
parm.scalex->key = "scalex";
parm.scalex->type = TYPE_DOUBLE;
parm.scalex->required = NO;
parm.scalex->description = _("Anisotropy scaling factor");
parm.scalex->guisection = _("Anisotropy");
flag.cprght = G_define_flag();
flag.cprght->key = 't';
flag.cprght->description = _("Use dnorm independent tension");
flag.deriv = G_define_flag();
flag.deriv->key = 'd';
flag.deriv->description =
_("Output partial derivatives instead of topographic parameters");
flag.deriv->guisection = _("Output");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&winhd);
inp_ew_res = winhd.ew_res;
inp_ns_res = winhd.ns_res;
inp_cols = winhd.cols;
inp_rows = winhd.rows;
inp_x_orig = winhd.west;
inp_y_orig = winhd.south;
input = parm.input->answer;
smooth = parm.smooth->answer;
maskmap = parm.maskmap->answer;
elev = parm.elev->answer;
slope = parm.slope->answer;
aspect = parm.aspect->answer;
pcurv = parm.pcurv->answer;
tcurv = parm.tcurv->answer;
mcurv = parm.mcurv->answer;
cond2 = ((pcurv != NULL) || (tcurv != NULL) || (mcurv != NULL));
cond1 = ((slope != NULL) || (aspect != NULL) || cond2);
deriv = flag.deriv->answer;
dtens = flag.cprght->answer;
ertre = 0.1;
if (!G_scan_resolution(parm.res_ew->answer, &ew_res, winhd.proj))
G_fatal_error(_("Unable to read ew_res value"));
if (!G_scan_resolution(parm.res_ns->answer, &ns_res, winhd.proj))
G_fatal_error(_("Unable to read ns_res value"));
if (sscanf(parm.fi->answer, "%lf", &fi) != 1)
G_fatal_error(_("Invalid value for tension"));
if (sscanf(parm.zmult->answer, "%lf", &zmult) != 1)
G_fatal_error(_("Invalid value for zmult"));
if (sscanf(parm.overlap->answer, "%d", &overlap) != 1)
G_fatal_error(_("Invalid value for overlap"));
if (parm.theta->answer) {
if (sscanf(parm.theta->answer, "%lf", &theta) != 1)
G_fatal_error(_("Invalid value for theta"));
}
if (parm.scalex->answer) {
if (sscanf(parm.scalex->answer, "%lf", &scalex) != 1)
G_fatal_error(_("Invalid value for scalex"));
if (!parm.theta->answer)
G_fatal_error(_("When using anisotropy both theta and scalex must be specified"));
}
/*
* G_set_embedded_null_value_mode(1);
*/
outhd.ew_res = ew_res;
outhd.ns_res = ns_res;
outhd.east = winhd.east;
outhd.west = winhd.west;
outhd.north = winhd.north;
outhd.south = winhd.south;
outhd.proj = winhd.proj;
outhd.zone = winhd.zone;
G_adjust_Cell_head(&outhd, 0, 0);
ew_res = outhd.ew_res;
ns_res = outhd.ns_res;
nsizc = outhd.cols;
nsizr = outhd.rows;
disk = nsizc * nsizr * sizeof(int);
az = G_alloc_vector(nsizc + 1);
if (cond1) {
adx = G_alloc_vector(nsizc + 1);
ady = G_alloc_vector(nsizc + 1);
if (cond2) {
adxx = G_alloc_vector(nsizc + 1);
adyy = G_alloc_vector(nsizc + 1);
adxy = G_alloc_vector(nsizc + 1);
}
}
if (smooth != NULL) {
fdsmooth = Rast_open_old(smooth, "");
Rast_get_cellhd(smooth, "", &smhd);
if ((winhd.ew_res != smhd.ew_res) || (winhd.ns_res != smhd.ns_res))
G_fatal_error(_("Map <%s> is the wrong resolution"), smooth);
if (Rast_read_fp_range(smooth, "", &range) >= 0)
Rast_get_fp_range_min_max(&range, &cellmin, &cellmax);
fcellmin = (float)cellmin;
if (Rast_is_f_null_value(&fcellmin) || fcellmin < 0.0)
G_fatal_error(_("Smoothing values can not be negative or NULL"));
}
Rast_get_cellhd(input, "", &inphd);
if ((winhd.ew_res != inphd.ew_res) || (winhd.ns_res != inphd.ns_res))
G_fatal_error(_("Input map resolution differs from current region resolution!"));
fdinp = Rast_open_old(input, "");
sdisk = 0;
if (elev != NULL)
sdisk += disk;
if (slope != NULL)
sdisk += disk;
if (aspect != NULL)
sdisk += disk;
if (pcurv != NULL)
sdisk += disk;
if (tcurv != NULL)
sdisk += disk;
if (mcurv != NULL)
sdisk += disk;
G_message(_("Processing all selected output files will require"));
if (sdisk > 1024) {
if (sdisk > 1024 * 1024) {
if (sdisk > 1024 * 1024 * 1024) {
G_message(_("%.2f GB of disk space for temp files."), sdisk / (1024. * 1024. * 1024.));
}
else
G_message(_("%.2f MB of disk space for temp files."), sdisk / (1024. * 1024.));
}
else
G_message(_("%.2f KB of disk space for temp files."), sdisk / 1024.);
}
else
G_message(_("%d bytes of disk space for temp files."), sdisk);
fstar2 = fi * fi / 4.;
tfsta2 = fstar2 + fstar2;
deltx = winhd.east - winhd.west;
delty = winhd.north - winhd.south;
xmin = winhd.west;
xmax = winhd.east;
ymin = winhd.south;
ymax = winhd.north;
if (smooth != NULL)
smc = -9999;
else
smc = 0.01;
if (Rast_read_fp_range(input, "", &range) >= 0) {
Rast_get_fp_range_min_max(&range, &cellmin, &cellmax);
}
else {
cellrow = Rast_allocate_f_buf();
for (m1 = 0; m1 < inp_rows; m1++) {
Rast_get_f_row(fdinp, cellrow, m1);
Rast_row_update_fp_range(cellrow, m1, &range, FCELL_TYPE);
}
Rast_get_fp_range_min_max(&range, &cellmin, &cellmax);
}
fcellmin = (float)cellmin;
if (Rast_is_f_null_value(&fcellmin))
G_fatal_error(_("Maximum value of a raster map is NULL."));
zmin = (double)cellmin *zmult;
zmax = (double)cellmax *zmult;
G_debug(1, "zmin=%f, zmax=%f", zmin, zmax);
if (fd4 != NULL)
fprintf(fd4, "deltx,delty %f %f \n", deltx, delty);
create_temp_files();
IL_init_params_2d(¶ms, NULL, 1, 1, zmult, KMIN, KMAX, maskmap,
outhd.rows, outhd.cols, az, adx, ady, adxx, adyy, adxy,
fi, MAXPOINTS, SCIK1, SCIK2, SCIK3, smc, elev, slope,
aspect, pcurv, tcurv, mcurv, dmin, inp_x_orig,
inp_y_orig, deriv, theta, scalex, Tmp_fd_z, Tmp_fd_dx,
Tmp_fd_dy, Tmp_fd_xx, Tmp_fd_yy, Tmp_fd_xy, NULL, NULL,
0, NULL);
/* In the above line, the penultimate argument is supposed to be a
* deviations file pointer. None is obvious, so I used NULL. */
/* The 3rd and 4th argument are int-s, elatt and smatt (from the function
* definition. The value 1 seemed like a good placeholder... or not. */
IL_init_func_2d(¶ms, IL_grid_calc_2d, IL_matrix_create,
IL_check_at_points_2d,
IL_secpar_loop_2d, IL_crst, IL_crstg, IL_write_temp_2d);
G_message(_("Temporarily changing the region to desired resolution ..."));
Rast_set_window(&outhd);
bitmask = IL_create_bitmask(¶ms);
/* change region to initial region */
G_message(_("Changing back to the original region ..."));
Rast_set_window(&winhd);
ertot = 0.;
cursegm = 0;
G_message(_("Percent complete: "));
NPOINT =
IL_resample_interp_segments_2d(¶ms, bitmask, zmin, zmax, &zminac,
&zmaxac, &gmin, &gmax, &c1min, &c1max,
&c2min, &c2max, &ertot, nsizc, &dnorm,
overlap, inp_rows, inp_cols, fdsmooth,
fdinp, ns_res, ew_res, inp_ns_res,
inp_ew_res, dtens);
G_message(_("dnorm in mainc after grid before out1= %f"), dnorm);
if (NPOINT < 0) {
clean();
G_fatal_error(_("split_and_interpolate() failed"));
}
if (fd4 != NULL)
fprintf(fd4, "max. error found = %f \n", ertot);
G_free_vector(az);
if (cond1) {
G_free_vector(adx);
G_free_vector(ady);
if (cond2) {
G_free_vector(adxx);
G_free_vector(adyy);
G_free_vector(adxy);
}
}
G_message(_("dnorm in mainc after grid before out2= %f"), dnorm);
if (IL_resample_output_2d(¶ms, zmin, zmax, zminac, zmaxac, c1min,
c1max, c2min, c2max, gmin, gmax, ertot, input,
&dnorm, &outhd, &winhd, smooth, NPOINT) < 0) {
clean();
G_fatal_error(_("Unable to write raster maps -- try increasing cell size"));
}
G_free(zero_array_cell);
clean();
if (fd4)
fclose(fd4);
Rast_close(fdinp);
if (smooth != NULL)
Rast_close(fdsmooth);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int ret, level;
int stat, type, display;
int chcat;
int has_color, has_fcolor;
struct color_rgb color, fcolor;
double size;
int default_width;
double width_scale;
double minreg, maxreg, reg;
char map_name[GNAME_MAX];
struct GModule *module;
struct Option *map_opt;
struct Option *color_opt, *fcolor_opt, *rgbcol_opt, *zcol_opt;
struct Option *type_opt, *display_opt;
struct Option *icon_opt, *size_opt, *sizecolumn_opt, *rotcolumn_opt;
struct Option *where_opt;
struct Option *field_opt, *cat_opt, *lfield_opt;
struct Option *lcolor_opt, *bgcolor_opt, *bcolor_opt;
struct Option *lsize_opt, *font_opt, *enc_opt, *xref_opt, *yref_opt;
struct Option *attrcol_opt, *maxreg_opt, *minreg_opt;
struct Option *width_opt, *wcolumn_opt, *wscale_opt;
struct Option *leglab_opt;
struct Option *icon_line_opt, *icon_area_opt;
struct Flag *id_flag, *cats_acolors_flag, *sqrt_flag, *legend_flag;
char *desc;
struct cat_list *Clist;
LATTR lattr;
struct Map_info Map;
struct Cell_head window;
struct bound_box box;
double overlap;
stat = 0;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("graphics"));
G_add_keyword(_("vector"));
module->description = _("Displays user-specified vector map "
"in the active graphics frame.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
field_opt->answer = "1";
field_opt->guisection = _("Selection");
display_opt = G_define_option();
display_opt->key = "display";
display_opt->type = TYPE_STRING;
display_opt->required = YES;
display_opt->multiple = YES;
display_opt->answer = "shape";
display_opt->options = "shape,cat,topo,vert,dir,zcoor";
display_opt->description = _("Display");
desc = NULL;
G_asprintf(&desc,
"shape;%s;cat;%s;topo;%s;vert;%s;dir;%s;zcoor;%s",
_("Display geometry of features"),
_("Display category numbers of features"),
_("Display topology information (nodes, edges)"),
_("Display vertices of features"),
_("Display direction of linear features"),
_("Display z-coordinate of features (only for 3D vector maps)"));
display_opt->descriptions = desc;
/* Query */
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->answer = "point,line,area,face";
type_opt->options = "point,line,boundary,centroid,area,face";
type_opt->guisection = _("Selection");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
/* Colors */
color_opt = G_define_standard_option(G_OPT_CN);
color_opt->label = _("Feature color");
color_opt->guisection = _("Colors");
fcolor_opt = G_define_standard_option(G_OPT_CN);
fcolor_opt->key = "fill_color";
fcolor_opt->answer = "200:200:200";
fcolor_opt->label = _("Area fill color");
fcolor_opt->guisection = _("Colors");
rgbcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
rgbcol_opt->key = "rgb_column";
rgbcol_opt->guisection = _("Colors");
rgbcol_opt->label = _("Colorize features according color definition column");
rgbcol_opt->description = _("Color definition in R:G:B form");
zcol_opt = G_define_standard_option(G_OPT_M_COLR);
zcol_opt->key = "zcolor";
zcol_opt->description = _("Colorize point or area features according to z-coordinate");
zcol_opt->guisection = _("Colors");
/* Lines */
width_opt = G_define_option();
width_opt->key = "width";
width_opt->type = TYPE_INTEGER;
width_opt->answer = "0";
width_opt->guisection = _("Lines");
width_opt->description = _("Line width");
wcolumn_opt = G_define_standard_option(G_OPT_DB_COLUMN);
wcolumn_opt->key = "width_column";
wcolumn_opt->guisection = _("Lines");
wcolumn_opt->label = _("Name of numeric column containing line width");
wcolumn_opt->description = _("These values will be scaled by width_scale");
wscale_opt = G_define_option();
wscale_opt->key = "width_scale";
wscale_opt->type = TYPE_DOUBLE;
wscale_opt->answer = "1";
wscale_opt->guisection = _("Lines");
wscale_opt->description = _("Scale factor for width_column");
/* Symbols */
icon_opt = G_define_option();
icon_opt->key = "icon";
icon_opt->type = TYPE_STRING;
icon_opt->required = NO;
icon_opt->multiple = NO;
icon_opt->guisection = _("Symbols");
icon_opt->answer = "basic/x";
/* This could also use ->gisprompt = "old,symbol,symbol" instead of ->options */
icon_opt->options = icon_files();
icon_opt->description = _("Point and centroid symbol");
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->answer = "5";
size_opt->guisection = _("Symbols");
size_opt->label = _("Symbol size");
size_opt->description =
_("When used with the size_column option this becomes the scale factor");
sizecolumn_opt = G_define_standard_option(G_OPT_DB_COLUMN);
sizecolumn_opt->key = "size_column";
sizecolumn_opt->guisection = _("Symbols");
sizecolumn_opt->description =
_("Name of numeric column containing symbol size");
rotcolumn_opt = G_define_standard_option(G_OPT_DB_COLUMN);
rotcolumn_opt->key = "rotation_column";
rotcolumn_opt->guisection = _("Symbols");
rotcolumn_opt->label =
_("Name of numeric column containing symbol rotation angle");
rotcolumn_opt->description =
_("Measured in degrees CCW from east");
icon_area_opt = G_define_option();
icon_area_opt->key = "icon_area";
icon_area_opt->type = TYPE_STRING;
icon_area_opt->required = NO;
icon_area_opt->multiple = NO;
icon_area_opt->guisection = _("Legend");
icon_area_opt->answer = "legend/area";
icon_area_opt->options = icon_files();
icon_area_opt->description = _("Area/boundary symbol for legend");
icon_line_opt = G_define_option();
icon_line_opt->key = "icon_line";
icon_line_opt->type = TYPE_STRING;
icon_line_opt->required = NO;
icon_line_opt->multiple = NO;
icon_line_opt->guisection = _("Legend");
icon_line_opt->answer = "legend/line";
icon_line_opt->options = icon_files();
icon_line_opt->description = _("Line symbol for legend");
leglab_opt = G_define_option();
leglab_opt->key = "legend_label";
leglab_opt->type = TYPE_STRING;
leglab_opt->guisection = _("Legend");
leglab_opt->description = _("Label to display after symbol in vector legend");
/* Labels */
lfield_opt = G_define_standard_option(G_OPT_V_FIELD);
lfield_opt->key = "label_layer";
lfield_opt->required = NO;
lfield_opt->guisection = _("Labels");
lfield_opt->label =
_("Layer number for labels (default: the given layer number)");
attrcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
attrcol_opt->key = "attribute_column";
attrcol_opt->multiple = NO; /* or fix attr.c, around line 102 */
attrcol_opt->guisection = _("Labels");
attrcol_opt->description = _("Name of column to be displayed as a label");
lcolor_opt = G_define_standard_option(G_OPT_C);
lcolor_opt->key = "label_color";
lcolor_opt->answer = "red";
lcolor_opt->label = _("Label color");
lcolor_opt->guisection = _("Labels");
bgcolor_opt = G_define_standard_option(G_OPT_CN);
bgcolor_opt->key = "label_bgcolor";
bgcolor_opt->answer = "none";
bgcolor_opt->guisection = _("Labels");
bgcolor_opt->label = _("Label background color");
bcolor_opt = G_define_standard_option(G_OPT_CN);
bcolor_opt->key = "label_bcolor";
bcolor_opt->type = TYPE_STRING;
bcolor_opt->answer = "none";
bcolor_opt->guisection = _("Labels");
bcolor_opt->label = _("Label border color");
lsize_opt = G_define_option();
lsize_opt->key = "label_size";
lsize_opt->type = TYPE_INTEGER;
lsize_opt->answer = "8";
lsize_opt->guisection = _("Labels");
lsize_opt->description = _("Label size (pixels)");
font_opt = G_define_option();
font_opt->key = "font";
font_opt->type = TYPE_STRING;
font_opt->guisection = _("Labels");
font_opt->description = _("Font name");
enc_opt = G_define_option();
enc_opt->key = "encoding";
enc_opt->type = TYPE_STRING;
enc_opt->guisection = _("Labels");
enc_opt->description = _("Text encoding");
xref_opt = G_define_option();
xref_opt->key = "xref";
xref_opt->type = TYPE_STRING;
xref_opt->guisection = _("Labels");
xref_opt->answer = "left";
xref_opt->options = "left,center,right";
xref_opt->description = _("Label horizontal justification");
yref_opt = G_define_option();
yref_opt->key = "yref";
yref_opt->type = TYPE_STRING;
yref_opt->guisection = _("Labels");
yref_opt->answer = "center";
yref_opt->options = "top,center,bottom";
yref_opt->description = _("Label vertical justification");
minreg_opt = G_define_option();
minreg_opt->key = "minreg";
minreg_opt->type = TYPE_DOUBLE;
minreg_opt->required = NO;
minreg_opt->description =
_("Minimum region size (average from height and width) "
"when map is displayed");
maxreg_opt = G_define_option();
maxreg_opt->key = "maxreg";
maxreg_opt->type = TYPE_DOUBLE;
maxreg_opt->required = NO;
maxreg_opt->description =
_("Maximum region size (average from height and width) "
"when map is displayed");
/* Colors */
cats_acolors_flag = G_define_flag();
cats_acolors_flag->key = 'c';
cats_acolors_flag->guisection = _("Colors");
cats_acolors_flag->description =
_("Random colors according to category number "
"(or layer number if 'layer=-1' is given)");
/* Query */
id_flag = G_define_flag();
id_flag->key = 'i';
id_flag->guisection = _("Selection");
id_flag->description = _("Use values from 'cats' option as feature id");
sqrt_flag = G_define_flag();
sqrt_flag->key = 'r';
sqrt_flag->label = _("Use square root of the value of size_column");
sqrt_flag->description =
_("This makes circle areas proportionate to the size_column values "
"instead of circle radius");
sqrt_flag->guisection = _("Symbols");
legend_flag = G_define_flag();
legend_flag->key = 's';
legend_flag->label = _("Do not show this layer in vector legend");
legend_flag->guisection = _("Legend");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
D_open_driver();
G_get_set_window(&window);
/* Check min/max region */
reg = ((window.east - window.west) + (window.north - window.south)) / 2;
if (minreg_opt->answer) {
minreg = atof(minreg_opt->answer);
if (reg < minreg) {
G_important_message(_("Region size is lower than minreg, nothing displayed"));
exit(EXIT_SUCCESS);
}
}
if (maxreg_opt->answer) {
maxreg = atof(maxreg_opt->answer);
if (reg > maxreg) {
G_important_message(_("Region size is greater than maxreg, nothing displayed"));
exit(EXIT_SUCCESS);
}
}
strcpy(map_name, map_opt->answer);
default_width = atoi(width_opt->answer);
if (default_width < 0)
default_width = 0;
width_scale = atof(wscale_opt->answer);
if (cats_acolors_flag->answer && rgbcol_opt->answer) {
G_warning(_("The -%c flag and <%s> option cannot be used together, "
"the -%c flag will be ignored!"),
cats_acolors_flag->key, rgbcol_opt->key, cats_acolors_flag->key);
cats_acolors_flag->answer = FALSE;
}
color = G_standard_color_rgb(WHITE);
has_color = option_to_color(&color, color_opt->answer);
fcolor = G_standard_color_rgb(WHITE);
has_fcolor = option_to_color(&fcolor, fcolor_opt->answer);
size = atof(size_opt->answer);
/* if where_opt was specified select categories from db
* otherwise parse cat_opt */
Clist = Vect_new_cat_list();
Clist->field = atoi(field_opt->answer);
/* open vector */
level = Vect_open_old2(&Map, map_name, "", field_opt->answer);
chcat = 0;
if (where_opt->answer) {
if (Clist->field < 1)
G_fatal_error(_("Option <%s> must be > 0"), field_opt->key);
chcat = 1;
option_to_where(&Map, Clist, where_opt->answer);
}
else if (cat_opt->answer) {
if (Clist->field < 1 && !id_flag->answer)
G_fatal_error(_("Option <%s> must be > 0"), field_opt->key);
chcat = 1;
ret = Vect_str_to_cat_list(cat_opt->answer, Clist);
if (ret > 0)
G_warning(n_("%d error in cat option", "%d errors in cat option", ret), ret);
}
type = Vect_option_to_types(type_opt);
display = option_to_display(display_opt);
/* labels */
options_to_lattr(&lattr, lfield_opt->answer,
lcolor_opt->answer, bgcolor_opt->answer, bcolor_opt->answer,
atoi(lsize_opt->answer), font_opt->answer, enc_opt->answer,
xref_opt->answer, yref_opt->answer);
D_setup(0);
D_set_reduction(1.0);
G_verbose_message(_("Plotting..."));
if (level >= 2)
Vect_get_map_box(&Map, &box);
if (level >= 2 && (window.north < box.S || window.south > box.N ||
window.east < box.W ||
window.west > G_adjust_easting(box.E, &window))) {
G_warning(_("The bounding box of the map is outside the current region, "
"nothing drawn"));
}
else {
overlap = G_window_percentage_overlap(&window, box.N, box.S,
box.E, box.W);
G_debug(1, "overlap = %f \n", overlap);
if (overlap < 1)
Vect_set_constraint_region(&Map, window.north, window.south,
window.east, window.west,
PORT_DOUBLE_MAX, -PORT_DOUBLE_MAX);
/* default line width */
if (!wcolumn_opt->answer)
D_line_width(default_width);
if (display & DISP_SHAPE) {
stat += display_shape(&Map, type, Clist, &window,
has_color ? &color : NULL, has_fcolor ? &fcolor : NULL, chcat,
icon_opt->answer, size, sizecolumn_opt->answer,
sqrt_flag->answer ? TRUE : FALSE, rotcolumn_opt->answer,
id_flag->answer ? TRUE : FALSE,
cats_acolors_flag->answer ? TRUE : FALSE, rgbcol_opt->answer,
default_width, wcolumn_opt->answer, width_scale,
zcol_opt->answer);
if (wcolumn_opt->answer)
D_line_width(default_width);
}
if (has_color) {
D_RGB_color(color.r, color.g, color.b);
if (display & DISP_DIR)
stat += display_dir(&Map, type, Clist, chcat, size);
}
if (!legend_flag->answer) {
write_into_legfile(&Map, type, leglab_opt->answer, map_name,
icon_opt->answer, size_opt->answer,
color_opt->answer, fcolor_opt->answer,
width_opt->answer, icon_area_opt->answer,
icon_line_opt->answer, sizecolumn_opt->answer);
}
/* reset line width: Do we need to get line width from display
* driver (not implemented)? It will help restore previous line
* width (not just 0) determined by another module (e.g.,
* d.linewidth). */
if (!wcolumn_opt->answer)
D_line_width(0);
if (display & DISP_CAT)
stat += display_label(&Map, type, Clist, &lattr, chcat);
if (attrcol_opt->answer)
stat += display_attr(&Map, type, attrcol_opt->answer, Clist, &lattr, chcat);
if (display & DISP_ZCOOR)
stat += display_zcoor(&Map, type, &lattr);
if (display & DISP_VERT)
stat += display_vert(&Map, type, &lattr, size);
if (display & DISP_TOPO)
stat += display_topo(&Map, type, &lattr, size);
}
D_save_command(G_recreate_command());
D_close_driver();
Vect_close(&Map);
Vect_destroy_cat_list(Clist);
if (stat != 0) {
G_fatal_error(_("Rendering failed"));
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *rastin, *rastout, *method;
struct History history;
char title[64];
char buf_nsres[100], buf_ewres[100];
struct Colors colors;
char *inmap;
int infile, outfile;
DCELL *outbuf;
int row, col;
struct Cell_head dst_w, src_w;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, resample");
module->description =
_("Resamples raster map layers to a finer grid using interpolation.");
rastin = G_define_standard_option(G_OPT_R_INPUT);
rastout = G_define_standard_option(G_OPT_R_OUTPUT);
method = G_define_option();
method->key = "method";
method->type = TYPE_STRING;
method->required = NO;
method->description = _("Interpolation method");
method->options = "nearest,bilinear,bicubic";
method->answer = "bilinear";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (G_strcasecmp(method->answer, "nearest") == 0)
neighbors = 1;
else if (G_strcasecmp(method->answer, "bilinear") == 0)
neighbors = 2;
else if (G_strcasecmp(method->answer, "bicubic") == 0)
neighbors = 4;
else
G_fatal_error(_("Invalid method: %s"), method->answer);
G_get_set_window(&dst_w);
inmap = G_find_cell2(rastin->answer, "");
if (!inmap)
G_fatal_error(_("Raster map <%s> not found"), rastin->answer);
/* set window to old map */
G_get_cellhd(rastin->answer, inmap, &src_w);
/* enlarge source window */
{
double north = G_row_to_northing(0.5, &dst_w);
double south = G_row_to_northing(dst_w.rows - 0.5, &dst_w);
int r0 = (int)floor(G_northing_to_row(north, &src_w) - 0.5) - 1;
int r1 = (int)floor(G_northing_to_row(south, &src_w) - 0.5) + 3;
double west = G_col_to_easting(0.5, &dst_w);
double east = G_col_to_easting(dst_w.cols - 0.5, &dst_w);
int c0 = (int)floor(G_easting_to_col(west, &src_w) - 0.5) - 1;
int c1 = (int)floor(G_easting_to_col(east, &src_w) - 0.5) + 3;
src_w.south -= src_w.ns_res * (r1 - src_w.rows);
src_w.north += src_w.ns_res * (-r0);
src_w.west -= src_w.ew_res * (-c0);
src_w.east += src_w.ew_res * (c1 - src_w.cols);
src_w.rows = r1 - r0;
src_w.cols = c1 - c0;
}
G_set_window(&src_w);
/* allocate buffers for input rows */
for (row = 0; row < neighbors; row++)
bufs[row] = G_allocate_d_raster_buf();
cur_row = -100;
/* open old map */
infile = G_open_cell_old(rastin->answer, inmap);
if (infile < 0)
G_fatal_error(_("Unable to open raster map <%s>"), rastin->answer);
/* reset window to current region */
G_set_window(&dst_w);
outbuf = G_allocate_d_raster_buf();
/* open new map */
outfile = G_open_raster_new(rastout->answer, DCELL_TYPE);
if (outfile < 0)
G_fatal_error(_("Unable to create raster map <%s>"), rastout->answer);
G_suppress_warnings(1);
/* otherwise get complaints about window changes */
switch (neighbors) {
case 1: /* nearest */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow0 = (int)floor(maprow_f + 0.5);
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol0 = (int)floor(mapcol_f + 0.5);
double c = bufs[0][mapcol0];
if (G_is_d_null_value(&c)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = c;
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
case 2: /* bilinear */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow0 = (int)floor(maprow_f);
double v = maprow_f - maprow0;
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol0 = (int)floor(mapcol_f);
int mapcol1 = mapcol0 + 1;
double u = mapcol_f - mapcol0;
double c00 = bufs[0][mapcol0];
double c01 = bufs[0][mapcol1];
double c10 = bufs[1][mapcol0];
double c11 = bufs[1][mapcol1];
if (G_is_d_null_value(&c00) ||
G_is_d_null_value(&c01) ||
G_is_d_null_value(&c10) || G_is_d_null_value(&c11)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = G_interp_bilinear(u, v, c00, c01, c10, c11);
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
case 4: /* bicubic */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow1 = (int)floor(maprow_f);
int maprow0 = maprow1 - 1;
double v = maprow_f - maprow1;
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol1 = (int)floor(mapcol_f);
int mapcol0 = mapcol1 - 1;
int mapcol2 = mapcol1 + 1;
int mapcol3 = mapcol1 + 2;
double u = mapcol_f - mapcol1;
double c00 = bufs[0][mapcol0];
double c01 = bufs[0][mapcol1];
double c02 = bufs[0][mapcol2];
double c03 = bufs[0][mapcol3];
double c10 = bufs[1][mapcol0];
double c11 = bufs[1][mapcol1];
double c12 = bufs[1][mapcol2];
double c13 = bufs[1][mapcol3];
double c20 = bufs[2][mapcol0];
double c21 = bufs[2][mapcol1];
double c22 = bufs[2][mapcol2];
double c23 = bufs[2][mapcol3];
double c30 = bufs[3][mapcol0];
double c31 = bufs[3][mapcol1];
double c32 = bufs[3][mapcol2];
double c33 = bufs[3][mapcol3];
if (G_is_d_null_value(&c00) ||
G_is_d_null_value(&c01) ||
G_is_d_null_value(&c02) ||
G_is_d_null_value(&c03) ||
G_is_d_null_value(&c10) ||
G_is_d_null_value(&c11) ||
G_is_d_null_value(&c12) ||
G_is_d_null_value(&c13) ||
G_is_d_null_value(&c20) ||
G_is_d_null_value(&c21) ||
G_is_d_null_value(&c22) ||
G_is_d_null_value(&c23) ||
G_is_d_null_value(&c30) ||
G_is_d_null_value(&c31) ||
G_is_d_null_value(&c32) || G_is_d_null_value(&c33)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = G_interp_bicubic(u, v,
c00, c01, c02, c03,
c10, c11, c12, c13,
c20, c21, c22, c23,
c30, c31, c32, c33);
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
}
G_percent(dst_w.rows, dst_w.rows, 2);
G_close_cell(infile);
G_close_cell(outfile);
/* record map metadata/history info */
sprintf(title, "Resample by %s interpolation", method->answer);
G_put_cell_title(rastout->answer, title);
G_short_history(rastout->answer, "raster", &history);
strncpy(history.datsrc_1, rastin->answer, RECORD_LEN);
history.datsrc_1[RECORD_LEN - 1] = '\0'; /* strncpy() doesn't null terminate if maxfill */
G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj);
G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj);
sprintf(history.datsrc_2, "Source map NS res: %s EW res: %s", buf_nsres,
buf_ewres);
G_command_history(&history);
G_write_history(rastout->answer, &history);
/* copy color table from source map */
if (G_read_colors(rastin->answer, inmap, &colors) < 0)
G_fatal_error(_("Unable to read color table for %s"), rastin->answer);
G_mark_colors_as_fp(&colors);
if (G_write_colors(rastout->answer, G_mapset(), &colors) < 0)
G_fatal_error(_("Unable to write color table for %s"),
rastout->answer);
return (EXIT_SUCCESS);
}
/*--------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variables declarations */
int nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
double N_extension, E_extension, edgeE, edgeN;
int dim_vect, nparameters, BW, npoints;
double mean, lambda;
const char *dvr, *db, *mapset;
char table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int last_row, last_column, flag_auxiliar = FALSE;
int filter_mode;
int *lineVect;
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
/* Structs declarations */
struct Map_info In, Out, Outlier, Qgis;
struct Option *in_opt, *out_opt, *outlier_opt, *qgis_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *Thres_O_opt, *filter_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Reg_dimens dims;
struct Cell_head elaboration_reg, original_reg;
struct bound_box general_box, overlap_box;
struct Point *observ;
dbDriver *driver;
/*----------------------------------------------------------------*/
/* Options declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("extract"));
G_add_keyword(_("select"));
G_add_keyword(_("filter"));
module->description = _("Removes outliers from vector point data.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
outlier_opt = G_define_option();
outlier_opt->key = "outlier";
outlier_opt->type = TYPE_STRING;
outlier_opt->key_desc = "name";
outlier_opt->required = YES;
outlier_opt->gisprompt = "new,vector,vector";
outlier_opt->description = _("Name of output outlier vector map");
qgis_opt = G_define_option();
qgis_opt->key = "qgis";
qgis_opt->type = TYPE_STRING;
qgis_opt->key_desc = "name";
qgis_opt->required = NO;
qgis_opt->gisprompt = "new,vector,vector";
qgis_opt->description = _("Name of vector map for visualization in QGIS");
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "10";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "10";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description = _("Tykhonov regularization weight");
lambda_f_opt->answer = "0.1";
lambda_f_opt->guisection = _("Settings");
Thres_O_opt = G_define_option();
Thres_O_opt->key = "threshold";
Thres_O_opt->type = TYPE_DOUBLE;
Thres_O_opt->required = NO;
Thres_O_opt->description = _("Threshold for the outliers");
Thres_O_opt->answer = "50";
filter_opt = G_define_option();
filter_opt->key = "filter";
filter_opt->type = TYPE_STRING;
filter_opt->required = NO;
filter_opt->description = _("Filtering option");
filter_opt->options = "both,positive,negative";
filter_opt->answer = "both";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!(db = G_getenv_nofatal2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G_getenv_nofatal2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
Thres_Outlier = atof(Thres_O_opt->answer);
filter_mode = 0;
if (strcmp(filter_opt->answer, "positive") == 0)
filter_mode = 1;
else if (strcmp(filter_opt->answer, "negative") == 0)
filter_mode = -1;
P_set_outlier_fn(filter_mode);
flag_auxiliar = FALSE;
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
}
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
/* Something went wrong in a previous v.outlier execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Open input vector */
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (qgis_opt->answer)
if (0 > Vect_open_new(&Qgis, qgis_opt->answer, WITHOUT_Z))
G_fatal_error(_("Unable to create vector map <%s>"),
qgis_opt->answer);
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&Qgis);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
if (0 > Vect_open_new(&Outlier, outlier_opt->answer, WITH_Z)) {
Vect_close(&Out);
Vect_close(&Qgis);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_head_data(&In, &Outlier);
Vect_hist_copy(&In, &Outlier);
Vect_hist_command(&Outlier);
if (qgis_opt->answer) {
Vect_copy_head_data(&In, &Qgis);
Vect_hist_copy(&In, &Qgis);
Vect_hist_command(&Qgis);
}
/* Open driver and database */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar table */
if ((flag_auxiliar =
P_Create_Aux2_Table(driver, table_name)) == FALSE)
G_fatal_error(_("It was impossible to create <%s> table."), table_name);
db_create_index2(driver, table_name, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims); /* Set dim struct to zero */
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BILINEAR, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("Adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("Adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
/*
if (nsply > NSPLY_MAX)
nsply = NSPLY_MAX;
*/
G_debug(1, "nsply = %d", nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("Processing subregion %d of %d..."), subregion, nsubregions);
else /* v.outlier -e will report mean point distance: */
G_warning(_("No subregions found! Check values for 'ew_step' and 'ns_step' parameters"));
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east -
elaboration_reg.west) / stepE) + 0.5;
/*
if (nsplx > NSPLX_MAX)
nsplx = NSPLX_MAX;
*/
G_debug(1, "nsplx = %d", nsplx);
/*Setting the active region */
dim_vect = nsplx * nsply;
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, 1);
if (npoints > 0) { /* If there is any point falling into elaboration_reg... */
int i;
nparameters = nsplx * nsply;
/* Mean calculation */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/* Least Squares system */
G_debug(1, "Allocation memory for bilinear interpolation");
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Bicubic parameters vector */
obsVect = G_alloc_matrix(npoints, 3); /* Observation vector */
Q = G_alloc_vector(npoints); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints);
/* Setting obsVect vector & Q matrix */
for (i = 0; i < npoints; i++) {
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
obsVect[i][2] = observ[i].coordZ - mean;
lineVect[i] = observ[i].lineID;
Q[i] = 1; /* Q=I */
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints, nparameters,
BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_verbose_message(_("Outlier detection"));
if (qgis_opt->answer)
P_Outlier(&Out, &Outlier, &Qgis, elaboration_reg,
general_box, overlap_box, obsVect, parVect,
mean, dims.overlap, lineVect, npoints,
driver, table_name);
else
P_Outlier(&Out, &Outlier, NULL, elaboration_reg,
general_box, overlap_box, obsVect, parVect,
mean, dims.overlap, lineVect, npoints,
driver, table_name);
G_free_vector(parVect);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
} /*! END IF; npoints > 0 */
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider increasing spline step values."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Drop auxiliar table */
if (npoints > 0) {
G_debug(1, "%s: Dropping <%s>", argv[0], table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliary table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Outlier);
if (qgis_opt->answer) {
Vect_build(&Qgis);
Vect_close(&Qgis);
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*END MAIN */
/*----------------------------------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Declarations */
int dim_vect, nparameters, BW, npoints;
int nsply, nsplx, nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
const char *dvr, *db, *mapset;
char table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
double lambda, mean, stepN, stepE, HighThresh,
LowThresh;
double N_extension, E_extension, edgeE, edgeN;
int i, nterrain, count_terrain;
int last_row, last_column, flag_auxiliar = FALSE;
int *lineVect;
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect, **obsVect_all; /* Interpolation and least-square matrix */
struct Map_info In, Out, Terrain;
struct Option *in_opt, *out_opt, *out_terrain_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *Thresh_A_opt, *Thresh_B_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Cell_head elaboration_reg, original_reg;
struct Reg_dimens dims;
struct bound_box general_box, overlap_box;
struct Point *observ;
struct lidar_cat *lcat;
dbDriver *driver;
/*----------------------------------------------------------------------------------------------------------*/
/* Options' declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
module->description =
_("Corrects the v.lidar.growing output. It is the last of the three algorithms for LIDAR filtering.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description =
_("Input observation vector map name (v.lidar.growing output)");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->description = _("Output classified vector map name");
out_terrain_opt = G_define_option();
out_terrain_opt->key = "terrain";
out_terrain_opt->type = TYPE_STRING;
out_terrain_opt->key_desc = "name";
out_terrain_opt->required = YES;
out_terrain_opt->gisprompt = "new,vector,vector";
out_terrain_opt->description =
_("Only 'terrain' points output vector map");
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "25";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "25";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda_c";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description =
_("Regularization weight in reclassification evaluation");
lambda_f_opt->answer = "1";
Thresh_A_opt = G_define_option();
Thresh_A_opt->key = "tch";
Thresh_A_opt->type = TYPE_DOUBLE;
Thresh_A_opt->required = NO;
Thresh_A_opt->description =
_("High threshold for object to terrain reclassification");
Thresh_A_opt->answer = "2";
Thresh_B_opt = G_define_option();
Thresh_B_opt->key = "tcl";
Thresh_B_opt->type = TYPE_DOUBLE;
Thresh_B_opt->required = NO;
Thresh_B_opt->description =
_("Low threshold for terrain to object reclassification");
Thresh_B_opt->answer = "1";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
HighThresh = atof(Thresh_A_opt->answer);
LowThresh = atof(Thresh_B_opt->answer);
if (!(db = G_getenv_nofatal2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G_getenv_nofatal2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
/* Something went wrong in a previous v.lidar.correction execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
/* Open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(1); /* without topology */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
if (0 > Vect_open_new(&Terrain, out_terrain_opt->answer, WITH_Z)) {
Vect_close(&In);
Vect_close(&Out);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_head_data(&In, &Terrain);
Vect_hist_copy(&In, &Terrain);
Vect_hist_command(&Terrain);
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar table */
if ((flag_auxiliar =
P_Create_Aux2_Table(driver, table_name)) == FALSE) {
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Terrain);
exit(EXIT_FAILURE);
}
db_create_index2(driver, table_name, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims);
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BILINEAR, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(n_("adjusted EW spline %d",
"adjusted EW splines %d",
nsplx_adj), nsplx_adj);
G_verbose_message(n_("adjusted NS spline %d",
"adjusted NS splines %d",
nsply_adj), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
/*
if (nsply > NSPLY_MAX) {
nsply = NSPLY_MAX;
}
*/
G_debug(1, _("nsply = %d"), nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east - elaboration_reg.west) / stepE) +
0.5;
/*
if (nsplx > NSPLX_MAX) {
nsplx = NSPLX_MAX;
}
*/
G_debug(1, _("nsplx = %d"), nsplx);
dim_vect = nsplx * nsply;
G_debug(1, _("read vector region map"));
observ =
P_Read_Vector_Correction(&In, &elaboration_reg, &npoints,
&nterrain, dim_vect, &lcat);
G_debug(5, _("npoints = %d, nterrain = %d"), npoints, nterrain);
if (npoints > 0) { /* If there is any point falling into elaboration_reg. */
count_terrain = 0;
nparameters = nsplx * nsply;
/* Mean calculation */
G_debug(3, _("Mean calculation"));
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/*Least Squares system */
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Bilinear parameters vector */
obsVect = G_alloc_matrix(nterrain + 1, 3); /* Observation vector with terrain points */
obsVect_all = G_alloc_matrix(npoints + 1, 3); /* Observation vector with all points */
Q = G_alloc_vector(nterrain + 1); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints + 1);
/* Setting obsVect vector & Q matrix */
G_debug(3, _("Only TERRAIN points"));
for (i = 0; i < npoints; i++) {
if (observ[i].cat == TERRAIN_SINGLE) {
obsVect[count_terrain][0] = observ[i].coordX;
obsVect[count_terrain][1] = observ[i].coordY;
obsVect[count_terrain][2] = observ[i].coordZ - mean;
Q[count_terrain] = 1; /* Q=I */
count_terrain++;
}
lineVect[i] = observ[i].lineID;
obsVect_all[i][0] = observ[i].coordX;
obsVect_all[i][1] = observ[i].coordY;
obsVect_all[i][2] = observ[i].coordZ - mean;
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, nterrain, nparameters,
BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_free_matrix(obsVect);
G_verbose_message( _("Correction and creation of terrain vector"));
P_Sparse_Correction(&In, &Out, &Terrain, &elaboration_reg,
general_box, overlap_box, obsVect_all, lcat,
parVect, lineVect, stepN, stepE,
dims.overlap, HighThresh, LowThresh,
nsplx, nsply, npoints, driver, mean, table_name);
G_free_vector(parVect);
G_free_matrix(obsVect_all);
G_free_ivector(lineVect);
}
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider changing the spline step."));
}
G_free(lcat);
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Dropping auxiliar table */
if (npoints > 0) {
G_debug(1, _("Dropping <%s>"), table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliar table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Terrain);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*! END MAIN */
int main(int argc, char *argv[])
{
struct GModule *module;
int infile;
const char *mapset;
size_t cell_size;
int ytile, xtile, y, overlap;
int *outfiles;
void *inbuf;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("tiling"));
module->description =
_("Splits a raster map into tiles.");
parm.rastin = G_define_standard_option(G_OPT_R_INPUT);
parm.rastout = G_define_option();
parm.rastout->key = "output";
parm.rastout->type = TYPE_STRING;
parm.rastout->required = YES;
parm.rastout->multiple = NO;
parm.rastout->description = _("Output base name");
parm.width = G_define_option();
parm.width->key = "width";
parm.width->type = TYPE_INTEGER;
parm.width->required = YES;
parm.width->multiple = NO;
parm.width->description = _("Width of tiles (columns)");
parm.height = G_define_option();
parm.height->key = "height";
parm.height->type = TYPE_INTEGER;
parm.height->required = YES;
parm.height->multiple = NO;
parm.height->description = _("Height of tiles (rows)");
parm.overlap = G_define_option();
parm.overlap->key = "overlap";
parm.overlap->type = TYPE_INTEGER;
parm.overlap->required = NO;
parm.overlap->multiple = NO;
parm.overlap->description = _("Overlap of tiles");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&src_w);
overlap = parm.overlap->answer ? atoi(parm.overlap->answer) : 0;
mapset = G_find_raster2(parm.rastin->answer, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), parm.rastin->answer);
/* set window to old map */
Rast_get_cellhd(parm.rastin->answer, "", &src_w);
dst_w = src_w;
dst_w.cols = atoi(parm.width->answer);
dst_w.rows = atoi(parm.height->answer);
G_adjust_Cell_head(&dst_w, 1, 1);
xtiles = (src_w.cols + dst_w.cols - 1) / dst_w.cols;
ytiles = (src_w.rows + dst_w.rows - 1) / dst_w.rows;
G_debug(1, "X: %d * %d, Y: %d * %d",
xtiles, dst_w.cols, ytiles, dst_w.rows);
src_w.cols = xtiles * dst_w.cols + 2 * overlap;
src_w.rows = ytiles * dst_w.rows + 2 * overlap;
src_w.west = src_w.west - overlap * src_w.ew_res;
src_w.east = src_w.west + (src_w.cols + 2 * overlap) * src_w.ew_res;
src_w.north = src_w.north + overlap * src_w.ns_res;
src_w.south = src_w.north - (src_w.rows + 2 * overlap) * src_w.ns_res;
Rast_set_input_window(&src_w);
/* set the output region */
ovl_w = dst_w;
ovl_w.cols = ovl_w.cols + 2 * overlap;
ovl_w.rows = ovl_w.rows + 2 * overlap;
G_adjust_Cell_head(&ovl_w, 1, 1);
Rast_set_output_window(&ovl_w);
infile = Rast_open_old(parm.rastin->answer, "");
map_type = Rast_get_map_type(infile);
cell_size = Rast_cell_size(map_type);
inbuf = Rast_allocate_input_buf(map_type);
outfiles = G_malloc(xtiles * sizeof(int));
G_debug(1, "X: %d * %d, Y: %d * %d",
xtiles, dst_w.cols, ytiles, dst_w.rows);
G_message(_("Generating %d x %d = %d tiles..."), xtiles, ytiles, xtiles * ytiles);
for (ytile = 0; ytile < ytiles; ytile++) {
G_debug(1, "reading y tile: %d", ytile);
G_percent(ytile, ytiles, 2);
for (xtile = 0; xtile < xtiles; xtile++) {
char name[GNAME_MAX];
sprintf(name, "%s-%03d-%03d", parm.rastout->answer, ytile, xtile);
outfiles[xtile] = Rast_open_new(name, map_type);
}
for (y = 0; y < ovl_w.rows; y++) {
int row = ytile * dst_w.rows + y;
G_debug(1, "reading row: %d", row);
Rast_get_row(infile, inbuf, row, map_type);
for (xtile = 0; xtile < xtiles; xtile++) {
int cells = xtile * dst_w.cols;
void *ptr = G_incr_void_ptr(inbuf, cells * cell_size);
Rast_put_row(outfiles[xtile], ptr, map_type);
}
}
for (xtile = 0; xtile < xtiles; xtile++) {
Rast_close(outfiles[xtile]);
write_support_files(xtile, ytile, overlap);
}
}
Rast_close(infile);
return EXIT_SUCCESS;
}
int close_streamvect(char *stream_vect)
{
int r, c, r_nbr, c_nbr, done;
GW_LARGE_INT i;
CELL stream_id, stream_nbr;
ASP_FLAG af;
int next_node;
struct sstack
{
int stream_id;
int next_trib;
} *nodestack;
int top = 0, stack_step = 1000;
int asp_r[9] = { 0, -1, -1, -1, 0, 1, 1, 1, 0 };
int asp_c[9] = { 0, 1, 0, -1, -1, -1, 0, 1, 1 };
struct Map_info Out;
static struct line_pnts *Points;
struct line_cats *Cats;
dbDriver *driver;
dbHandle handle;
dbString table_name, dbsql, valstr;
struct field_info *Fi;
char *cat_col_name = "cat", buf[2000];
struct Cell_head window;
double north_offset, west_offset, ns_res, ew_res;
int next_cat;
G_message(_("Writing vector map <%s>..."), stream_vect);
if (Vect_open_new(&Out, stream_vect, 0) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), stream_vect);
nodestack = (struct sstack *)G_malloc(stack_step * sizeof(struct sstack));
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
G_get_set_window(&window);
ns_res = window.ns_res;
ew_res = window.ew_res;
north_offset = window.north - 0.5 * ns_res;
west_offset = window.west + 0.5 * ew_res;
next_cat = n_stream_nodes + 1;
for (i = 0; i < n_outlets; i++, next_cat++) {
G_percent(i, n_outlets, 2);
r = outlets[i].r;
c = outlets[i].c;
cseg_get(&stream, &stream_id, r, c);
if (!stream_id)
continue;
Vect_reset_line(Points);
Vect_reset_cats(Cats);
/* outlet */
Vect_cat_set(Cats, 1, stream_id);
Vect_cat_set(Cats, 2, 2);
Vect_append_point(Points, west_offset + c * ew_res,
north_offset - r * ns_res, 0);
Vect_write_line(&Out, GV_POINT, Points, Cats);
/* add root node to stack */
G_debug(3, "add root node");
top = 0;
nodestack[top].stream_id = stream_id;
nodestack[top].next_trib = 0;
/* depth first post order traversal */
G_debug(3, "traverse");
while (top >= 0) {
done = 1;
stream_id = nodestack[top].stream_id;
G_debug(3, "stream_id %d", stream_id);
if (nodestack[top].next_trib < stream_node[stream_id].n_trib) {
/* add to stack */
next_node =
stream_node[stream_id].trib[nodestack[top].next_trib];
G_debug(3, "add to stack: next %d, trib %d, n trib %d",
next_node, nodestack[top].next_trib,
stream_node[stream_id].n_trib);
nodestack[top].next_trib++;
top++;
if (top >= stack_step) {
/* need more space */
stack_step += 1000;
nodestack =
(struct sstack *)G_realloc(nodestack,
stack_step *
sizeof(struct sstack));
}
nodestack[top].next_trib = 0;
nodestack[top].stream_id = next_node;
done = 0;
G_debug(3, "go further down");
}
if (done) {
G_debug(3, "write stream segment");
Vect_reset_line(Points);
Vect_reset_cats(Cats);
r_nbr = stream_node[stream_id].r;
c_nbr = stream_node[stream_id].c;
cseg_get(&stream, &stream_nbr, r_nbr, c_nbr);
if (stream_nbr <= 0)
G_fatal_error(_("Stream id %d not set, top is %d, parent is %d"),
stream_id, top, nodestack[top - 1].stream_id);
Vect_cat_set(Cats, 1, stream_id);
if (stream_node[stream_id].n_trib == 0)
Vect_cat_set(Cats, 2, 0);
else
Vect_cat_set(Cats, 2, 1);
Vect_append_point(Points, west_offset + c_nbr * ew_res,
north_offset - r_nbr * ns_res, 0);
Vect_write_line(&Out, GV_POINT, Points, Cats);
seg_get(&aspflag, (char *)&af, r_nbr, c_nbr);
while (af.asp > 0) {
r_nbr = r_nbr + asp_r[(int)af.asp];
c_nbr = c_nbr + asp_c[(int)af.asp];
cseg_get(&stream, &stream_nbr, r_nbr, c_nbr);
if (stream_nbr <= 0)
G_fatal_error(_("Stream id not set while tracing"));
Vect_append_point(Points, west_offset + c_nbr * ew_res,
north_offset - r_nbr * ns_res, 0);
if (stream_nbr != stream_id) {
/* first point of parent stream */
break;
}
seg_get(&aspflag, (char *)&af, r_nbr, c_nbr);
}
Vect_write_line(&Out, GV_LINE, Points, Cats);
top--;
}
}
}
G_percent(n_outlets, n_outlets, 1); /* finish it */
G_message(_("Writing attribute data..."));
/* Prepeare strings for use in db_* calls */
db_init_string(&dbsql);
db_init_string(&valstr);
db_init_string(&table_name);
db_init_handle(&handle);
/* Preparing database for use */
/* Create database for new vector map */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
driver = db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database,
&Out));
if (driver == NULL) {
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
}
db_set_error_handler_driver(driver);
G_debug(1, "table: %s", Fi->table);
G_debug(1, "driver: %s", Fi->driver);
G_debug(1, "database: %s", Fi->database);
sprintf(buf,
"create table %s (%s integer, stream_type varchar(20), type_code integer)",
Fi->table, cat_col_name);
db_set_string(&dbsql, buf);
if (db_execute_immediate(driver, &dbsql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&dbsql));
}
if (db_create_index2(driver, Fi->table, cat_col_name) != DB_OK)
G_warning(_("Unable to create index on table <%s>"), Fi->table);
if (db_grant_on_table(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
/* stream nodes */
for (i = 1; i <= n_stream_nodes; i++) {
sprintf(buf, "insert into %s values ( %lld, \'%s\', %d )",
Fi->table, i,
(stream_node[i].n_trib > 0 ? "intermediate" : "start"),
(stream_node[i].n_trib > 0));
db_set_string(&dbsql, buf);
if (db_execute_immediate(driver, &dbsql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to insert new row: '%s'"),
db_get_string(&dbsql));
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table,
cat_col_name, Fi->database, Fi->driver);
G_debug(1, "close vector");
Vect_hist_command(&Out);
Vect_build(&Out);
Vect_close(&Out);
G_free(nodestack);
return 1;
}
int G_get_3dview(const char *fname, const char *mapset, struct G_3dview *View)
{
struct Cell_head curwin;
FILE *fp;
char buffer[80], keystring[24], boo[8], nbuf[128], ebuf[128];
int lap, v_maj, v_min, wind_keys = 0, reqkeys = 0;
int current = 0; /* current version flag */
mapset = G_find_file2("3d.view", fname, mapset);
if (mapset != NULL) {
if (NULL == (fp = G_fopen_old("3d.view", fname, mapset))) {
G_warning(_("Unable to open %s for reading"), fname);
return (-1);
}
G_get_set_window(&curwin);
G_get_3dview_defaults(View, &curwin);
if (NULL != fgets(buffer, 80, fp)) {
if (buffer[0] != '#') { /* old d.3d format */
rewind(fp);
if (0 <= read_old_format(View, fp))
return (0);
else
return (-1);
}
else {
sscanf(buffer, "#%d.%d\n", &v_maj, &v_min);
if (v_maj == vers_major && v_min == vers_minor)
current = 1; /* same version */
}
}
while (NULL != fgets(buffer, 75, fp)) {
if (buffer[0] != '#') {
sscanf(buffer, "%[^:]:", keystring);
if (!strcmp(keystring, "PGM_ID")) {
sscanf(buffer, "%*s%s", (View->pgm_id));
continue;
}
if (!strcmp(keystring, "north")) {
sscanf(buffer, "%*s%lf", &(View->vwin.north));
++wind_keys;
continue;
}
if (!strcmp(keystring, "south")) {
sscanf(buffer, "%*s%lf", &(View->vwin.south));
++wind_keys;
continue;
}
if (!strcmp(keystring, "east")) {
sscanf(buffer, "%*s%lf", &(View->vwin.east));
++wind_keys;
continue;
}
if (!strcmp(keystring, "west")) {
sscanf(buffer, "%*s%lf", &(View->vwin.west));
++wind_keys;
continue;
}
if (!strcmp(keystring, "rows")) {
sscanf(buffer, "%*s%d", &(View->vwin.rows));
++wind_keys;
continue;
}
if (!strcmp(keystring, "cols")) {
sscanf(buffer, "%*s%d", &(View->vwin.cols));
++wind_keys;
continue;
}
if (!strcmp(keystring, "TO_EASTING")) {
sscanf(buffer, "%*s%f", &(View->from_to[1][0]));
++reqkeys;
continue;
}
if (!strcmp(keystring, "TO_NORTHING")) {
sscanf(buffer, "%*s%f", &(View->from_to[1][1]));
++reqkeys;
continue;
}
if (!strcmp(keystring, "TO_HEIGHT")) {
sscanf(buffer, "%*s%f", &(View->from_to[1][2]));
++reqkeys;
continue;
}
if (!strcmp(keystring, "FROM_EASTING")) {
sscanf(buffer, "%*s%f", &(View->from_to[0][0]));
++reqkeys;
continue;
}
if (!strcmp(keystring, "FROM_NORTHING")) {
sscanf(buffer, "%*s%f", &(View->from_to[0][1]));
++reqkeys;
continue;
}
if (!strcmp(keystring, "FROM_HEIGHT")) {
sscanf(buffer, "%*s%f", &(View->from_to[0][2]));
++reqkeys;
continue;
}
if (!strcmp(keystring, "Z_EXAG")) {
sscanf(buffer, "%*s%f", &(View->exag));
++reqkeys;
continue;
}
if (!strcmp(keystring, "MESH_FREQ")) {
sscanf(buffer, "%*s%d", &(View->mesh_freq));
continue;
}
if (!strcmp(keystring, "POLY_RES")) {
sscanf(buffer, "%*s%d", &(View->poly_freq));
continue;
}
if (!strcmp(keystring, "DOAVG")) {
sscanf(buffer, "%*s%d", &(View->doavg));
continue;
}
if (!strcmp(keystring, "FIELD_VIEW")) {
sscanf(buffer, "%*s%f", &(View->fov));
++reqkeys;
continue;
}
if (!strcmp(keystring, "TWIST")) {
sscanf(buffer, "%*s%f", &(View->twist));
continue;
}
if (!strcmp(keystring, "DISPLAY_TYPE")) {
sscanf(buffer, "%*s%d", &View->display_type);
continue;
}
if (!strcmp(keystring, "DOZERO")) {
sscanf(buffer, "%*s%s", boo);
View->dozero = get_bool(boo);
continue;
}
if (!strcmp(keystring, "COLORGRID")) {
sscanf(buffer, "%*s%s", boo);
View->colorgrid = get_bool(boo);
continue;
}
if (!strcmp(keystring, "FRINGE")) {
sscanf(buffer, "%*s%s", boo);
View->fringe = get_bool(boo);
continue;
}
if (!strcmp(keystring, "SHADING")) {
sscanf(buffer, "%*s%s", boo);
View->shading = get_bool(boo);
continue;
}
if (!strcmp(keystring, "BG_COL")) {
sscanf(buffer, "%*s%s", View->bg_col);
continue;
}
if (!strcmp(keystring, "GRID_COL")) {
sscanf(buffer, "%*s%s", View->grid_col);
continue;
}
if (!strcmp(keystring, "OTHER_COL")) {
sscanf(buffer, "%*s%s", View->other_col);
continue;
}
if (!strcmp(keystring, "SURFACEONLY")) {
sscanf(buffer, "%*s%s", boo);
View->surfonly = get_bool(boo);
continue;
}
if (!strcmp(keystring, "LIGHTS_ON")) {
sscanf(buffer, "%*s%s", boo);
View->lightson = get_bool(boo);
continue;
}
if (!strcmp(keystring, "LIGHTPOS")) {
sscanf(buffer, "%*s%f%f%f%f", &(View->lightpos[0]),
&(View->lightpos[1]), &(View->lightpos[2]),
&(View->lightpos[3]));
continue;
}
if (!strcmp(keystring, "LIGHTCOL")) {
sscanf(buffer, "%*s%f%f%f", &(View->lightcol[0]),
&(View->lightcol[1]), &(View->lightcol[2]));
continue;
}
if (!strcmp(keystring, "LIGHTAMBIENT")) {
sscanf(buffer, "%*s%f", &(View->ambient));
continue;
}
if (!strcmp(keystring, "SHINE")) {
sscanf(buffer, "%*s%f", &(View->shine));
continue;
}
}
}
fclose(fp);
if (reqkeys != REQ_KEYS) /* required keys not found */
return (-1);
/* fill rest of View->vwin */
if (wind_keys == 6) {
View->vwin.ew_res = (View->vwin.east - View->vwin.west) /
View->vwin.cols;
View->vwin.ns_res = (View->vwin.north - View->vwin.south) /
View->vwin.rows;
}
else
return (0); /* older format */
if (!Suppress_warn) {
if (95 > (lap = compare_wind(&(View->vwin), &curwin))) {
fprintf(stderr, _("GRASS window when view was saved:\n"));
G_format_northing(View->vwin.north, nbuf, G_projection());
fprintf(stderr, "north: %s\n", nbuf);
G_format_northing(View->vwin.south, nbuf, G_projection());
fprintf(stderr, "south: %s\n", nbuf);
G_format_easting(View->vwin.east, ebuf, G_projection());
fprintf(stderr, "east: %s\n", ebuf);
G_format_easting(View->vwin.west, ebuf, G_projection());
fprintf(stderr, "west: %s\n", ebuf);
pr_winerr(lap, fname);
}
}
}
else {
G_warning(_("Unable to open %s for reading"), fname);
return (-1);
}
if (current)
return (2);
return (1);
}
/* *************************************************************** */
int test_array_2d(void)
{
int sum = 0, res = 0;
struct Cell_head region;
N_array_2d *data1;
N_array_2d *data11;
N_array_2d *data2;
N_array_2d *data22;
N_array_2d *data3;
N_array_2d *data33;
char buff[1024];
double min, max, ssum;
int nonzero;
N_array_2d *tmp;
/*Alloacte memory for all arrays */
data1 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
N_print_array_2d_info(data1);
data11 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
data2 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
N_print_array_2d_info(data2);
data22 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
data3 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
N_print_array_2d_info(data3);
data33 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
/*Fill the first arrays with data */
res = fill_array_2d(data1);
if (res != 0)
G_warning("test_array_2d: error while filling array with values");
sum += res;
res = fill_array_2d(data2);
if (res != 0)
G_warning("test_array_2d: error while filling array with values");
sum += res;
res = fill_array_2d(data3);
if (res != 0)
G_warning("test_array_2d: error while filling array with values");
sum += res;
/*Copy the data */
N_copy_array_2d(data1, data11);
N_copy_array_2d(data2, data22);
N_copy_array_2d(data3, data33);
/*Compare the data */
res = compare_array_2d(data1, data11);
if (res != 0)
G_warning("test_array_2d: error in N_copy_array_2d");
sum += res;
res = compare_array_2d(data2, data22);
if (res != 0)
G_warning("test_array_2d: error in N_copy_array_2d");
sum += res;
res = compare_array_2d(data3, data33);
if (res != 0)
G_warning("test_array_2d: error in N_copy_array_2d");
sum += res;
/*compute statistics */
N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 0);
G_message("CELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 1);
G_message("CELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 0);
G_message("FCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 1);
G_message("FCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 0);
G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 1);
G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
/*test the array math functions */
tmp = N_math_array_2d(data1, data2, NULL, N_ARRAY_SUM);
N_math_array_2d(data2, data2, tmp, N_ARRAY_SUM);
res = N_convert_array_2d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum = res;
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIF);
N_math_array_2d(data1, data2, tmp, N_ARRAY_DIF);
res = N_convert_array_2d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum = res;
N_free_array_2d(tmp);
tmp = N_math_array_2d(data1, data1, NULL, N_ARRAY_MUL);
N_math_array_2d(data1, data1, tmp, N_ARRAY_MUL);
res = N_convert_array_2d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum = res;
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
N_math_array_2d(data1, data2, tmp, N_ARRAY_DIV);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) { /* if a division with zero is detected, the value is set to null, not to nan */
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
/*check for correct norm calculation */
if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
/*fill arrays with null values */
res = fill_array_2d_null(data1);
if (res != 0)
G_warning
("test_array_2d: error while filling array with cell null values");
sum += res;
res = fill_array_2d_null(data2);
if (res != 0)
G_warning
("test_array_2d: error while filling array with fcell null values");
sum += res;
res = fill_array_2d_null(data3);
if (res != 0)
G_warning
("test_array_2d: error while filling array with dcell null values");
sum += res;
/*Copy the data */
N_copy_array_2d(data1, data11);
N_copy_array_2d(data2, data22);
N_copy_array_2d(data3, data33);
/*Compare the data */
compare_array_2d(data1, data11);
compare_array_2d(data2, data22);
compare_array_2d(data3, data33);
/*check for correct norm calculation in case of null values */
if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
/*test the array math functions with null values */
tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_SUM);
N_math_array_2d(data2, data22, tmp, N_ARRAY_SUM);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero ");
sum++;
}
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data22, NULL, N_ARRAY_DIF);
N_math_array_2d(data3, data33, tmp, N_ARRAY_DIF);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_MUL);
N_math_array_2d(data3, data33, tmp, N_ARRAY_MUL);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
N_math_array_2d(data1, data11, tmp, N_ARRAY_DIV);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
N_free_array_2d(data1);
N_free_array_2d(data2);
N_free_array_2d(data3);
G_get_set_window(®ion);
data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
fill_array_2d(data1);
fill_array_2d(data2);
fill_array_2d(data3);
/*raster IO methods */
N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
N_free_array_2d(tmp);
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
N_free_array_2d(tmp);
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
N_free_array_2d(tmp);
sprintf(buff,
"g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
system(buff);
N_free_array_2d(data1);
N_free_array_2d(data11);
N_free_array_2d(data2);
N_free_array_2d(data22);
N_free_array_2d(data3);
N_free_array_2d(data33);
return sum;
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
RASTER3D_Region region;
struct Cell_head window2d;
struct GModule *module;
void *map = NULL; /*The 3D Rastermap */
int changemask = 0;
int elevfd = -1, outfd = -1; /*file descriptors */
int output_type, cols, rows;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("profile"));
G_add_keyword(_("raster"));
G_add_keyword(_("voxel"));
module->description =
_("Creates cross section 2D raster map from 3D raster map based on 2D elevation map");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_debug(3, "Open 3D raster map %s", param.input->answer);
if (NULL == G_find_raster3d(param.input->answer, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"),
param.input->answer);
/* Figure out the region from the map */
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/*Check if the g3d-region is equal to the 2d rows and cols */
rows = Rast_window_rows();
cols = Rast_window_cols();
/*If not equal, set the 2D windows correct */
if (rows != region.rows || cols != region.cols) {
G_message
(_("The 2D and 3D region settings are different. Using the 3D raster map settings to adjust the 2D region."));
G_get_set_window(&window2d);
window2d.ns_res = region.ns_res;
window2d.ew_res = region.ew_res;
window2d.rows = region.rows;
window2d.cols = region.cols;
Rast_set_window(&window2d);
}
/*******************/
/*Open the 3d raster map */
/*******************/
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
/*Get the output type */
output_type = Rast3d_file_type_map(map);
if (output_type == FCELL_TYPE || output_type == DCELL_TYPE) {
/********************************/
/*Open the elevation raster map */
/********************************/
elevfd = Rast_open_old(param.elevation->answer, "");
globalElevMapType = Rast_get_map_type(elevfd);
/**********************/
/*Open the Outputmap */
/**********************/
if (G_find_raster2(param.output->answer, ""))
G_message(_("Output map already exists. Will be overwritten!"));
if (output_type == FCELL_TYPE)
outfd = Rast_open_new(param.output->answer, FCELL_TYPE);
else if (output_type == DCELL_TYPE)
outfd = Rast_open_new(param.output->answer, DCELL_TYPE);
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(map)) {
Rast3d_mask_on(map);
changemask = 1;
}
}
}
/************************/
/*Create the Rastermaps */
/************************/
rast3d_cross_section(map, region, elevfd, outfd);
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(map) && changemask)
Rast3d_mask_off(map);
}
Rast_close(outfd);
Rast_close(elevfd);
} else {
fatal_error(map, -1, -1,
_("Wrong 3D raster datatype! Cannot create raster map"));
}
/* Close files and exit */
if (!Rast3d_close(map))
Rast3d_fatal_error(_("Unable to close 3D raster map <%s>"),
param.input->answer);
return (EXIT_SUCCESS);
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
struct GModule *module = NULL;
N_solute_transport_data2d *data = NULL;
N_geom_data *geom = NULL;
N_les *les = NULL;
N_les_callback_2d *call = NULL;
struct Cell_head region;
double error, sor;
char *solver;
int x, y, stat, i, maxit = 1;
double loops = 1;
N_array_2d *xcomp = NULL;
N_array_2d *ycomp = NULL;
N_array_2d *hc_x = NULL;
N_array_2d *hc_y = NULL;
N_array_2d *phead = NULL;
double time_step, cfl, length, time_loops, time_sum;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("solute transport"));
module->description =
_("Numerical calculation program for transient, confined and unconfined "
"solute transport in two dimensions");
/* Get parameters from user */
set_params();
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Make sure that the current projection is not lat/long */
if ((G_projection() == PROJECTION_LL))
G_fatal_error(_("Lat/Long location is not supported by %s. Please reproject map first."),
G_program_name());
/*Set the maximum iterations */
sscanf(param.maxit->answer, "%i", &(maxit));
/*Set the calculation error break criteria */
sscanf(param.error->answer, "%lf", &(error));
sscanf(param.sor->answer, "%lf", &(sor));
/*number of loops*/
sscanf(param.loops->answer, "%lf", &(loops));
/*Set the solver */
solver = param.solver->answer;
if (strcmp(solver, G_MATH_SOLVER_DIRECT_LU) == 0 && !param.full_les->answer)
G_fatal_error(_("The direct LU solver do not work with sparse matrices"));
if (strcmp(solver, G_MATH_SOLVER_DIRECT_GAUSS) == 0 && !param.full_les->answer)
G_fatal_error(_("The direct Gauss solver do not work with sparse matrices"));
/*get the current region */
G_get_set_window(®ion);
/*allocate the geometry structure for geometry and area calculation */
geom = N_init_geom_data_2d(®ion, geom);
/*Set the function callback to the groundwater flow function */
call = N_alloc_les_callback_2d();
N_set_les_callback_2d_func(call, (*N_callback_solute_transport_2d)); /*solute_transport 2d */
/*Allocate the groundwater flow data structure */
data = N_alloc_solute_transport_data2d(geom->cols, geom->rows);
/*Set the stabilizing scheme*/
if (strncmp("full", param.stab->answer, 4) == 0) {
data->stab = N_UPWIND_FULL;
}
if (strncmp("exp", param.stab->answer, 3) == 0) {
data->stab = N_UPWIND_EXP;
}
/*the dispersivity lengths*/
sscanf(param.al->answer, "%lf", &(data->al));
sscanf(param.at->answer, "%lf", &(data->at));
/*Set the calculation time */
sscanf(param.dt->answer, "%lf", &(data->dt));
/*read all input maps into the memory and take care of the
* null values.*/
N_read_rast_to_array_2d(param.c->answer, data->c);
N_convert_array_2d_null_to_zero(data->c);
N_read_rast_to_array_2d(param.c->answer, data->c_start);
N_convert_array_2d_null_to_zero(data->c_start);
N_read_rast_to_array_2d(param.status->answer, data->status);
N_convert_array_2d_null_to_zero(data->status);
N_read_rast_to_array_2d(param.diff_x->answer, data->diff_x);
N_convert_array_2d_null_to_zero(data->diff_x);
N_read_rast_to_array_2d(param.diff_y->answer, data->diff_y);
N_convert_array_2d_null_to_zero(data->diff_y);
N_read_rast_to_array_2d(param.q->answer, data->q);
N_convert_array_2d_null_to_zero(data->q);
N_read_rast_to_array_2d(param.nf->answer, data->nf);
N_convert_array_2d_null_to_zero(data->nf);
N_read_rast_to_array_2d(param.cs->answer, data->cs);
N_convert_array_2d_null_to_zero(data->cs);
N_read_rast_to_array_2d(param.top->answer, data->top);
N_convert_array_2d_null_to_zero(data->top);
N_read_rast_to_array_2d(param.bottom->answer, data->bottom);
N_convert_array_2d_null_to_zero(data->bottom);
N_read_rast_to_array_2d(param.r->answer, data->R);
N_convert_array_2d_null_to_zero(data->R);
if(param.cin->answer) {
N_read_rast_to_array_2d(param.cin->answer, data->cin);
N_convert_array_2d_null_to_zero(data->cin);
}
/*initiate the values for velocity calculation*/
hc_x = N_alloc_array_2d(geom->cols, geom->rows, 1, DCELL_TYPE);
hc_x = N_read_rast_to_array_2d(param.hc_x->answer, hc_x);
N_convert_array_2d_null_to_zero(hc_x);
hc_y = N_alloc_array_2d(geom->cols, geom->rows, 1, DCELL_TYPE);
hc_y = N_read_rast_to_array_2d(param.hc_y->answer, hc_y);
N_convert_array_2d_null_to_zero(hc_y);
phead = N_alloc_array_2d(geom->cols, geom->rows, 1, DCELL_TYPE);
phead = N_read_rast_to_array_2d(param.phead->answer, phead);
N_convert_array_2d_null_to_zero(phead);
/* Set the inactive values to zero, to assure a no flow boundary */
for (y = 0; y < geom->rows; y++) {
for (x = 0; x < geom->cols; x++) {
stat = (int)N_get_array_2d_d_value(data->status, x, y);
if (stat == N_CELL_INACTIVE) { /*only inactive cells */
N_put_array_2d_d_value(data->diff_x, x, y, 0);
N_put_array_2d_d_value(data->diff_y, x, y, 0);
N_put_array_2d_d_value(data->cs, x, y, 0);
N_put_array_2d_d_value(data->q, x, y, 0);
}
}
}
/*compute the velocities */
N_math_array_2d(hc_x, data->nf, hc_x, N_ARRAY_DIV);
N_math_array_2d(hc_y, data->nf, hc_y, N_ARRAY_DIV);
N_compute_gradient_field_2d(phead, hc_x, hc_y, geom, data->grad);
/*Now compute the dispersivity tensor*/
N_calc_solute_transport_disptensor_2d(data);
/***************************************/
/*the Courant-Friedrichs-Lewy criteria */
/*Compute the correct time step */
if (geom->dx > geom->dy)
length = geom->dx;
else
length = geom->dy;
if (fabs(data->grad->max) > fabs(data->grad->min)) {
cfl = (double)data->dt * fabs(data->grad->max) / length;
time_step = 1*length / fabs(data->grad->max);
}
else {
cfl = (double)data->dt * fabs(data->grad->min) / length;
time_step = 1*length / fabs(data->grad->min);
}
G_message(_("The Courant-Friedrichs-Lewy criteria is %g it should be within [0:1]"), cfl);
G_message(_("The largest stable time step is %g"), time_step);
/*Set the number of inner loops and the time step*/
if (data->dt > time_step && param.cfl->answer) {
/*safe the user time step */
time_sum = data->dt;
time_loops = data->dt / time_step;
time_loops = floor(time_loops) + 1;
data->dt = data->dt / time_loops;
G_message(_("Number of inner loops is %g"), time_loops);
G_message(_("Time step for each loop %g"), data->dt);
}
else {
if(data->dt > time_step)
G_warning(_("The time step is to large: %gs. The largest time step should be of size %gs."), data->dt, time_step);
time_loops = loops;
data->dt = data->dt / loops;
}
N_free_array_2d(phead);
N_free_array_2d(hc_x);
N_free_array_2d(hc_y);
/*Compute for each time step*/
for (i = 0; i < time_loops; i++) {
G_message(_("Time step %i with time sum %g"), i + 1, (i + 1)*data->dt);
/*assemble the linear equation system and solve it */
les = create_solve_les(geom, data, call, solver, maxit, error, sor);
/* copy the result into the c array for output */
copy_result(data->status, data->c_start, les->x, ®ion, data->c, 1);
N_convert_array_2d_null_to_zero(data->c_start);
if (les)
N_free_les(les);
/*Set the start array*/
N_copy_array_2d(data->c, data->c_start);
/*Set the transmission boundary*/
N_calc_solute_transport_transmission_2d(data);
}
/*write the result to the output file */
N_write_array_2d_to_rast(data->c, param.output->answer);
/*Compute the the velocity field if required and write the result into three rast maps */
if (param.vector_x->answer || param.vector_y->answer) {
xcomp = N_alloc_array_2d(geom->cols, geom->rows, 1, DCELL_TYPE);
ycomp = N_alloc_array_2d(geom->cols, geom->rows, 1, DCELL_TYPE);
N_compute_gradient_field_components_2d(data->grad, xcomp, ycomp);
if (param.vector_x->answer)
N_write_array_2d_to_rast(xcomp, param.vector_x->answer);
if (param.vector_y->answer)
N_write_array_2d_to_rast(ycomp, param.vector_y->answer);
if (xcomp)
N_free_array_2d(xcomp);
if (ycomp)
N_free_array_2d(ycomp);
}
if (data)
N_free_solute_transport_data2d(data);
if (geom)
N_free_geom_data(geom);
if (call)
G_free(call);
return (EXIT_SUCCESS);
}
int init_vars(int argc, char *argv[])
{
int r, c;
int ele_fd, wat_fd, fd = -1;
int seg_rows, seg_cols, num_cseg_total, num_open_segs, num_open_array_segs;
double memory_divisor, heap_mem, seg_factor, disk_space;
/* int page_block, num_cseg; */
int max_bytes;
CELL *buf, alt_value, *alt_value_buf, block_value;
char asp_value;
DCELL wat_value;
DCELL dvalue;
WAT_ALT wa, *wabuf;
ASP_FLAG af, af_nbr, *afbuf;
char MASK_flag;
void *elebuf, *ptr, *watbuf, *watptr;
int ele_map_type, wat_map_type;
size_t ele_size, wat_size;
int ct_dir, r_nbr, c_nbr;
G_gisinit(argv[0]);
/* input */
ele_flag = pit_flag = run_flag = ril_flag = 0;
/* output */
wat_flag = asp_flag = bas_flag = seg_flag = haf_flag = tci_flag = 0;
bas_thres = 0;
/* shed, unused */
arm_flag = dis_flag = 0;
/* RUSLE */
ob_flag = st_flag = sl_flag = sg_flag = ls_flag = er_flag = 0;
nxt_avail_pt = 0;
/* dep_flag = 0; */
max_length = d_zero = 0.0;
d_one = 1.0;
ril_value = -1.0;
/* dep_slope = 0.0; */
max_bytes = 0;
sides = 8;
mfd = 1;
c_fac = 5;
abs_acc = 0;
ele_scale = 1;
segs_mb = 300;
/* scan options */
for (r = 1; r < argc; r++) {
if (sscanf(argv[r], "elevation=%s", ele_name) == 1)
ele_flag++;
else if (sscanf(argv[r], "accumulation=%s", wat_name) == 1)
wat_flag++;
else if (sscanf(argv[r], "tci=%s", tci_name) == 1)
tci_flag++;
else if (sscanf(argv[r], "drainage=%s", asp_name) == 1)
asp_flag++;
else if (sscanf(argv[r], "depression=%s", pit_name) == 1)
pit_flag++;
else if (sscanf(argv[r], "threshold=%d", &bas_thres) == 1) ;
else if (sscanf(argv[r], "max_slope_length=%lf", &max_length) == 1) ;
else if (sscanf(argv[r], "basin=%s", bas_name) == 1)
bas_flag++;
else if (sscanf(argv[r], "stream=%s", seg_name) == 1)
seg_flag++;
else if (sscanf(argv[r], "half_basin=%s", haf_name) == 1)
haf_flag++;
else if (sscanf(argv[r], "flow=%s", run_name) == 1)
run_flag++;
else if (sscanf(argv[r], "ar=%s", arm_name) == 1)
arm_flag++;
/* slope length
else if (sscanf(argv[r], "slope_length=%s", sl_name) == 1)
sl_flag++; */
else if (sscanf(argv[r], "slope_steepness=%s", sg_name) == 1)
sg_flag++;
else if (sscanf(argv[r], "length_slope=%s", ls_name) == 1)
ls_flag++;
else if (sscanf(argv[r], "blocking=%s", ob_name) == 1)
ob_flag++;
else if (sscanf(argv[r], "memory=%lf", &segs_mb) == 1) ;
else if (sscanf(argv[r], "disturbed_land=%s", ril_name) == 1) {
if (sscanf(ril_name, "%lf", &ril_value) == 0) {
ril_value = -1.0;
ril_flag++;
}
}
/* slope deposition
else if (sscanf (argv[r], "sd=%[^\n]", dep_name) == 1) dep_flag++; */
else if (sscanf(argv[r], "-%d", &sides) == 1) {
if (sides != 4)
usage(argv[0]);
}
else if (sscanf(argv[r], "convergence=%d", &c_fac) == 1) ;
else if (strcmp(argv[r], "-s") == 0)
mfd = 0;
else if (strcmp(argv[r], "-a") == 0)
abs_acc = 1;
else
usage(argv[0]);
}
/* check options */
if (mfd == 1 && (c_fac < 1 || c_fac > 10)) {
G_fatal_error("Convergence factor must be between 1 and 10.");
}
if ((ele_flag != 1)
||
((arm_flag == 1) &&
((bas_thres <= 0) || ((haf_flag != 1) && (bas_flag != 1))))
||
((bas_thres <= 0) &&
((bas_flag == 1) || (seg_flag == 1) || (haf_flag == 1) ||
(sl_flag == 1) || (sg_flag == 1) || (ls_flag == 1)))
)
usage(argv[0]);
tot_parts = 4;
if (sl_flag || sg_flag || ls_flag)
er_flag = 1;
/* do RUSLE */
if (er_flag)
tot_parts++;
/* define basins */
if (seg_flag || bas_flag || haf_flag)
tot_parts++;
G_message(_n("SECTION 1 beginning: Initiating Variables. %d section total.",
"SECTION 1 beginning: Initiating Variables. %d sections total.",
tot_parts),
tot_parts);
this_mapset = G_mapset();
/* for sd factor
if (dep_flag) {
if (sscanf (dep_name, "%lf", &dep_slope) != 1) {
dep_flag = -1;
}
}
*/
G_get_set_window(&window);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
if (max_length <= d_zero)
max_length = 10 * nrows * window.ns_res + 10 * ncols * window.ew_res;
if (window.ew_res < window.ns_res)
half_res = .5 * window.ew_res;
else
half_res = .5 * window.ns_res;
diag = sqrt(window.ew_res * window.ew_res +
window.ns_res * window.ns_res);
if (sides == 4)
diag *= 0.5;
/* Segment rows and cols: 64 */
seg_rows = SROW;
seg_cols = SCOL;
/* seg_factor * <size in bytes> = segment size in KB */
seg_factor = seg_rows * seg_rows / 1024.;
if (segs_mb < 3.0) {
segs_mb = 3;
G_warning(_("Maximum memory to be used was smaller than 3 MB,"
" set to 3 MB."));
}
/* balance segment files */
/* elevation + accumulation: * 2 */
memory_divisor = sizeof(WAT_ALT) * 2;
disk_space = sizeof(WAT_ALT);
/* aspect and flags: * 4 */
memory_divisor += sizeof(ASP_FLAG) * 4;
disk_space += sizeof(ASP_FLAG);
/* astar_points: / 16 */
/* ideally only a few but large segments */
memory_divisor += sizeof(POINT) / 16.;
disk_space += sizeof(POINT);
/* heap points: / 4 */
memory_divisor += sizeof(HEAP_PNT) / 4.;
disk_space += sizeof(HEAP_PNT);
/* TCI: as is */
if (tci_flag) {
memory_divisor += sizeof(double);
disk_space += sizeof(double);
}
/* RUSLE */
if (er_flag) {
/* r_h */
memory_divisor += 4;
disk_space += 4;
/* s_l */
memory_divisor += 8;
disk_space += 8;
/* s_g */
if (sg_flag) {
memory_divisor += 8;
disk_space += 8;
}
/* l_s */
if (ls_flag) {
memory_divisor += 8;
disk_space += 8;
}
/* ril */
if (ril_flag) {
memory_divisor += 8;
disk_space += 8;
}
}
/* KB -> MB */
memory_divisor = memory_divisor * seg_factor / 1024.;
disk_space = disk_space * seg_factor / 1024.;
num_open_segs = segs_mb / memory_divisor;
heap_mem = num_open_segs * seg_factor * sizeof(HEAP_PNT) / (4. * 1024.);
G_debug(1, "segs MB: %.0f", segs_mb);
G_debug(1, "region rows: %d", nrows);
G_debug(1, "seg rows: %d", seg_rows);
G_debug(1, "region cols: %d", ncols);
G_debug(1, "seg cols: %d", seg_cols);
num_cseg_total = nrows / SROW + 1;
G_debug(1, " row segments:\t%d", num_cseg_total);
num_cseg_total = ncols / SCOL + 1;
G_debug(1, "column segments:\t%d", num_cseg_total);
num_cseg_total = (ncols / seg_cols + 1) * (nrows / seg_rows + 1);
G_debug(1, " total segments:\t%d", num_cseg_total);
G_debug(1, " open segments:\t%d", num_open_segs);
/* nonsense to have more segments open than exist */
if (num_open_segs > num_cseg_total)
num_open_segs = num_cseg_total;
G_debug(1, " open segments after adjusting:\t%d", num_open_segs);
disk_space *= num_cseg_total;
if (disk_space < 1024.0)
G_verbose_message(_("Will need up to %.2f MB of disk space"), disk_space);
else
G_verbose_message(_("Will need up to %.2f GB (%.0f MB) of disk space"),
disk_space / 1024.0, disk_space);
if (er_flag) {
cseg_open(&r_h, seg_rows, seg_cols, num_open_segs);
cseg_read_cell(&r_h, ele_name, "");
}
/* read elevation input and mark NULL/masked cells */
/* scattered access: alt, watalt, bitflags, asp */
seg_open(&watalt, nrows, ncols, seg_rows, seg_cols, num_open_segs * 2, sizeof(WAT_ALT));
seg_open(&aspflag, nrows, ncols, seg_rows, seg_cols, num_open_segs * 4, sizeof(ASP_FLAG));
if (tci_flag)
dseg_open(&tci, seg_rows, seg_cols, num_open_segs);
/* open elevation input */
ele_fd = Rast_open_old(ele_name, "");
ele_map_type = Rast_get_map_type(ele_fd);
ele_size = Rast_cell_size(ele_map_type);
elebuf = Rast_allocate_buf(ele_map_type);
afbuf = G_malloc(ncols * sizeof(ASP_FLAG));
if (ele_map_type == FCELL_TYPE || ele_map_type == DCELL_TYPE)
ele_scale = 1000; /* should be enough to do the trick */
/* initial flow accumulation */
if (run_flag) {
wat_fd = Rast_open_old(run_name, "");
wat_map_type = Rast_get_map_type(ele_fd);
wat_size = Rast_cell_size(ele_map_type);
watbuf = Rast_allocate_buf(ele_map_type);
}
else {
watbuf = watptr = NULL;
wat_fd = wat_size = wat_map_type = -1;
}
wabuf = G_malloc(ncols * sizeof(WAT_ALT));
alt_value_buf = Rast_allocate_buf(CELL_TYPE);
/* read elevation input and mark NULL/masked cells */
G_message("SECTION 1a: Mark masked and NULL cells");
MASK_flag = 0;
do_points = (GW_LARGE_INT) nrows * ncols;
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
Rast_get_row(ele_fd, elebuf, r, ele_map_type);
ptr = elebuf;
if (run_flag) {
Rast_get_row(wat_fd, watbuf, r, wat_map_type);
watptr = watbuf;
}
for (c = 0; c < ncols; c++) {
afbuf[c].flag = 0;
afbuf[c].asp = 0;
/* check for masked and NULL cells */
if (Rast_is_null_value(ptr, ele_map_type)) {
FLAG_SET(afbuf[c].flag, NULLFLAG);
FLAG_SET(afbuf[c].flag, INLISTFLAG);
FLAG_SET(afbuf[c].flag, WORKEDFLAG);
Rast_set_c_null_value(&alt_value, 1);
/* flow accumulation */
Rast_set_d_null_value(&wat_value, 1);
do_points--;
}
else {
if (ele_map_type == CELL_TYPE) {
alt_value = *((CELL *)ptr);
}
else if (ele_map_type == FCELL_TYPE) {
dvalue = *((FCELL *)ptr);
dvalue *= ele_scale;
alt_value = ele_round(dvalue);
}
else if (ele_map_type == DCELL_TYPE) {
dvalue = *((DCELL *)ptr);
dvalue *= ele_scale;
alt_value = ele_round(dvalue);
}
/* flow accumulation */
if (run_flag) {
if (Rast_is_null_value(watptr, wat_map_type)) {
wat_value = 0; /* ok ? */
}
else {
if (wat_map_type == CELL_TYPE) {
wat_value = *((CELL *)watptr);
}
else if (wat_map_type == FCELL_TYPE) {
wat_value = *((FCELL *)watptr);
}
else if (wat_map_type == DCELL_TYPE) {
wat_value = *((DCELL *)watptr);
}
}
}
else {
wat_value = 1;
}
}
wabuf[c].wat = wat_value;
wabuf[c].ele = alt_value;
alt_value_buf[c] = alt_value;
ptr = G_incr_void_ptr(ptr, ele_size);
if (run_flag) {
watptr = G_incr_void_ptr(watptr, wat_size);
}
}
seg_put_row(&watalt, (char *) wabuf, r);
seg_put_row(&aspflag, (char *)afbuf, r);
if (er_flag) {
cseg_put_row(&r_h, alt_value_buf, r);
}
}
G_percent(nrows, nrows, 1); /* finish it */
Rast_close(ele_fd);
G_free(wabuf);
G_free(afbuf);
if (run_flag) {
Rast_close(wat_fd);
G_free(watbuf);
}
MASK_flag = (do_points < nrows * ncols);
/* do RUSLE */
if (er_flag) {
if (ob_flag) {
fd = Rast_open_old(ob_name, "");
buf = Rast_allocate_c_buf();
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
Rast_get_c_row(fd, buf, r);
for (c = 0; c < ncols; c++) {
block_value = buf[c];
if (!Rast_is_c_null_value(&block_value) && block_value) {
seg_get(&aspflag, (char *)&af, r, c);
FLAG_SET(af.flag, RUSLEBLOCKFLAG);
seg_put(&aspflag, (char *)&af, r, c);
}
}
}
G_percent(nrows, nrows, 1); /* finish it */
Rast_close(fd);
G_free(buf);
}
if (ril_flag) {
dseg_open(&ril, seg_rows, seg_cols, num_open_segs);
dseg_read_cell(&ril, ril_name, "");
}
/* dseg_open(&slp, SROW, SCOL, num_open_segs); */
dseg_open(&s_l, seg_rows, seg_cols, num_open_segs);
if (sg_flag)
dseg_open(&s_g, seg_rows, seg_cols, num_open_segs);
if (ls_flag)
dseg_open(&l_s, seg_rows, seg_cols, num_open_segs);
}
G_debug(1, "open segments for A* points");
/* columns per segment */
seg_cols = seg_rows * seg_rows;
num_cseg_total = do_points / seg_cols;
if (do_points % seg_cols > 0)
num_cseg_total++;
/* no need to have more segments open than exist */
num_open_array_segs = num_open_segs / 16.;
if (num_open_array_segs > num_cseg_total)
num_open_array_segs = num_cseg_total;
if (num_open_array_segs < 1)
num_open_array_segs = 1;
seg_open(&astar_pts, 1, do_points, 1, seg_cols, num_open_array_segs,
sizeof(POINT));
/* one-based d-ary search_heap with astar_pts */
G_debug(1, "open segments for A* search heap");
G_debug(1, "heap memory %.2f MB", heap_mem);
/* columns per segment */
/* larger is faster */
seg_cols = seg_rows * seg_rows;
num_cseg_total = do_points / seg_cols;
if (do_points % seg_cols > 0)
num_cseg_total++;
/* no need to have more segments open than exist */
num_open_array_segs = (1 << 20) * heap_mem / (seg_cols * sizeof(HEAP_PNT));
if (num_open_array_segs > num_cseg_total)
num_open_array_segs = num_cseg_total;
if (num_open_array_segs < 2)
num_open_array_segs = 2;
G_debug(1, "A* search heap open segments %d, total %d",
num_open_array_segs, num_cseg_total);
/* the search heap will not hold more than 5% of all points at any given time ? */
/* chances are good that the heap will fit into one large segment */
seg_open(&search_heap, 1, do_points + 1, 1, seg_cols,
num_open_array_segs, sizeof(HEAP_PNT));
G_message(_("SECTION 1b: Determining Offmap Flow."));
/* heap is empty */
heap_size = 0;
if (pit_flag) {
buf = Rast_allocate_c_buf();
fd = Rast_open_old(pit_name, "");
}
else
buf = NULL;
first_astar = first_cum = -1;
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
if (pit_flag)
Rast_get_c_row(fd, buf, r);
for (c = 0; c < ncols; c++) {
seg_get(&aspflag, (char *)&af, r, c);
if (!FLAG_GET(af.flag, NULLFLAG)) {
if (er_flag)
dseg_put(&s_l, &half_res, r, c);
asp_value = af.asp;
if (r == 0 || c == 0 || r == nrows - 1 ||
c == ncols - 1) {
/* dseg_get(&wat, &wat_value, r, c); */
seg_get(&watalt, (char *)&wa, r, c);
wat_value = wa.wat;
if (wat_value > 0) {
wat_value = -wat_value;
/* dseg_put(&wat, &wat_value, r, c); */
wa.wat = wat_value;
seg_put(&watalt, (char *)&wa, r, c);
}
if (r == 0)
asp_value = -2;
else if (c == 0)
asp_value = -4;
else if (r == nrows - 1)
asp_value = -6;
else if (c == ncols - 1)
asp_value = -8;
/* cseg_get(&alt, &alt_value, r, c); */
alt_value = wa.ele;
add_pt(r, c, alt_value);
FLAG_SET(af.flag, INLISTFLAG);
FLAG_SET(af.flag, EDGEFLAG);
af.asp = asp_value;
seg_put(&aspflag, (char *)&af, r, c);
}
else {
seg_get(&watalt, (char *)&wa, r, c);
for (ct_dir = 0; ct_dir < sides; ct_dir++) {
/* get r, c (r_nbr, c_nbr) for neighbours */
r_nbr = r + nextdr[ct_dir];
c_nbr = c + nextdc[ct_dir];
seg_get(&aspflag, (char *)&af_nbr, r_nbr, c_nbr);
if (FLAG_GET(af_nbr.flag, NULLFLAG)) {
af.asp = -1 * drain[r - r_nbr + 1][c - c_nbr + 1];
add_pt(r, c, wa.ele);
FLAG_SET(af.flag, INLISTFLAG);
FLAG_SET(af.flag, EDGEFLAG);
seg_put(&aspflag, (char *)&af, r, c);
wat_value = wa.wat;
if (wat_value > 0) {
wa.wat = -wat_value;
seg_put(&watalt, (char *)&wa, r, c);
}
break;
}
}
}
/* real depression ? */
if (pit_flag && asp_value == 0) {
if (!Rast_is_c_null_value(&buf[c]) && buf[c] != 0) {
seg_get(&watalt, (char *)&wa, r, c);
add_pt(r, c, wa.ele);
FLAG_SET(af.flag, INLISTFLAG);
FLAG_SET(af.flag, EDGEFLAG);
seg_put(&aspflag, (char *)&af, r, c);
wat_value = wa.wat;
if (wat_value > 0) {
wa.wat = -wat_value;
seg_put(&watalt, (char *)&wa, r, c);
}
}
}
} /* end non-NULL cell */
} /* end column */
}
G_percent(r, nrows, 1); /* finish it */
return 0;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *input, *vect;
struct Cell_head window;
int bot, right, t0, b0, l0, r0, clear = 0;
double Rw_l, Rscr_wl;
char *map_name = NULL, *v_name = NULL, *s_name = NULL;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
/* must run in a term window */
G_putenv("GRASS_UI_TERM", "1");
module = G_define_module();
module->keywords = _("raster, landscape structure analysis, patch index");
module->description =
_("Interactive tool used to setup the sampling and analysis framework "
"that will be used by the other r.le programs.");
input = G_define_standard_option(G_OPT_R_MAP);
input->description = _("Raster map to use to setup sampling");
vect = G_define_standard_option(G_OPT_V_INPUT);
vect->key = "vect";
vect->description = _("Vector map to overlay");
vect->required = NO;
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
setbuf(stdout, NULL); /* unbuffered */
setbuf(stderr, NULL);
G_sleep_on_error(1); /* error messages get lost on clear screen */
map_name = input->answer;
v_name = vect->answer;
s_name = NULL; /* sites not used in GRASS 6 */
/* setup the r.le.para directory */
get_pwd();
/* query for the map to be setup */
if (R_open_driver() != 0)
G_fatal_error("No graphics device selected");
/* setup the current window for display & clear screen */
D_setup(1);
Rw_l = (double)G_window_cols() / G_window_rows();
/*R_open_driver(); */
/* R_font("romant"); */
G_get_set_window(&window);
t0 = R_screen_top();
b0 = R_screen_bot();
l0 = R_screen_left();
r0 = R_screen_rite();
Rscr_wl = (double)(r0 - l0) / (b0 - t0);
if (Rscr_wl > Rw_l) {
bot = b0;
right = l0 + (b0 - t0) * Rw_l;
}
else {
right = r0;
bot = t0 + (r0 - l0) / Rw_l;
}
D_new_window("a", t0, bot, l0, right);
D_set_cur_wind("a");
D_show_window(D_translate_color("green"));
D_setup(clear);
R_close_driver();
/* invoke the setup modules */
set_map(map_name, v_name, s_name, window, t0, bot, l0, right);
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct
{
struct Option *rastin, *rastout, *method, *quantile;
} parm;
struct
{
struct Flag *nulls, *weight;
} flag;
struct History history;
char title[64];
char buf_nsres[100], buf_ewres[100];
struct Colors colors;
int row;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("resample"));
module->description =
_("Resamples raster map layers to a coarser grid using aggregation.");
parm.rastin = G_define_standard_option(G_OPT_R_INPUT);
parm.rastout = G_define_standard_option(G_OPT_R_OUTPUT);
parm.method = G_define_option();
parm.method->key = "method";
parm.method->type = TYPE_STRING;
parm.method->required = NO;
parm.method->description = _("Aggregation method");
parm.method->options = build_method_list();
parm.method->answer = "average";
parm.quantile = G_define_option();
parm.quantile->key = "quantile";
parm.quantile->type = TYPE_DOUBLE;
parm.quantile->required = NO;
parm.quantile->description = _("Quantile to calculate for method=quantile");
parm.quantile->options = "0.0-1.0";
parm.quantile->answer = "0.5";
flag.nulls = G_define_flag();
flag.nulls->key = 'n';
flag.nulls->description = _("Propagate NULLs");
flag.weight = G_define_flag();
flag.weight->key = 'w';
flag.weight->description = _("Weight according to area (slower)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
nulls = flag.nulls->answer;
method = find_method(parm.method->answer);
if (method < 0)
G_fatal_error(_("Unknown method <%s>"), parm.method->answer);
if (menu[method].method == c_quant) {
quantile = atoi(parm.quantile->answer);
closure = &quantile;
}
G_get_set_window(&dst_w);
/* set window to old map */
Rast_get_cellhd(parm.rastin->answer, "", &src_w);
/* enlarge source window */
{
int r0 = (int)floor(Rast_northing_to_row(dst_w.north, &src_w));
int r1 = (int)ceil(Rast_northing_to_row(dst_w.south, &src_w));
int c0 = (int)floor(Rast_easting_to_col(dst_w.west, &src_w));
int c1 = (int)ceil(Rast_easting_to_col(dst_w.east, &src_w));
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;
}
Rast_set_input_window(&src_w);
Rast_set_output_window(&dst_w);
row_scale = 2 + ceil(dst_w.ns_res / src_w.ns_res);
col_scale = 2 + ceil(dst_w.ew_res / src_w.ew_res);
/* allocate buffers for input rows */
bufs = G_malloc(row_scale * sizeof(DCELL *));
for (row = 0; row < row_scale; row++)
bufs[row] = Rast_allocate_d_input_buf();
/* open old map */
infile = Rast_open_old(parm.rastin->answer, "");
/* allocate output buffer */
outbuf = Rast_allocate_d_output_buf();
/* open new map */
outfile = Rast_open_new(parm.rastout->answer, DCELL_TYPE);
if (flag.weight->answer && menu[method].method_w)
resamp_weighted();
else
resamp_unweighted();
G_percent(dst_w.rows, dst_w.rows, 2);
Rast_close(infile);
Rast_close(outfile);
/* record map metadata/history info */
sprintf(title, "Aggregate resample by %s", parm.method->answer);
Rast_put_cell_title(parm.rastout->answer, title);
Rast_short_history(parm.rastout->answer, "raster", &history);
Rast_set_history(&history, HIST_DATSRC_1, parm.rastin->answer);
G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj);
G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj);
Rast_format_history(&history, HIST_DATSRC_2,
"Source map NS res: %s EW res: %s",
buf_nsres, buf_ewres);
Rast_command_history(&history);
Rast_write_history(parm.rastout->answer, &history);
/* copy color table from source map */
if (strcmp(parm.method->answer, "sum") != 0) {
if (Rast_read_colors(parm.rastin->answer, "", &colors) < 0)
G_fatal_error(_("Unable to read color table for %s"),
parm.rastin->answer);
Rast_mark_colors_as_fp(&colors);
Rast_write_colors(parm.rastout->answer, G_mapset(), &colors);
}
return (EXIT_SUCCESS);
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
RASTER3D_Region region, inputmap_bounds;
struct Cell_head region2d;
struct GModule *module;
struct History history;
void *map = NULL; /*The 3D Rastermap */
int i = 0, changemask = 0;
int *fd = NULL, output_type, cols, rows;
char *RasterFileName;
int overwrite = 0;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("conversion"));
G_add_keyword(_("raster"));
G_add_keyword(_("voxel"));
module->description = _("Converts 3D raster maps to 2D raster maps");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_debug(3, "Open 3D raster map <%s>", param.input->answer);
if (NULL == G_find_raster3d(param.input->answer, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"),
param.input->answer);
/*Set the defaults */
Rast3d_init_defaults();
/*Set the resolution of the output maps */
if (param.res->answer) {
/*Open the map with current region */
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
RASTER3D_DEFAULT_WINDOW, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
/*Get the region of the map */
Rast3d_get_region_struct_map(map, ®ion);
/*set this region as current 3D window for map */
Rast3d_set_window_map(map, ®ion);
/*Set the 2d region appropriate */
Rast3d_extract2d_region(®ion, ®ion2d);
/*Make the new 2d region the default */
Rast_set_window(®ion2d);
} else {
/* Figure out the region from the map */
Rast3d_get_window(®ion);
/*Open the 3d raster map */
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
}
/*Check if the g3d-region is equal to the 2D rows and cols */
rows = Rast_window_rows();
cols = Rast_window_cols();
/*If not equal, set the 3D window correct */
if (rows != region.rows || cols != region.cols) {
G_message(_("The 2D and 3D region settings are different. "
"Using the 2D window settings to adjust the 2D part of the 3D region."));
G_get_set_window(®ion2d);
region.ns_res = region2d.ns_res;
region.ew_res = region2d.ew_res;
region.rows = region2d.rows;
region.cols = region2d.cols;
Rast3d_adjust_region(®ion);
Rast3d_set_window_map(map, ®ion);
}
/* save the input map region for later use (history meta-data) */
Rast3d_get_region_struct_map(map, &inputmap_bounds);
/*Get the output type */
output_type = Rast3d_file_type_map(map);
/*prepare the filehandler */
fd = (int *) G_malloc(region.depths * sizeof (int));
if (fd == NULL)
fatal_error(map, NULL, 0, _("Out of memory"));
G_message(_("Creating %i raster maps"), region.depths);
/*Loop over all output maps! open */
for (i = 0; i < region.depths; i++) {
/*Create the outputmaps */
G_asprintf(&RasterFileName, "%s_%05d", param.output->answer, i + 1);
G_message(_("Raster map %i Filename: %s"), i + 1, RasterFileName);
overwrite = G_check_overwrite(argc, argv);
if (G_find_raster2(RasterFileName, "") && !overwrite)
G_fatal_error(_("Raster map %d Filename: %s already exists. Use the flag --o to overwrite."),
i + 1, RasterFileName);
if (output_type == FCELL_TYPE)
fd[i] = open_output_map(RasterFileName, FCELL_TYPE);
else if (output_type == DCELL_TYPE)
fd[i] = open_output_map(RasterFileName, DCELL_TYPE);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(map)) {
Rast3d_mask_on(map);
changemask = 1;
}
}
}
/*Create the Rastermaps */
g3d_to_raster(map, region, fd);
/*Loop over all output maps! close */
for (i = 0; i < region.depths; i++) {
close_output_map(fd[i]);
/* write history */
G_asprintf(&RasterFileName, "%s_%i", param.output->answer, i + 1);
G_debug(4, "Raster map %d Filename: %s", i + 1, RasterFileName);
Rast_short_history(RasterFileName, "raster", &history);
Rast_set_history(&history, HIST_DATSRC_1, "3D Raster map:");
Rast_set_history(&history, HIST_DATSRC_2, param.input->answer);
Rast_append_format_history(&history, "Level %d of %d", i + 1, region.depths);
Rast_append_format_history(&history, "Level z-range: %f to %f",
region.bottom + (i * region.tb_res),
region.bottom + (i + 1 * region.tb_res));
Rast_append_format_history(&history, "Input map full z-range: %f to %f",
inputmap_bounds.bottom, inputmap_bounds.top);
Rast_append_format_history(&history, "Input map z-resolution: %f",
inputmap_bounds.tb_res);
if (!param.res->answer) {
Rast_append_format_history(&history, "GIS region full z-range: %f to %f",
region.bottom, region.top);
Rast_append_format_history(&history, "GIS region z-resolution: %f",
region.tb_res);
}
Rast_command_history(&history);
Rast_write_history(RasterFileName, &history);
}
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(map) && changemask)
Rast3d_mask_off(map);
}
/*Cleaning */
if (RasterFileName)
G_free(RasterFileName);
if (fd)
G_free(fd);
/* Close files and exit */
if (!Rast3d_close(map))
fatal_error(map, NULL, 0, _("Unable to close 3D raster map"));
map = NULL;
return (EXIT_SUCCESS);
}
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 test_geom_data(void)
{
struct Cell_head region2d;
G3D_Region region3d;
N_geom_data *geom = NULL;
int sum = 0, i;
double area = 0;
G_get_set_window(®ion2d);
/*Set the defaults */
G3d_initDefaults();
/*get the current region */
G3d_getWindow(®ion3d);
geom = N_alloc_geom_data();
if (!geom) {
G_warning("error in N_alloc_geom_data");
return 1;
}
N_free_geom_data(geom);
geom = NULL;
/* ************ 2d region *************** */
geom = N_init_geom_data_2d(®ion2d, geom);
if (!geom) {
G_warning("error in N_init_geom_data_2d");
return 2;
}
geom = N_init_geom_data_2d(®ion2d, geom);
if (!geom) {
G_warning("error in N_init_geom_data_2d");
return 3;
}
if (geom->dim != 2)
sum++;
if (geom->planimetric == 0 && geom->area == NULL)
sum++;
if (geom->planimetric == 1 && geom->area != NULL)
sum++;
/*get areas */
area = 0.0;
if (geom->planimetric == 0) {
for (i = 0; i < geom->rows; i++)
area += N_get_geom_data_area_of_cell(geom, i);
if (area == 0) {
G_warning("Wrong area calculation in N_init_geom_data_2d");
sum++;
}
}
area = 0.0;
if (geom->planimetric == 1) {
for (i = 0; i < geom->rows; i++)
area += N_get_geom_data_area_of_cell(geom, i);
if (area == 0) {
G_warning
("Wrong area calculation in N_get_geom_data_area_of_cell");
sum++;
}
}
N_free_geom_data(geom);
geom = NULL;
/* ************ 3d region *************** */
geom = N_init_geom_data_3d(®ion3d, geom);
if (!geom) {
G_warning("error in N_init_geom_data_3d");
return 2;
}
geom = N_init_geom_data_3d(®ion3d, geom);
if (!geom) {
G_warning("error in N_init_geom_data_3d");
return 3;
}
if (geom->dim != 3)
sum++;
if (geom->planimetric == 0 && geom->area == NULL)
sum++;
if (geom->planimetric == 1 && geom->area != NULL)
sum++;
/*get areas */
area = 0.0;
if (geom->planimetric == 0) {
for (i = 0; i < geom->rows; i++)
area += N_get_geom_data_area_of_cell(geom, i);
if (area == 0) {
G_warning
("Wrong area calculation in N_get_geom_data_area_of_cell");
sum++;
}
}
area = 0.0;
if (geom->planimetric == 1) {
for (i = 0; i < geom->rows; i++)
area += N_get_geom_data_area_of_cell(geom, i);
if (area == 0) {
G_warning
("Wrong area calculation in N_get_geom_data_area_of_cell");
sum++;
}
}
return sum;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *coord, *out_file, *min, *max, *mult;
struct Flag *flag;
int *int_buf;
struct Cell_head w;
struct History history;
int cellfile;
double east, north, pt[2], cur[2], row, col, fmult;
double fmin, fmax;
int binary;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("buffer"));
G_add_keyword(_("geometry"));
G_add_keyword(_("circle"));
module->description =
_("Creates a raster map containing concentric "
"rings around a given point.");
out_file = G_define_standard_option(G_OPT_R_OUTPUT);
coord = G_define_standard_option(G_OPT_M_COORDS);
coord->required = YES;
coord->description = _("The coordinate of the center (east,north)");
min = G_define_option();
min->key = "min";
min->type = TYPE_DOUBLE;
min->required = NO;
min->description = _("Minimum radius for ring/circle map (in meters)");
max = G_define_option();
max->key = "max";
max->type = TYPE_DOUBLE;
max->required = NO;
max->description = _("Maximum radius for ring/circle map (in meters)");
mult = G_define_option();
mult->key = "multiplier";
mult->type = TYPE_DOUBLE;
mult->required = NO;
mult->description = _("Data value multiplier");
flag = G_define_flag();
flag->key = 'b';
flag->description = _("Generate binary raster map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_scan_easting(coord->answers[0], &east, G_projection());
G_scan_northing(coord->answers[1], &north, G_projection());
pt[0] = east;
pt[1] = north;
fmult = 1.0;
if (min->answer)
sscanf(min->answer, "%lf", &fmin);
else
fmin = 0;
if (max->answer)
sscanf(max->answer, "%lf", &fmax);
else
fmax = HUGE_VAL;
if (fmin > fmax)
G_fatal_error(_("Please specify a radius in which min < max"));
if (mult->answer)
if (1 != sscanf(mult->answer, "%lf", &fmult))
fmult = 1.0;
/* nonsense test */
if (flag->answer && (!min->answer && !max->answer))
G_fatal_error(_("Please specify min and/or max radius when "
"using the binary flag"));
if (flag->answer)
binary = 1; /* generate binary pattern only, useful for MASK */
else
binary = 0;
G_get_set_window(&w);
cellfile = Rast_open_c_new(out_file->answer);
int_buf = (int *)G_malloc(w.cols * sizeof(int));
{
int c;
for (row = 0; row < w.rows; row++) {
G_percent(row, w.rows, 2);
cur[1] = Rast_row_to_northing(row + 0.5, &w);
for (col = 0; col < w.cols; col++) {
c = col;
cur[0] = Rast_col_to_easting(col + 0.5, &w);
int_buf[c] =
(int)(distance(pt, cur, fmin, fmax, binary) * fmult);
if (int_buf[c] == 0)
Rast_set_null_value(&int_buf[c], 1, CELL_TYPE);
}
Rast_put_row(cellfile, int_buf, CELL_TYPE);
}
}
G_free(int_buf);
Rast_close(cellfile);
Rast_short_history(out_file->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(out_file->answer, &history);
G_done_msg(_("Raster map <%s> created."),
out_file->answer);
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int ii;
int ret_val;
double x_orig, y_orig;
static int rand1 = 12345;
static int rand2 = 67891;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("sediment flow"));
G_add_keyword(_("erosion"));
G_add_keyword(_("deposition"));
module->description =
_("Sediment transport and erosion/deposition simulation "
"using path sampling method (SIMWE).");
parm.elevin = G_define_standard_option(G_OPT_R_ELEV);
parm.wdepth = G_define_standard_option(G_OPT_R_INPUT);
parm.wdepth->key = "wdepth";
parm.wdepth->description = _("Name of water depth raster map [m]");
parm.dxin = G_define_standard_option(G_OPT_R_INPUT);
parm.dxin->key = "dx";
parm.dxin->description = _("Name of x-derivatives raster map [m/m]");
parm.dyin = G_define_standard_option(G_OPT_R_INPUT);
parm.dyin->key = "dy";
parm.dyin->description = _("Name of y-derivatives raster map [m/m]");
parm.detin = G_define_standard_option(G_OPT_R_INPUT);
parm.detin->key = "det";
parm.detin->description =
_("Name of detachment capacity coefficient raster map [s/m]");
parm.tranin = G_define_standard_option(G_OPT_R_INPUT);
parm.tranin->key = "tran";
parm.tranin->description =
_("Name of transport capacity coefficient raster map [s]");
parm.tauin = G_define_standard_option(G_OPT_R_INPUT);
parm.tauin->key = "tau";
parm.tauin->description =
_("Name of critical shear stress raster map [Pa]");
parm.manin = G_define_standard_option(G_OPT_R_INPUT);
parm.manin->key = "man";
parm.manin->required = NO;
parm.manin->description = _("Name of Manning's n raster map");
parm.manin->guisection = _("Input");
parm.maninval = G_define_option();
parm.maninval->key = "man_value";
parm.maninval->type = TYPE_DOUBLE;
parm.maninval->answer = MANINVAL;
parm.maninval->required = NO;
parm.maninval->description = _("Manning's n unique value");
parm.maninval->guisection = _("Input");
parm.outwalk = G_define_standard_option(G_OPT_V_OUTPUT);
parm.outwalk->key = "outwalk";
parm.outwalk->required = NO;
parm.outwalk->description =
_("Base name of the output walkers vector points map");
parm.outwalk->guisection = _("Output options");
parm.observation = G_define_standard_option(G_OPT_V_INPUT);
parm.observation->key = "observation";
parm.observation->required = NO;
parm.observation->description =
_("Name of sampling locations vector points map");
parm.observation->guisection = _("Input options");
parm.logfile = G_define_standard_option(G_OPT_F_OUTPUT);
parm.logfile->key = "logfile";
parm.logfile->required = NO;
parm.logfile->description =
_("Name for sampling points output text file. For each observation vector point the time series of sediment transport is stored.");
parm.logfile->guisection = _("Output");
parm.tc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.tc->key = "tc";
parm.tc->required = NO;
parm.tc->description = _("Name for output transport capacity raster map [kg/ms]");
parm.tc->guisection = _("Output");
parm.et = G_define_standard_option(G_OPT_R_OUTPUT);
parm.et->key = "et";
parm.et->required = NO;
parm.et->description =
_("Name for output transport limited erosion-deposition raster map [kg/m2s]");
parm.et->guisection = _("Output");
parm.conc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.conc->key = "conc";
parm.conc->required = NO;
parm.conc->description =
_("Name for output sediment concentration raster map [particle/m3]");
parm.conc->guisection = _("Output");
parm.flux = G_define_standard_option(G_OPT_R_OUTPUT);
parm.flux->key = "flux";
parm.flux->required = NO;
parm.flux->description = _("Name for output sediment flux raster map [kg/ms]");
parm.flux->guisection = _("Output");
parm.erdep = G_define_standard_option(G_OPT_R_OUTPUT);
parm.erdep->key = "erdep";
parm.erdep->required = NO;
parm.erdep->description =
_("Name for output erosion-deposition raster map [kg/m2s]");
parm.erdep->guisection = _("Output");
parm.nwalk = G_define_option();
parm.nwalk->key = "nwalk";
parm.nwalk->type = TYPE_INTEGER;
parm.nwalk->required = NO;
parm.nwalk->description = _("Number of walkers");
parm.nwalk->guisection = _("Parameters");
parm.niter = G_define_option();
parm.niter->key = "niter";
parm.niter->type = TYPE_INTEGER;
parm.niter->answer = NITER;
parm.niter->required = NO;
parm.niter->description = _("Time used for iterations [minutes]");
parm.niter->guisection = _("Parameters");
parm.outiter = G_define_option();
parm.outiter->key = "outiter";
parm.outiter->type = TYPE_INTEGER;
parm.outiter->answer = ITEROUT;
parm.outiter->required = NO;
parm.outiter->description =
_("Time interval for creating output maps [minutes]");
parm.outiter->guisection = _("Parameters");
/*
parm.density = G_define_option();
parm.density->key = "density";
parm.density->type = TYPE_INTEGER;
parm.density->answer = DENSITY;
parm.density->required = NO;
parm.density->description = _("Density of output walkers");
parm.density->guisection = _("Parameters");
*/
parm.diffc = G_define_option();
parm.diffc->key = "diffc";
parm.diffc->type = TYPE_DOUBLE;
parm.diffc->answer = DIFFC;
parm.diffc->required = NO;
parm.diffc->description = _("Water diffusion constant");
parm.diffc->guisection = _("Parameters");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&cellhd);
conv = G_database_units_to_meters_factor();
mixx = cellhd.west * conv;
maxx = cellhd.east * conv;
miyy = cellhd.south * conv;
mayy = cellhd.north * conv;
stepx = cellhd.ew_res * conv;
stepy = cellhd.ns_res * conv;
/* step = amin1(stepx,stepy); */
step = (stepx + stepy) / 2.;
mx = cellhd.cols;
my = cellhd.rows;
x_orig = cellhd.west * conv;
y_orig = cellhd.south * conv; /* do we need this? */
xmin = 0.;
ymin = 0.;
xp0 = xmin + stepx / 2.;
yp0 = ymin + stepy / 2.;
xmax = xmin + stepx * (float)mx;
ymax = ymin + stepy * (float)my;
hhc = hhmax = 0.;
#if 0
bxmi = 2093113. * conv;
bymi = 731331. * conv;
bxma = 2093461. * conv;
byma = 731529. * conv;
bresx = 2. * conv;
bresy = 2. * conv;
maxwab = 100000;
mx2o = (int)((bxma - bxmi) / bresx);
my2o = (int)((byma - bymi) / bresy);
/* relative small box coordinates: leave 1 grid layer for overlap */
bxmi = bxmi - mixx + stepx;
bymi = bymi - miyy + stepy;
bxma = bxma - mixx - stepx;
byma = byma - miyy - stepy;
mx2 = mx2o - 2 * ((int)(stepx / bresx));
my2 = my2o - 2 * ((int)(stepy / bresy));
#endif
elevin = parm.elevin->answer;
wdepth = parm.wdepth->answer;
dxin = parm.dxin->answer;
dyin = parm.dyin->answer;
detin = parm.detin->answer;
tranin = parm.tranin->answer;
tauin = parm.tauin->answer;
manin = parm.manin->answer;
tc = parm.tc->answer;
et = parm.et->answer;
conc = parm.conc->answer;
flux = parm.flux->answer;
erdep = parm.erdep->answer;
outwalk = parm.outwalk->answer;
/* sscanf(parm.nwalk->answer, "%d", &maxwa); */
sscanf(parm.niter->answer, "%d", ×ec);
sscanf(parm.outiter->answer, "%d", &iterout);
/* sscanf(parm.density->answer, "%d", &ldemo); */
sscanf(parm.diffc->answer, "%lf", &frac);
sscanf(parm.maninval->answer, "%lf", &manin_val);
/* Recompute timesec from user input in minutes
* to real timesec in seconds */
timesec = timesec * 60.0;
iterout = iterout * 60.0;
if ((timesec / iterout) > 100.0)
G_message(_("More than 100 files are going to be created !!!!!"));
/* compute how big the raster is and set this to appr 2 walkers per cell */
if (parm.nwalk->answer == NULL) {
maxwa = mx * my * 2;
rwalk = (double)(mx * my * 2.);
G_message(_("default nwalk=%d, rwalk=%f"), maxwa, rwalk);
}
else {
sscanf(parm.nwalk->answer, "%d", &maxwa);
rwalk = (double)maxwa;
}
/*rwalk = (double) maxwa; */
if (conv != 1.0)
G_message(_("Using metric conversion factor %f, step=%f"), conv,
step);
if ((tc == NULL) && (et == NULL) && (conc == NULL) && (flux == NULL) &&
(erdep == NULL))
G_warning(_("You are not outputting any raster or site files"));
ret_val = input_data();
if (ret_val != 1)
G_fatal_error(_("Input failed"));
/* mandatory for si,sigma */
si = G_alloc_matrix(my, mx);
sigma = G_alloc_matrix(my, mx);
/* memory allocation for output grids */
dif = G_alloc_fmatrix(my, mx);
if (erdep != NULL || et != NULL)
er = G_alloc_fmatrix(my, mx);
seeds(rand1, rand2);
grad_check();
if (et != NULL)
erod(si);
/* treba dat output pre topoerdep */
main_loop();
if (tserie == NULL) {
ii = output_data(0, 1.);
if (ii != 1)
G_fatal_error(_("Cannot write raster maps"));
}
/* Exit with Success */
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int out_fd;
CELL *result, *rp;
int nrows, ncols;
int row, col;
struct GModule *module;
struct Option *in_opt, *out_opt;
struct Option *method_opt, *size_opt;
char *mapset;
struct Map_info In;
double radius;
struct ilist *List;
struct Cell_head region;
BOUND_BOX box;
struct line_pnts *Points;
struct line_cats *Cats;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, raster, aggregation");
module->description = "Makes each cell value a "
"function of the attribute values assigned to the vector points or centroids "
"around it, and stores new cell values in an output raster map layer.";
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_R_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->options = "count";
method_opt->answer = "count";
method_opt->description = "Neighborhood operation";
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->required = YES;
size_opt->description = "Neighborhood diameter in map units";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
radius = atof(size_opt->answer) / 2;
/* open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found in the current mapset"),
in_opt->answer);
}
Vect_set_open_level(2);
Vect_open_old(&In, in_opt->answer, mapset);
G_get_set_window(®ion);
nrows = G_window_rows();
ncols = G_window_cols();
result = G_allocate_raster_buf(CELL_TYPE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_list();
/*open the new cellfile */
out_fd = G_open_raster_new(out_opt->answer, CELL_TYPE);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), out_opt->answer);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
for (row = 0; row < nrows; row++) {
double x, y;
G_percent(row, nrows, 1);
y = G_row_to_northing(row + 0.5, ®ion);
box.N = y + radius;
box.S = y - radius;
G_set_null_value(result, ncols, CELL_TYPE);
rp = result;
for (col = 0; col < ncols; col++) {
int i, count;
CELL value;
x = G_col_to_easting(col + 0.5, ®ion);
box.E = x + radius;
box.W = x - radius;
Vect_select_lines_by_box(&In, &box, GV_POINTS, List);
G_debug(3, " %d lines in box", List->n_values);
count = 0;
for (i = 0; i < List->n_values; i++) {
double distance;
Vect_read_line(&In, Points, Cats, List->value[i]);
distance =
Vect_points_distance(x, y, 0.0, Points->x[0],
Points->y[0], 0.0, 0);
if (distance <= radius) {
count++;
}
}
if (count > 0) {
value = count;
G_set_raster_value_d(rp, value, CELL_TYPE);
}
rp = G_incr_void_ptr(rp, G_raster_size(CELL_TYPE));
}
G_put_raster_row(out_fd, result, CELL_TYPE);
}
G_percent(row, nrows, 1);
Vect_close(&In);
G_close_cell(out_fd);
exit(EXIT_SUCCESS);
}
