/*!
* \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);
}
double QgsGrassGisLib::G_geodesic_distance_lon_to_lon( double lon1, double lon2 )
{
double dist = mDistanceArea.measureLine( QgsPoint( lon1, mLat1 ), QgsPoint( lon2, mLat2 ) );
// TODO: not sure about this
if ( !mCrs.geographicFlag() )
{
dist *= G_database_units_to_meters_factor();
}
return dist;
}
// Distance in meters
double QgsGrassGisLib::distance( double e1, double n1, double e2, double n2 )
{
// QgsDistanceArea states that results are in meters, but it does not
// seem to be true,
double dist = mDistanceArea.measureLine( QgsPoint( e1, n1 ), QgsPoint( e2, n2 ) );
if ( !mCrs.geographicFlag() )
{
dist *= G_database_units_to_meters_factor();
}
return dist;
}
double QgsGrassGisLib::G_area_of_cell_at_row( int row )
{
double yMax = mExtent.yMaximum() - row * mYRes;
double yMin = yMax - mYRes;
QgsRectangle rect( mExtent.xMinimum(), yMin, mExtent.xMinimum() + mXRes, yMax );
QgsGeometry* geo = QgsGeometry::fromRect( rect );
double area = mDistanceArea.measure( geo );
delete geo;
if ( !mCrs.geographicFlag() )
{
area *= qPow( G_database_units_to_meters_factor(), 2 );
}
return area;
}
double QgsGrassGisLib::G_area_of_polygon( const double *x, const double *y, int n )
{
QgsPolyline polyline;
for ( int i = 0; i < n; i++ )
{
polyline.append( QgsPoint( x[i], y[i] ) );
}
QgsPolygon polygon;
polygon.append( polyline );
QgsGeometry* geo = QgsGeometry::fromPolygon( polygon );
double area = mDistanceArea.measure( geo );
delete geo;
if ( !mCrs.geographicFlag() )
{
area *= qPow( G_database_units_to_meters_factor(), 2 );
}
return area;
}
int main(int argc, char *argv[])
{
char *name, *outfile;
const char *unit;
int unit_id;
double factor;
int fd, projection;
FILE *fp, *coor_fp;
double res;
char *null_string;
char ebuf[256], nbuf[256], label[512], formatbuff[256];
char b1[100], b2[100];
int n;
int havefirst = FALSE;
int coords = 0, i, k = -1;
double e1, e2, n1, n2;
RASTER_MAP_TYPE data_type;
struct Cell_head window;
struct
{
struct Option *opt1, *profile, *res, *output, *null_str, *coord_file, *units;
struct Flag *g, *c, *m;
}
parm;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("profile"));
module->description =
_("Outputs the raster map layer values lying on user-defined line(s).");
parm.opt1 = G_define_standard_option(G_OPT_R_INPUT);
parm.output = G_define_standard_option(G_OPT_F_OUTPUT);
parm.output->required = NO;
parm.output->answer = "-";
parm.output->description =
_("Name of file for output (use output=- for stdout)");
parm.profile = G_define_standard_option(G_OPT_M_COORDS);
parm.profile->required = NO;
parm.profile->multiple = YES;
parm.profile->description = _("Profile coordinate pairs");
parm.coord_file = G_define_standard_option(G_OPT_F_INPUT);
parm.coord_file->key = "file";
parm.coord_file->required = NO;
parm.coord_file->label =
_("Name of input file containing coordinate pairs");
parm.coord_file->description =
_("Use instead of the 'coordinates' option. "
"\"-\" reads from stdin.");
parm.res = G_define_option();
parm.res->key = "resolution";
parm.res->type = TYPE_DOUBLE;
parm.res->required = NO;
parm.res->description =
_("Resolution along profile (default = current region resolution)");
parm.null_str = G_define_option();
parm.null_str->key = "null";
parm.null_str->type = TYPE_STRING;
parm.null_str->required = NO;
parm.null_str->answer = "*";
parm.null_str->description = _("Character to represent no data cell");
parm.g = G_define_flag();
parm.g->key = 'g';
parm.g->description =
_("Output easting and northing in first two columns of four column output");
parm.c = G_define_flag();
parm.c->key = 'c';
parm.c->description =
_("Output RRR:GGG:BBB color values for each profile point");
parm.units = G_define_standard_option(G_OPT_M_UNITS);
parm.units->options = "meters,kilometers,feet,miles";
parm.units->label = parm.units->description;
parm.units->description = _("If units are not specified, current location units are used. "
"Meters are used by default in geographic (latlon) locations.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
clr = 0;
if (parm.c->answer)
clr = 1; /* color output */
null_string = parm.null_str->answer;
if ((parm.profile->answer && parm.coord_file->answer) ||
(!parm.profile->answer && !parm.coord_file->answer))
G_fatal_error(_("Either use profile option or coordinate_file "
" option, but not both"));
G_get_window(&window);
projection = G_projection();
/* get conversion factor and units name */
if (parm.units->answer) {
unit_id = G_units(parm.units->answer);
factor = 1. / G_meters_to_units_factor(unit_id);
unit = G_get_units_name(unit_id, 1, 0);
}
/* keep meters in case of latlon */
else if (projection == PROJECTION_LL) {
factor = 1;
unit = "meters";
}
else {
/* get conversion factor to current units */
unit = G_database_unit_name(1);
factor = G_database_units_to_meters_factor();
}
if (parm.res->answer) {
res = atof(parm.res->answer);
/* Catch bad resolution ? */
if (res <= 0)
G_fatal_error(_("Illegal resolution %g [%s]"), res / factor, unit);
}
else {
/* Do average of EW and NS res */
res = (window.ew_res + window.ns_res) / 2;
}
G_message(_("Using resolution: %g [%s]"), res / factor, unit);
G_begin_distance_calculations();
/* Open Input File for reading */
/* Get Input Name */
name = parm.opt1->answer;
if (parm.g->answer)
coords = 1;
/* Open Raster File */
fd = Rast_open_old(name, "");
/* initialize color structure */
if (clr)
Rast_read_colors(name, "", &colors);
/* Open ASCII file for output or stdout */
outfile = parm.output->answer;
if ((strcmp("-", outfile)) == 0) {
fp = stdout;
}
else if (NULL == (fp = fopen(outfile, "w")))
G_fatal_error(_("Unable to open file <%s>"), outfile);
/* Get Raster Type */
data_type = Rast_get_map_type(fd);
/* Done with file */
/* Show message giving output format */
G_message(_("Output columns:"));
if (coords == 1)
sprintf(formatbuff,
_("Easting, Northing, Along track dist. [%s], Elevation"), unit);
else
sprintf(formatbuff, _("Along track dist. [%s], Elevation"), unit);
if (clr)
strcat(formatbuff, _(" RGB color"));
G_message(formatbuff);
/* Get Profile Start Coords */
if (parm.coord_file->answer) {
if (strcmp("-", parm.coord_file->answer) == 0)
coor_fp = stdin;
else
coor_fp = fopen(parm.coord_file->answer, "r");
if (coor_fp == NULL)
G_fatal_error(_("Could not open <%s>"), parm.coord_file->answer);
for (n = 1; input(b1, ebuf, b2, nbuf, label, coor_fp); n++) {
G_debug(4, "stdin line %d: ebuf=[%s] nbuf=[%s]", n, ebuf, nbuf);
if (!G_scan_easting(ebuf, &e2, G_projection()) ||
!G_scan_northing(nbuf, &n2, G_projection()))
G_fatal_error(_("Invalid coordinates %s %s"), ebuf, nbuf);
if (havefirst)
do_profile(e1, e2, n1, n2, coords, res, fd, data_type,
fp, null_string, unit, factor);
e1 = e2;
n1 = n2;
havefirst = TRUE;
}
if (coor_fp != stdin)
fclose(coor_fp);
}
else {
/* Coords given on the Command Line using the profile= option */
for (i = 0; parm.profile->answers[i]; i += 2) {
/* Test for number coordinate pairs */
k = i;
}
if (k == 0) {
/* Only one coordinate pair supplied */
G_scan_easting(parm.profile->answers[0], &e1, G_projection());
G_scan_northing(parm.profile->answers[1], &n1, G_projection());
e2 = e1;
n2 = n1;
/* Get profile info */
do_profile(e1, e2, n1, n2, coords, res, fd, data_type, fp,
null_string, unit, factor);
}
else {
for (i = 0; i <= k - 2; i += 2) {
G_scan_easting(parm.profile->answers[i], &e1, G_projection());
G_scan_northing(parm.profile->answers[i + 1], &n1,
G_projection());
G_scan_easting(parm.profile->answers[i + 2], &e2,
G_projection());
G_scan_northing(parm.profile->answers[i + 3], &n2,
G_projection());
/* Get profile info */
do_profile(e1, e2, n1, n2, coords, res, fd, data_type,
fp, null_string, unit, factor);
}
}
}
Rast_close(fd);
fclose(fp);
if (clr)
Rast_free_colors(&colors);
exit(EXIT_SUCCESS);
} /* Done with main */
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[])
{
struct GModule *module;
struct Option *in_opt, *layer_opt, *out_opt, *length_opt, *units_opt, *vertices_opt;
struct Map_info In, Out;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
int line, nlines, layer;
double length = -1;
int vertices = 0;
double (*line_length) ();
int latlon = 0;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
module->description = _("Splits vector lines to shorter segments.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
layer_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
length_opt = G_define_option();
length_opt->key = "length";
length_opt->type = TYPE_DOUBLE;
length_opt->required = NO;
length_opt->multiple = NO;
length_opt->description = _("Maximum segment length");
units_opt = G_define_option();
units_opt->key = "units";
units_opt->type = TYPE_STRING;
units_opt->required = NO;
units_opt->multiple = NO;
units_opt->options = "meters,kilometers,feet,miles,nautmiles";
units_opt->answer = "meters";
units_opt->description = _("Length units");
vertices_opt = G_define_option();
vertices_opt->key = "vertices";
vertices_opt->type = TYPE_INTEGER;
vertices_opt->required = NO;
vertices_opt->multiple = NO;
vertices_opt->description = _("Maximum number of vertices in segment");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if ((length_opt->answer && vertices_opt->answer) ||
!(length_opt->answer || vertices_opt->answer))
G_fatal_error(_("Use either length or vertices"));
line_length = NULL;
if (length_opt->answer) {
length = atof(length_opt->answer);
if (length <= 0)
G_fatal_error(_("Length must be positive but is %g"), length);
/* convert length to meters */
if (strcmp(units_opt->answer, "meters") == 0)
/* do nothing */ ;
else if (strcmp(units_opt->answer, "kilometers") == 0)
length *= FROM_KILOMETERS;
else if (strcmp(units_opt->answer, "feet") == 0)
length *= FROM_FEET;
else if (strcmp(units_opt->answer, "miles") == 0)
length *= FROM_MILES;
else if (strcmp(units_opt->answer, "nautmiles") == 0)
length *= FROM_NAUTMILES;
else
G_fatal_error(_("Unknown unit %s"), units_opt->answer);
/* set line length function */
if ((latlon = (G_projection() == PROJECTION_LL)) == 1)
line_length = Vect_line_geodesic_length;
else {
double factor;
line_length = Vect_line_length;
/* convert length to map units */
if ((factor = G_database_units_to_meters_factor()) == 0)
G_fatal_error(_("Can not get projection units"));
else {
/* meters to units */
length = length / factor;
}
}
G_verbose_message(_("length in %s: %g"), (latlon ? "meters" : "map units"), length);
}
if (vertices_opt->answer) {
vertices = atoi(vertices_opt->answer);
if (vertices < 2)
G_fatal_error(_("Number of vertices must be at least 2"));
}
Vect_set_open_level(2);
Vect_open_old2(&In, in_opt->answer, "", layer_opt->answer);
layer = Vect_get_field_number(&In, layer_opt->answer);
Vect_open_new(&Out, out_opt->answer, Vect_is_3d(&In));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_tables(&In, &Out, layer);
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype;
G_percent(line, nlines, 1);
if (!Vect_line_alive(&In, line))
continue;
ltype = Vect_read_line(&In, Points, Cats, line);
if (layer != -1 && !Vect_cat_get(Cats, layer, NULL))
continue;
if (ltype & GV_LINES) {
if (length > 0) {
double l, from, to, step;
l = line_length(Points);
if (l <= length) {
Vect_write_line(&Out, ltype, Points, Cats);
}
else {
int n, i;
n = ceil(l / length);
if (latlon)
l = Vect_line_length(Points);
step = l / n;
from = 0.;
for (i = 0; i < n; i++) {
int ret;
double x, y, z;
if (i == n - 1) {
to = l; /* to be sure that it goes to end */
}
else {
to = from + step;
}
ret = Vect_line_segment(Points, from, to, Points2);
if (ret == 0) {
G_warning(_("Unable to make line segment: %f - %f (line length = %f)"),
from, to, l);
continue;
}
/* To be sure that the coordinates are identical */
if (i > 0) {
Points2->x[0] = x;
Points2->y[0] = y;
Points2->z[0] = z;
}
if (i == n - 1) {
Points2->x[Points2->n_points - 1] =
Points->x[Points->n_points - 1];
Points2->y[Points2->n_points - 1] =
Points->y[Points->n_points - 1];
Points2->z[Points2->n_points - 1] =
Points->z[Points->n_points - 1];
}
Vect_write_line(&Out, ltype, Points2, Cats);
/* last point */
x = Points2->x[Points2->n_points - 1];
y = Points2->y[Points2->n_points - 1];
z = Points2->z[Points2->n_points - 1];
from += step;
}
}
}
else {
int start = 0; /* number of coordinates written */
while (start < Points->n_points - 1) {
int i, v;
Vect_reset_line(Points2);
for (i = 0; i < vertices; i++) {
v = start + i;
if (v == Points->n_points)
break;
Vect_append_point(Points2, Points->x[v], Points->y[v],
Points->z[v]);
}
Vect_write_line(&Out, ltype, Points2, Cats);
start = v;
}
}
}
else {
Vect_write_line(&Out, ltype, Points, Cats);
}
}
Vect_close(&In);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int camera_angle(char *name)
{
int row, col, nrows, ncols;
double XC = group.XC;
double YC = group.YC;
double ZC = group.ZC;
double c_angle, c_angle_min, c_alt, c_az, slope, aspect;
double radians_to_degrees = 180.0 / M_PI;
/* double degrees_to_radians = M_PI / 180.0; */
DCELL e1, e2, e3, e4, e5, e6, e7, e8, e9;
double factor, V, H, dx, dy, dz, key;
double north, south, east, west, ns_med;
FCELL *fbuf0, *fbuf1, *fbuf2, *tmpbuf, *outbuf;
int elevfd, outfd;
struct Cell_head cellhd;
struct Colors colr;
FCELL clr_min, clr_max;
struct History hist;
char *type;
G_message(_("Calculating camera angle to local surface..."));
select_target_env();
/* align target window to elevation map, otherwise we get artefacts
* like in r.slope.aspect -a */
Rast_get_cellhd(elev_name, elev_mapset, &cellhd);
Rast_align_window(&target_window, &cellhd);
Rast_set_window(&target_window);
elevfd = Rast_open_old(elev_name, elev_mapset);
if (elevfd < 0) {
G_fatal_error(_("Could not open elevation raster"));
return 1;
}
nrows = target_window.rows;
ncols = target_window.cols;
outfd = Rast_open_new(name, FCELL_TYPE);
fbuf0 = Rast_allocate_buf(FCELL_TYPE);
fbuf1 = Rast_allocate_buf(FCELL_TYPE);
fbuf2 = Rast_allocate_buf(FCELL_TYPE);
outbuf = Rast_allocate_buf(FCELL_TYPE);
/* give warning if location units are different from meters and zfactor=1 */
factor = G_database_units_to_meters_factor();
if (factor != 1.0)
G_warning(_("Converting units to meters, factor=%.6f"), factor);
G_begin_distance_calculations();
north = Rast_row_to_northing(0.5, &target_window);
ns_med = Rast_row_to_northing(1.5, &target_window);
south = Rast_row_to_northing(2.5, &target_window);
east = Rast_col_to_easting(2.5, &target_window);
west = Rast_col_to_easting(0.5, &target_window);
V = G_distance(east, north, east, south) * 4;
H = G_distance(east, ns_med, west, ns_med) * 4;
c_angle_min = 90;
Rast_get_row(elevfd, fbuf1, 0, FCELL_TYPE);
Rast_get_row(elevfd, fbuf2, 1, FCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_set_null_value(outbuf, ncols, FCELL_TYPE);
/* first and last row */
if (row == 0 || row == nrows - 1) {
Rast_put_row(outfd, outbuf, FCELL_TYPE);
continue;
}
tmpbuf = fbuf0;
fbuf0 = fbuf1;
fbuf1 = fbuf2;
fbuf2 = tmpbuf;
Rast_get_row(elevfd, fbuf2, row + 1, FCELL_TYPE);
north = Rast_row_to_northing(row + 0.5, &target_window);
for (col = 1; col < ncols - 1; col++) {
e1 = fbuf0[col - 1];
if (Rast_is_d_null_value(&e1))
continue;
e2 = fbuf0[col];
if (Rast_is_d_null_value(&e2))
continue;
e3 = fbuf0[col + 1];
if (Rast_is_d_null_value(&e3))
continue;
e4 = fbuf1[col - 1];
if (Rast_is_d_null_value(&e4))
continue;
e5 = fbuf1[col];
if (Rast_is_d_null_value(&e5))
continue;
e6 = fbuf1[col + 1];
if (Rast_is_d_null_value(&e6))
continue;
e7 = fbuf2[col - 1];
if (Rast_is_d_null_value(&e7))
continue;
e8 = fbuf2[col];
if (Rast_is_d_null_value(&e8))
continue;
e9 = fbuf2[col + 1];
if (Rast_is_d_null_value(&e9))
continue;
dx = ((e1 + e4 + e4 + e7) - (e3 + e6 + e6 + e9)) / H;
dy = ((e7 + e8 + e8 + e9) - (e1 + e2 + e2 + e3)) / V;
/* compute topographic parameters */
key = dx * dx + dy * dy;
/* slope in radians */
slope = atan(sqrt(key));
/* aspect in radians */
if (key == 0.)
aspect = 0.;
else if (dx == 0) {
if (dy > 0)
aspect = M_PI / 2;
else
aspect = 1.5 * M_PI;
}
else {
aspect = atan2(dy, dx);
if (aspect <= 0.)
aspect = 2 * M_PI + aspect;
}
/* camera altitude angle in radians */
east = Rast_col_to_easting(col + 0.5, &target_window);
dx = east - XC;
dy = north - YC;
dz = ZC - e5;
c_alt = atan(sqrt(dx * dx + dy * dy) / dz);
/* camera azimuth angle in radians */
c_az = atan(dy / dx);
if (east < XC && north != YC)
c_az += M_PI;
else if (north < YC && east > XC)
c_az += 2 * M_PI;
/* camera angle to real ground */
/* orthogonal to ground: 90 degrees */
/* parallel to ground: 0 degrees */
c_angle = asin(cos(c_alt) * cos(slope) - sin(c_alt) * sin(slope) * cos(c_az - aspect));
outbuf[col] = c_angle * radians_to_degrees;
if (c_angle_min > outbuf[col])
c_angle_min = outbuf[col];
}
Rast_put_row(outfd, outbuf, FCELL_TYPE);
}
G_percent(row, nrows, 2);
Rast_close(elevfd);
Rast_close(outfd);
G_free(fbuf0);
G_free(fbuf1);
G_free(fbuf2);
G_free(outbuf);
type = "raster";
Rast_short_history(name, type, &hist);
Rast_command_history(&hist);
Rast_write_history(name, &hist);
Rast_init_colors(&colr);
if (c_angle_min < 0) {
clr_min = (FCELL)((int)(c_angle_min / 10 - 1)) * 10;
clr_max = 0;
Rast_add_f_color_rule(&clr_min, 0, 0, 0, &clr_max, 0,
0, 0, &colr);
}
clr_min = 0;
clr_max = 10;
Rast_add_f_color_rule(&clr_min, 0, 0, 0, &clr_max, 255,
0, 0, &colr);
clr_min = 10;
clr_max = 40;
Rast_add_f_color_rule(&clr_min, 255, 0, 0, &clr_max, 255,
255, 0, &colr);
clr_min = 40;
clr_max = 90;
Rast_add_f_color_rule(&clr_min, 255, 255, 0, &clr_max, 0,
255, 0, &colr);
Rast_write_colors(name, G_mapset(), &colr);
select_current_env();
return 1;
}
int do_scalebar(void)
{
double scale_size;
double length, width;
double x, x1, x2, y1, y2, y3;
int seg, i, j, lab;
int margin;
char num[50];
/* get scale size */
scale_size =
METERS_TO_INCHES * distance(PS.w.east, PS.w.west) / scale(PS.scaletext);
/* convert scale size to map inches */
length = (sb.length / scale_size) *
G_database_units_to_meters_factor() * METERS_TO_INCHES;
/* if(sb.units == SB_UNITS_AUTO) { do nothing } */
if(sb.units == SB_UNITS_METERS)
length /= G_database_units_to_meters_factor();
else if(sb.units == SB_UNITS_KM)
length *= KILOMETERS_TO_METERS / G_database_units_to_meters_factor();
else if(sb.units == SB_UNITS_FEET)
length *= FEET_TO_METERS / G_database_units_to_meters_factor();
else if(sb.units == SB_UNITS_MILES)
length *= MILES_TO_METERS / G_database_units_to_meters_factor();
else if(sb.units == SB_UNITS_NMILES)
length *= NAUT_MILES_TO_METERS / G_database_units_to_meters_factor();
width = sb.height;
seg = sb.segment;
j = 0;
lab = 0;
margin = (int)(0.2 * (double)sb.fontsize + 0.5);
if (margin < 2)
margin = 2;
fprintf(PS.fp, "/mg %d def\n", margin);
x = sb.x - (length / 2.);
set_font_size(sb.fontsize);
set_line_width(sb.width);
if (strcmp(sb.type, "f") == 0) {
/* draw fancy scale bar */
for (i = 0; i < seg; i++) {
/* draw a filled rectangle */
x1 = 72.0 * (x + (length / seg) * i) + 0.5;
y1 = 72.0 * (PS.page_height - sb.y);
x2 = 72.0 * (x + (length / seg) * (i + 1)) + 0.5;
y2 = (72.0 * (PS.page_height - sb.y)) + (width * 72.0);
/* Alternate black and white */
if (j == 0) {
fprintf(PS.fp, "0.0 0.0 0.0 C\n");
j = 1;
}
else {
fprintf(PS.fp, "1.0 1.0 1.0 C\n");
j = 0;
}
fprintf(PS.fp, "%.1f %.1f %.1f %.1f B\n", x1, y1, x2, y2);
/* set outline to black */
fprintf(PS.fp, "F 0.0 0.0 0.0 C\n");
fprintf(PS.fp, "D\n");
lab++;
/* do text */
if (i == 0 || lab == sb.numbers) {
sprintf(num, "%s", nice_number((sb.length / sb.segment) * i));
text_box_path(x1, y2 + margin, CENTER, LOWER, num,
sb.fontsize, 0);
if (sb.bgcolor) { /* TODO: take bg color, not just [white|none] */
set_rgb_color(WHITE);
fprintf(PS.fp, "F ");
}
set_rgb_color(BLACK);
fprintf(PS.fp, "TIB\n");
lab = 0;
}
if ((lab > 0 && i == seg - 1) ||
(sb.numbers == 1 && i == seg - 1)) {
/* special case for last label */
sprintf(num, "%s", nice_number(sb.length));
text_box_path(x2, y2 + margin, CENTER, LOWER, num,
sb.fontsize, 0);
if (sb.bgcolor) {
set_rgb_color(WHITE);
fprintf(PS.fp, "F ");
}
set_rgb_color(BLACK);
fprintf(PS.fp, "TIB\n");
}
}
}
else {
/* draw simple scalebar */
x1 = 72.0 * x + 0.5;
y1 = (72.0 * (PS.page_height - sb.y)) + (width * 72.0);
x2 = 72.0 * x + 0.5;
y2 = 72.0 * (PS.page_height - sb.y);
fprintf(PS.fp, "%.1f %.1f %.1f %.1f L D\n", x1, y1, x2, y2);
/* draw label */
text_box_path(x1, y1 + margin, CENTER, LOWER, "0", sb.fontsize, 0);
if (sb.bgcolor) {
set_rgb_color(WHITE);
fprintf(PS.fp, "F ");
}
set_rgb_color(BLACK);
fprintf(PS.fp, "TIB\n");
x1 = 72.0 * x + 0.5;
y1 = 72.0 * (PS.page_height - sb.y);
x2 = 72.0 * (x + length) + 0.5;
y2 = 72.0 * (PS.page_height - sb.y);
fprintf(PS.fp, "%.1f %.1f %.1f %.1f L D\n", x1, y1, x2, y2);
x1 = 72.0 * (x + length) + 0.5;
y2 = (72.0 * (PS.page_height - sb.y)) + (width * 72.0);
x2 = 72.0 * (x + length) + 0.5;
y1 = 72.0 * (PS.page_height - sb.y);
fprintf(PS.fp, "%.1f %.1f %.1f %.1f L D\n", x1, y1, x2, y2);
/* draw label */
sprintf(num, "%s", nice_number(sb.length));
text_box_path(x1, y2 + margin, CENTER, LOWER, num, sb.fontsize, 0);
if (sb.bgcolor) {
set_rgb_color(WHITE);
fprintf(PS.fp, "F ");
}
set_rgb_color(BLACK);
fprintf(PS.fp, "TIB\n");
for (i = 1; i < seg; i++) {
x1 = 72.0 * (x + (length / seg) * i) + 0.5;
y1 = 72.0 * (PS.page_height - sb.y);
x2 = 72.0 * (x + (length / seg) * i) + 0.5;
y2 = (72.0 * (PS.page_height - sb.y)) + (width / 2. * 72.0);
y3 = (72.0 * (PS.page_height - sb.y)) + (width * 72.0);
fprintf(PS.fp, "%.1f %.1f %.1f %.1f L D\n", x1, y1, x2, y2);
lab++;
/* do text */
if (lab == sb.numbers) {
sprintf(num, "%s", nice_number((sb.length / sb.segment) * i));
text_box_path(x1, y3 + margin, CENTER, LOWER, num,
sb.fontsize, 0);
if (sb.bgcolor) {
set_rgb_color(WHITE);
fprintf(PS.fp, "F ");
}
set_rgb_color(BLACK);
fprintf(PS.fp, "TIB\n");
lab = 0;
}
}
}
/* draw units label */
if (sb.units == SB_UNITS_AUTO)
strcpy(num, G_database_unit_name(TRUE));
else if(sb.units == SB_UNITS_METERS)
strcpy(num, "meters");
else if(sb.units == SB_UNITS_KM)
strcpy(num, "kilometers");
else if(sb.units == SB_UNITS_FEET)
strcpy(num, "feet");
else if(sb.units == SB_UNITS_MILES)
strcpy(num, "miles");
else if(sb.units == SB_UNITS_NMILES)
strcpy(num, "nautical miles");
text_box_path(72.0 * (x + length/2), 72.0 * (PS.page_height - (sb.y + 0.075)),
CENTER, UPPER, num, sb.fontsize, 0);
if (sb.bgcolor) {
set_rgb_color(WHITE);
fprintf(PS.fp, "F ");
}
set_rgb_color(BLACK);
fprintf(PS.fp, "TIB\n");
return 0;
}
int draw_scale(char *save, int toptext, int size)
{
double meters;
double line_len;
int incr;
int x_pos, y_pos;
int t, b, l, r;
int pt, pb, pl, pr;
int i;
int xarr[5], yarr[5];
double seg_len;
const struct scale *scales = all_scales[use_feet];
/* Establish text size */
D_get_screen_window(&t, &b, &l, &r);
R_set_window(t, b, l, r);
R_text_size(size, size);
x_pos = (int)(east * (r - l) / 100.);
y_pos = (int)(north * (b - t) / 100.);
if (draw == 1) {
int w, h;
w = 30;
h = 17 + 2 * w;
pl = x_pos;
pt = y_pos;
pr = x_pos + w + 2; /* 1 pixel margin for both sides */
pb = y_pos + h + 2; /* 1 pixel margin for both sides */
if (save)
R_panel_save(save, pt, pb, pl, pr);
if (do_background) {
D_raster_use_color(color1);
R_box_abs(pl, pt, pr, pb);
}
/* Draw legend */
D_raster_use_color(color2);
R_move_abs(pl + w / 2 + 1, pt + 17 + 1);
xarr[0] = 0;
yarr[0] = 0;
xarr[1] = -w / 2;
yarr[1] = 2 * w;
xarr[2] = w / 2;
yarr[2] = -w / 2;
xarr[3] = 0;
yarr[3] = -1.5 * w;
R_polyline_rel(xarr, yarr, 4);
xarr[1] = -xarr[1];
xarr[2] = -xarr[2];
R_polygon_rel(xarr, yarr, 4);
/* actual text width is 81% of size? from d.legend */
R_move_abs((int)(pl + w / 2 - 7 * .81), pt + 14);
R_text("N");
R_stabilize();
return 0;
}
meters = D_get_u_east() - D_get_u_west();
meters *= G_database_units_to_meters_factor();
/* find the right scale */
for (incr = 0; incr < NUMSCALES; incr++) {
if (meters <= scales[incr].limit)
break;
}
if (!incr)
return (-1);
/* beyond the maximum just make the longest scale narrower */
if (incr >= NUMSCALES)
incr = NUMSCALES - 1;
line_len = D_get_u_to_d_xconv() * scales[incr].size
/ G_database_units_to_meters_factor();
seg_len = line_len / scales[incr].seg;
/* work around round off */
line_len = ((int)seg_len) * scales[incr].seg;
/* Blank out area with background color */
if (toptext) {
pr = x_pos + 35 + (int)line_len;
pt = y_pos - 15;
if (pt < t)
pt = t;
}
else {
pr = x_pos + 35 + (int)line_len + size * strlen(scales[incr].name);
pt = y_pos + 0;
if (pt < t)
pt = t;
}
pb = y_pos + 30;
if (pb > b)
pb = b;
pl = x_pos + 0;
if (pl < l)
pl = l;
pr = pr;
if (pr > r)
pr = r;
if (save)
R_panel_save(save, pt, pb, pl, pr);
if (do_background) {
D_raster_use_color(color1);
R_box_abs(pl, pt, pr, pb);
}
/* Draw legend */
D_raster_use_color(color2);
if (draw != 2) {
R_move_abs(x_pos + 5, y_pos + 20);
R_cont_rel(0, -10);
R_cont_rel(10, 10);
R_cont_rel(0, -10);
R_move_rel(-5, 14);
R_cont_rel(0, -17);
R_cont_rel(-2, -0);
R_cont_rel(2, -2);
R_cont_rel(2, 2);
R_cont_rel(-2, -0);
}
if (draw == 2) {
R_move_abs(x_pos + 25 - draw * 10, y_pos + 17);
/* actual width is line_len-1+1=line_len and height is 7+1=8 */
R_cont_rel((int)line_len - 1, 0);
R_cont_rel(0, -7);
R_cont_rel((int)(line_len * -1 + 1), 0);
R_cont_rel(0, 7);
R_move_rel(0, 1 - 4);
for (i = 1; i <= scales[incr].seg; i++) {
xarr[0] = 0;
yarr[0] = 0;
xarr[1] = (int)seg_len;
yarr[1] = 0;
xarr[2] = 0;
yarr[2] = (i % 2 ? -4 : 4);
xarr[3] = (int)-seg_len;
yarr[3] = 0;
xarr[4] = 0;
yarr[4] = (i % 2 ? 4 : -4);
/* width is seg_len and height is 4 */
R_polygon_rel(xarr, yarr, 4);
R_move_rel((int)seg_len, 0);
}
}
else if (do_bar) {
R_move_abs(x_pos + 25, y_pos + 17);
/* actual width is line_len-1+1=line_len and height is 4+1=5 */
R_cont_rel((int)line_len - 1, 0);
R_cont_rel(0, -4);
R_cont_rel((int)(line_len * -1 + 1), 0);
R_cont_rel(0, 4);
R_move_rel(0, 1);
for (i = 1; i <= scales[incr].seg; i += 2) {
/* width is seg_len and height is 5 */
R_box_rel((int)seg_len, -5);
R_move_rel((int)(seg_len * 2), 0);
}
}
else { /* draw simple line scale */
R_move_abs(x_pos + 25, y_pos + 5);
R_cont_abs(x_pos + 25, y_pos + 25);
R_move_abs(x_pos + 25, y_pos + 15);
R_cont_abs(x_pos + 25 + (int)line_len, y_pos + 15);
R_move_abs(x_pos + 25 + (int)line_len, y_pos + 5);
R_cont_abs(x_pos + 25 + (int)line_len, y_pos + 25);
}
if (toptext) {
R_move_abs(x_pos + 25 - draw * 10 +
(int)(line_len / 2. -
strlen(scales[incr].name) * size * 0.81 / 2), y_pos);
R_text(scales[incr].name);
}
else {
R_move_abs(x_pos + 35 - draw * 10 + (int)line_len, y_pos + 20);
R_text(scales[incr].name);
}
R_stabilize();
return (0);
}
int main(int argc, char *argv[])
{
int ii;
int ret_val;
struct Cell_head cellhd;
struct WaterParams wp;
struct options parm;
struct flags flag;
long seed_value;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("soil"));
G_add_keyword(_("sediment flow"));
G_add_keyword(_("erosion"));
G_add_keyword(_("deposition"));
G_add_keyword(_("model"));
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 = "water_depth";
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 = "detachment_coeff";
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 = "transport_coeff";
parm.tranin->description =
_("Name of transport capacity coefficient raster map [s]");
parm.tauin = G_define_standard_option(G_OPT_R_INPUT);
parm.tauin->key = "shear_stress";
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.observation = G_define_standard_option(G_OPT_V_INPUT);
parm.observation->key = "observation";
parm.observation->required = NO;
parm.observation->label =
_("Name of sampling locations vector points map");
parm.observation->guisection = _("Input");
parm.tc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.tc->key = "transport_capacity";
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 = "tlimit_erosion_deposition";
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 = "sediment_concentration";
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 = "sediment_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 = "erosion_deposition";
parm.erdep->required = NO;
parm.erdep->description =
_("Name for output erosion-deposition raster map [kg/m2s]");
parm.erdep->guisection = _("Output");
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.outwalk = G_define_standard_option(G_OPT_V_OUTPUT);
parm.outwalk->key = "walkers_output";
parm.outwalk->required = NO;
parm.outwalk->description =
_("Base name of the output walkers vector points map");
parm.outwalk->guisection = _("Output");
parm.nwalk = G_define_option();
parm.nwalk->key = "nwalkers";
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 = "niterations";
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 = "output_step";
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 = "diffusion_coeff";
parm.diffc->type = TYPE_DOUBLE;
parm.diffc->answer = DIFFC;
parm.diffc->required = NO;
parm.diffc->description = _("Water diffusion constant");
parm.diffc->guisection = _("Parameters");
parm.seed = G_define_option();
parm.seed->key = "random_seed";
parm.seed->type = TYPE_INTEGER;
parm.seed->required = NO;
parm.seed->label = _("Seed for random number generator");
parm.seed->description =
_("The same seed can be used to obtain same results"
" or random seed can be generated by other means.");
flag.generateSeed = G_define_flag();
flag.generateSeed->key = 's';
flag.generateSeed->label =
_("Generate random seed");
flag.generateSeed->description =
_("Automatically generates random seed for random number"
" generator (use when you don't want to provide the seed option)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (flag.generateSeed->answer) {
seed_value = G_srand48_auto();
G_verbose_message(_("Generated random seed (-s): %ld"), seed_value);
}
else if (parm.seed->answer) {
seed_value = atol(parm.seed->answer);
G_srand48(seed_value);
G_verbose_message(_("Read random seed from %s option: %ld"),
parm.seed->key, seed_value);
}
else {
/* default as it used to be */
G_srand48(12345);
}
G_get_set_window(&cellhd);
WaterParams_init(&wp);
wp.conv = G_database_units_to_meters_factor();
wp.mixx = cellhd.west * wp.conv;
wp.maxx = cellhd.east * wp.conv;
wp.miyy = cellhd.south * wp.conv;
wp.mayy = cellhd.north * wp.conv;
wp.stepx = cellhd.ew_res * wp.conv;
wp.stepy = cellhd.ns_res * wp.conv;
/* wp.step = amin1(wp.stepx,wp.stepy); */
wp.step = (wp.stepx + wp.stepy) / 2.;
wp.mx = cellhd.cols;
wp.my = cellhd.rows;
wp.xmin = 0.;
wp.ymin = 0.;
wp.xp0 = wp.xmin + wp.stepx / 2.;
wp.yp0 = wp.ymin + wp.stepy / 2.;
wp.xmax = wp.xmin + wp.stepx * (float)wp.mx;
wp.ymax = wp.ymin + wp.stepy * (float)wp.my;
wp.hhc = wp.hhmax = 0.;
#if 0
wp.bxmi = 2093113. * wp.conv;
wp.bymi = 731331. * wp.conv;
wp.bxma = 2093461. * wp.conv;
wp.byma = 731529. * wp.conv;
wp.bresx = 2. * wp.conv;
wp.bresy = 2. * wp.conv;
wp.maxwab = 100000;
wp.mx2o = (int)((wp.bxma - wp.bxmi) / wp.bresx);
wp.my2o = (int)((wp.byma - wp.bymi) / wp.bresy);
/* relative small box coordinates: leave 1 grid layer for overlap */
wp.bxmi = wp.bxmi - wp.mixx + wp.stepx;
wp.bymi = wp.bymi - wp.miyy + wp.stepy;
wp.bxma = wp.bxma - wp.mixx - wp.stepx;
wp.byma = wp.byma - wp.miyy - wp.stepy;
wp.mx2 = wp.mx2o - 2 * ((int)(wp.stepx / wp.bresx));
wp.my2 = wp.my2o - 2 * ((int)(wp.stepy / wp.bresy));
#endif
wp.elevin = parm.elevin->answer;
wp.wdepth = parm.wdepth->answer;
wp.dxin = parm.dxin->answer;
wp.dyin = parm.dyin->answer;
wp.detin = parm.detin->answer;
wp.tranin = parm.tranin->answer;
wp.tauin = parm.tauin->answer;
wp.manin = parm.manin->answer;
wp.tc = parm.tc->answer;
wp.et = parm.et->answer;
wp.conc = parm.conc->answer;
wp.flux = parm.flux->answer;
wp.erdep = parm.erdep->answer;
wp.outwalk = parm.outwalk->answer;
/* sscanf(parm.nwalk->answer, "%d", &wp.maxwa); */
sscanf(parm.niter->answer, "%d", &wp.timesec);
sscanf(parm.outiter->answer, "%d", &wp.iterout);
/* sscanf(parm.density->answer, "%d", &wp.ldemo); */
sscanf(parm.diffc->answer, "%lf", &wp.frac);
sscanf(parm.maninval->answer, "%lf", &wp.manin_val);
/* Recompute timesec from user input in minutes
* to real timesec in seconds */
wp.timesec = wp.timesec * 60;
wp.iterout = wp.iterout * 60;
if ((wp.timesec / wp.iterout) > 100)
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) {
wp.maxwa = wp.mx * wp.my * 2;
wp.rwalk = (double)(wp.mx * wp.my * 2.);
G_message(_("default nwalk=%d, rwalk=%f"), wp.maxwa, wp.rwalk);
}
else {
sscanf(parm.nwalk->answer, "%d", &wp.maxwa);
wp.rwalk = (double)wp.maxwa;
}
/*rwalk = (double) maxwa; */
if (wp.conv != 1.0)
G_message(_("Using metric conversion factor %f, step=%f"), wp.conv,
wp.step);
init_library_globals(&wp);
if ((wp.tc == NULL) && (wp.et == NULL) && (wp.conc == NULL) && (wp.flux == NULL) &&
(wp.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"));
alloc_grids_sediment();
grad_check();
init_grids_sediment();
/* treba dat output pre topoerdep */
main_loop();
/* always true for sediment? */
if (wp.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 ii;
int ret_val;
double x_orig, y_orig;
static int rand1 = 12345;
static int rand2 = 67891;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
module->description =
_("Overland flow hydrologic simulation using "
"path sampling method (SIMWE).");
parm.elevin = G_define_standard_option(G_OPT_R_ELEV);
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.rain = G_define_standard_option(G_OPT_R_INPUT);
parm.rain->key = "rain";
parm.rain->required = NO;
parm.rain->description =
_("Name of rainfall excess rate (rain-infilt) raster map [mm/hr]");
parm.rain->guisection = _("Input");
parm.rainval = G_define_option();
parm.rainval->key = "rain_value";
parm.rainval->type = TYPE_DOUBLE;
parm.rainval->answer = RAINVAL;
parm.rainval->required = NO;
parm.rainval->description =
_("Rainfall excess rate unique value [mm/hr]");
parm.rainval->guisection = _("Input");
parm.infil = G_define_standard_option(G_OPT_R_INPUT);
parm.infil->key = "infil";
parm.infil->required = NO;
parm.infil->description =
_("Name of runoff infiltration rate raster map [mm/hr]");
parm.infil->guisection = _("Input");
parm.infilval = G_define_option();
parm.infilval->key = "infil_value";
parm.infilval->type = TYPE_DOUBLE;
parm.infilval->answer = INFILVAL;
parm.infilval->required = NO;
parm.infilval->description =
_("Runoff infiltration rate unique value [mm/hr]");
parm.infilval->guisection = _("Input");
parm.manin = G_define_standard_option(G_OPT_R_INPUT);
parm.manin->key = "man";
parm.manin->required = NO;
parm.manin->description = _("Name of mannings 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 = _("Mannings n unique value");
parm.maninval->guisection = _("Input");
parm.traps = G_define_standard_option(G_OPT_R_INPUT);
parm.traps->key = "traps";
parm.traps->required = NO;
parm.traps->description =
_("Name of flow controls raster map (permeability ratio 0-1)");
parm.traps->guisection = _("Input");
parm.observation = G_define_standard_option(G_OPT_V_INPUT);
parm.observation->key = "observation";
parm.observation->required = NO;
parm.observation->description =
_("Name of the 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 of the sampling points output text file. For each observation vector point the time series of water depth is stored.");
parm.logfile->guisection = _("Output");
parm.depth = G_define_standard_option(G_OPT_R_OUTPUT);
parm.depth->key = "depth";
parm.depth->required = NO;
parm.depth->description = _("Name for output water depth raster map [m]");
parm.depth->guisection = _("Output");
parm.disch = G_define_standard_option(G_OPT_R_OUTPUT);
parm.disch->key = "disch";
parm.disch->required = NO;
parm.disch->description = _("Name for output water discharge raster map [m3/s]");
parm.disch->guisection = _("Output");
parm.err = G_define_standard_option(G_OPT_R_OUTPUT);
parm.err->key = "err";
parm.err->required = NO;
parm.err->description = _("Name for output simulation error raster map [m]");
parm.err->guisection = _("Output");
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.nwalk = G_define_option();
parm.nwalk->key = "nwalk";
parm.nwalk->type = TYPE_INTEGER;
parm.nwalk->required = NO;
parm.nwalk->description =
_("Number of walkers, default is twice the no. of cells");
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");
parm.hmax = G_define_option();
parm.hmax->key = "hmax";
parm.hmax->type = TYPE_DOUBLE;
parm.hmax->answer = HMAX;
parm.hmax->required = NO;
parm.hmax->label =
_("Threshold water depth [m]");
parm.hmax->description = _("Diffusion increases after this water depth is reached");
parm.hmax->guisection = _("Parameters");
parm.halpha = G_define_option();
parm.halpha->key = "halpha";
parm.halpha->type = TYPE_DOUBLE;
parm.halpha->answer = HALPHA;
parm.halpha->required = NO;
parm.halpha->description = _("Diffusion increase constant");
parm.halpha->guisection = _("Parameters");
parm.hbeta = G_define_option();
parm.hbeta->key = "hbeta";
parm.hbeta->type = TYPE_DOUBLE;
parm.hbeta->answer = HBETA;
parm.hbeta->required = NO;
parm.hbeta->description =
_("Weighting factor for water flow velocity vector");
parm.hbeta->guisection = _("Parameters");
flag.tserie = G_define_flag();
flag.tserie->key = 't';
flag.tserie->description = _("Time-series output");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&cellhd);
conv = G_database_units_to_meters_factor();
mixx = conv * cellhd.west;
maxx = conv * cellhd.east;
miyy = conv * cellhd.south;
mayy = conv * cellhd.north;
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;
ts = flag.tserie->answer;
elevin = parm.elevin->answer;
dxin = parm.dxin->answer;
dyin = parm.dyin->answer;
rain = parm.rain->answer;
infil = parm.infil->answer;
traps = parm.traps->answer;
manin = parm.manin->answer;
depth = parm.depth->answer;
disch = parm.disch->answer;
err = parm.err->answer;
outwalk = parm.outwalk->answer;
sscanf(parm.niter->answer, "%d", ×ec);
sscanf(parm.outiter->answer, "%d", &iterout);
sscanf(parm.diffc->answer, "%lf", &frac);
sscanf(parm.hmax->answer, "%lf", &hhmax);
sscanf(parm.halpha->answer, "%lf", &halpha);
sscanf(parm.hbeta->answer, "%lf", &hbeta);
/* if no rain map input, then: */
if (parm.rain->answer == NULL) {
/*Check for Rain Unique Value Input */
/* if no rain unique value input */
if (parm.rainval->answer == NULL) {
/*No rain input so use default */
sscanf(RAINVAL, "%lf", &rain_val);
/* if rain unique input exist, load it */
}
else {
/*Unique value input only */
sscanf(parm.rainval->answer, "%lf", &rain_val);
}
/* if Rain map exists */
}
else {
/*Map input, so set rain_val to -999.99 */
if (parm.rainval->answer == NULL) {
rain_val = -999.99;
}
else {
/*both map and unique value exist */
/*Choose the map, discard the unique value */
rain_val = -999.99;
}
}
/* Report the final value of rain_val */
G_debug(3, "rain_val is set to: %f\n", rain_val);
/* if no Mannings map, then: */
if (parm.manin->answer == NULL) {
/*Check for Manin Unique Value Input */
/* if no Mannings unique value input */
if (parm.maninval->answer == NULL) {
/*No Mannings input so use default */
sscanf(MANINVAL, "%lf", &manin_val);
/* if mannings unique input value exists, load it */
}
else {
/*Unique value input only */
sscanf(parm.maninval->answer, "%lf", &manin_val);
}
/* if Mannings map exists */
}
else {
/* Map input, set manin_val to -999.99 */
if (parm.maninval->answer == NULL) {
manin_val = -999.99;
}
else {
/*both map and unique value exist */
/*Choose map, discard the unique value */
manin_val = -999.99;
}
}
/* Report the final value of manin_val */
G_debug(1, "manin_val is set to: %f\n", manin_val);
/* if no infiltration map, then: */
if (parm.infil->answer == NULL) {
/*Check for Infil Unique Value Input */
/*if no infiltration unique value input */
if (parm.infilval->answer == NULL) {
/*No infiltration unique value so use default */
sscanf(INFILVAL, "%lf", &infil_val);
/* if infiltration unique value exists, load it */
}
else {
/*unique value input only */
sscanf(parm.infilval->answer, "%lf", &infil_val);
}
/* if infiltration map exists */
}
else {
/* Map input, set infil_val to -999.99 */
if (parm.infilval->answer == NULL) {
infil_val = -999.99;
}
else {
/*both map and unique value exist */
/*Choose map, discard the unique value */
infil_val = -999.99;
}
}
/* Report the final value of infil_val */
G_debug(1, "infil_val is set to: %f\n", infil_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 ((depth == NULL) && (disch == NULL) && (err == NULL))
G_warning(_("You are not outputting any raster maps"));
ret_val = input_data();
if (ret_val != 1)
G_fatal_error(_("Input failed"));
/* memory allocation for output grids */
G_debug(1, "beginning memory allocation for output grids");
gama = G_alloc_matrix(my, mx);
if (err != NULL)
gammas = G_alloc_matrix(my, mx);
dif = G_alloc_fmatrix(my, mx);
G_debug(1, "seeding randoms");
seeds(rand1, rand2);
grad_check();
main_loop();
if (ts == 0) {
ii = output_data(0, 1.);
if (ii != 1)
G_fatal_error(_("Cannot write raster maps"));
}
/* Exit with Success */
exit(EXIT_SUCCESS);
}
/*!
* \brief Initiate a pde geometry data structure with a 2d region
*
* If the projection is not planimetric, a double array will be created based on the
* number of rows of the provided region storing all computed areas for each row
*
* \param region sruct Cell_head *
* \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_2d(struct Cell_head * region,
N_geom_data * geodata)
{
N_geom_data *geom = geodata;
struct Cell_head backup;
double meters;
short ll = 0;
int i;
/*create an openmp lock to assure that only one thread at a time will access this function */
#pragma omp critical
{
G_debug(2,
"N_init_geom_data_2d: initializing the geometry structure");
/*make a backup from this region */
G_get_set_window(&backup); /*this function is not thread safe */
/*set the current region */
Rast_set_window(region); /*this function is not thread safe */
if (geom == NULL)
geom = N_alloc_geom_data();
meters = G_database_units_to_meters_factor(); /*this function is not thread safe */
/*set the dim to 2d if it was not initiated with 3, that's a bit ugly :( */
if (geom->dim != 3)
geom->dim = 2;
geom->planimetric = 1;
geom->rows = region->rows;
geom->cols = region->cols;
geom->dx = region->ew_res * meters;
geom->dy = region->ns_res * meters;
geom->Az = geom->dy * geom->dx; /*square meters in planimetric proj */
/*depths and dz are initialized with a 3d region */
/*Begin the area calculation */
ll = G_begin_cell_area_calculations(); /*this function is not thread safe */
/*if the projection is not planimetric, calc the area for each row */
if (ll == 2) {
G_debug(2,
"N_init_geom_data_2d: calculating the areas for non parametric projection");
geom->planimetric = 0;
if (geom->area != NULL)
G_free(geom->area);
else
geom->area = G_calloc(geom->rows, sizeof(double));
/*fill the area vector */
for (i = 0; i < geom->rows; i++) {
geom->area[i] = G_area_of_cell_at_row(i); /*square meters */
}
}
/*restore the old region */
Rast_set_window(&backup); /*this function is not thread safe */
}
return geom;
}
