/*! * \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; }