/* useful to create randomised samples for statistical tests */
void do_split_sample ( char *input, char *output, int in_types, double percentage, char *map,
int all, int processing_mode, int quiet) {
CELL *cellbuf;
DCELL *dcellbuf;
GT_Row_cache_t *cache;
int fd;
int i,j,k,l;
int no_sites;
int sites_tried = 0;
struct Cell_head region;
int error;
char *mapset, errmsg [200];
unsigned int *taken; /* this is an array of 0/1 which signals, if
a certain site has already been 'drawn' */
long row_idx, col_idx;
struct Map_info in_vect_map;
struct Map_info out_vect_map;
struct line_pnts *vect_points;
struct line_cats *vect_cats;
double x,y,z;
int n_points = 1;
int cur_type;
cellbuf = NULL;
dcellbuf = NULL;
cache = NULL;
/* get current region */
G_get_window (®ion);
/* attempt to create new file for output */
Vect_set_open_level (2);
if (0 > Vect_open_new (&out_vect_map, output, 0) ) {
G_fatal_error ("Could not open output vector map.\n");
}
/* open input vector map */
if ((mapset = G_find_vector2 (input, "")) == NULL) {
sprintf (errmsg, "Could not find input %s\n", input);
G_fatal_error ("%s",errmsg);
}
if (1 > Vect_open_old (&in_vect_map, input, "")) {
sprintf (errmsg, "Could not open input map %s.\n", input);
G_fatal_error ("%s",errmsg);
}
vect_points = Vect_new_line_struct ();
vect_cats = Vect_new_cats_struct ();
/* set constraints specified */
if (in_types != 0) {
Vect_set_constraint_type (&in_vect_map, in_types);
}
if (all != 1) {
Vect_set_constraint_region (&in_vect_map, region.north, region.south,
region.east, region.west, 0.0, 0.0);
}
/* get total number of objects with constraints */
i = 0;
while ((cur_type = Vect_read_next_line (&in_vect_map, vect_points, vect_cats) > 0)) {
i ++;
}
k = ( ((float) i/100)) * percentage; /* k now has the number of objects wanted */
if ( quiet != 1 ) {
fprintf (stderr,"Creating randomised sample of size n = %i.\n",k);
}
/* now, we need to acquire exactly 'k' random objects that fall in NON-NULL */
/* coverage raster cells. */
taken = G_calloc (i, sizeof (unsigned int));
for ( l = 0; l < k; l ++ ) {
taken[l] = 0;
}
no_sites = i; /* store this for later use */
/* does user want to filter objects through a raster map? */
if ( map != NULL) {
/* open raster map */
fd = G_open_cell_old (map, G_find_cell (map, ""));
if (fd < 0)
{
G_fatal_error ("Could not open raster map for reading!\n");
}
/* allocate cache and buffer, according to type of coverage */
if ( processing_mode == CELL_TYPE) {
/* INT coverage */
cache = (GT_Row_cache_t *) G_malloc (sizeof (GT_Row_cache_t));
/* TODO: check error value */
error = GT_RC_open (cache, cachesize, fd, CELL_TYPE);
cellbuf = G_allocate_raster_buf (CELL_TYPE);
}
if ( (processing_mode == FCELL_TYPE) || (processing_mode == DCELL_TYPE) ) {
/* FP coverage */
cache = (GT_Row_cache_t *) G_malloc (sizeof (GT_Row_cache_t));
/* TODO: check error value */
error = GT_RC_open (cache, cachesize, fd, DCELL_TYPE);
dcellbuf = G_allocate_raster_buf (DCELL_TYPE);
}
}
srand ( ((unsigned int) time (NULL)) + getpid()); /* set seed for random number generator from system time and process ID*/
i = 0;
/* MAIN LOOP */
while ( i < k ) {
/* get a random index, but one that was not taken already */
l = 0;
while ( l == 0 ) {
j = rand () % ( no_sites - 1 + 1) + 1; /* j now has the random position to try */
if ( taken[j-1] == 0 ) {
l = 1; /* exit loop */
}
}
taken [j-1] = 1; /* mark this index as 'taken' */
sites_tried ++; /* keep track of this so we do not enter an infinite loop */
if ( sites_tried > no_sites ) {
/* could not create a large enough sample */
G_fatal_error ("Could not find enough objects for split sampling.\nDecrease split sample size.\n");
}
/* get next vector object */
cur_type = Vect_read_line (&in_vect_map, vect_points, vect_cats, j);
if (cur_type < 0 ) {
G_fatal_error ("Error reading vector map: premature EOF.\n");
}
/* now, check if coverage under site is NON-NULL and within region */
/* convert site northing to row! */
/* for this check, we use only the first pair of coordinates! */
Vect_copy_pnts_to_xyz (vect_points, &x, &y, &z, &n_points);
row_idx =
(long) G_northing_to_row (y,
®ion);
col_idx =
(long) G_easting_to_col (x,
®ion);
/* do region check, first... OBSOLETE */
/* read row from cache and check for NULL */
/* if required */
if ( map != NULL ) {
if ( processing_mode == CELL_TYPE ) {
cellbuf = GT_RC_get (cache, row_idx);
if (!G_is_c_null_value(&cellbuf[col_idx])) {
i ++;
Vect_write_line (&out_vect_map, cur_type,
vect_points, vect_cats );
fflush (stdout);
}
}
if ( (processing_mode == FCELL_TYPE) || (processing_mode == DCELL_TYPE) ) {
dcellbuf = GT_RC_get (cache, row_idx);
if (!G_is_d_null_value(&dcellbuf[col_idx])) {
i ++;
Vect_write_line (&out_vect_map, cur_type,
vect_points, vect_cats );
fflush (stdout);
}
}
} else {
i ++;
Vect_write_line (&out_vect_map, GV_POINT,
vect_points, vect_cats );
fflush (stdout);
}
/* disregard region setting and map, if -a flag is given */
if ( all == 1 ) {
i ++;
Vect_write_line (&out_vect_map, cur_type,
vect_points, vect_cats );
fflush (stdout);
}
if ( quiet != 1 ) {
G_percent(i,k,1);
}
}
/* END OF MAIN LOOP */
Vect_copy_head_data (&in_vect_map, &out_vect_map);
fprintf (stdout, "Building topology information for output map.\n");
Vect_build (&out_vect_map);
Vect_close (&in_vect_map);
Vect_close (&out_vect_map);
if ( map != NULL ) {
/* close cache, free buffers! */
GT_RC_close (cache);
if ( processing_mode == CELL_TYPE ) {
G_free (cellbuf);
}
if ( (processing_mode == FCELL_TYPE) || (processing_mode == DCELL_TYPE) ) {
G_free (dcellbuf);
}
G_free (cache);
}
}
int read_points(const char *name, const char *field_name, const char *col, std::map<Point, Coord_type, K::Less_xy_2>& function_values,
std::vector<K::Point_2>& OutPoints)
{
int nrec, ctype = 0, npoints, field, with_z;
double x, y, z;
Point p;
struct Map_info Map;
struct field_info *Fi;
struct line_pnts *Points;
struct line_cats *Cats;
dbDriver *Driver;
dbCatValArray cvarr;
Vect_set_open_level(1); /* without topology */
if (Vect_open_old2(&Map, name, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), name);
field = Vect_get_field_number(&Map, field_name);
with_z = col == NULL && Vect_is_3d(&Map); /* read z-coordinates
only when column is
not defined */
if (!col) {
if (!with_z)
G_important_message(_("Input vector map <%s> is 2D - using categories to interpolate"),
Vect_get_full_name(&Map));
else
G_important_message(_("Input vector map <%s> is 3D - using z-coordinates to interpolate"),
Vect_get_full_name(&Map));
}
if (col) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %s"), field_name);
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"), Fi->database, Fi->driver);
nrec = db_select_CatValArray(Driver, Fi->table, Fi->key, col, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message("One record selected from table %d records selected from table", nrec);
db_close_database_shutdown_driver(Driver);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* set constraints */
Vect_set_constraint_type(&Map, GV_POINTS);
if (field > 0)
Vect_set_constraint_field(&Map, field);
/* read points */
npoints = 0;
G_message(_("Reading points..."));
while(TRUE) {
double dval;
if (Vect_read_next_line(&Map, Points, Cats) < 0)
break;
G_progress(npoints, 1e3);
if (Points->n_points != 1) {
G_warning(_("Invalid point skipped"));
continue;
}
if (!with_z) {
int cat, ival, ret;
/* TODO: what to do with multiple cats */
Vect_cat_get(Cats, field, &cat);
if (cat < 0) /* skip features without category */
continue;
if (col) {
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &ival);
dval = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
}
if (ret != DB_OK) {
G_warning(_("No record for point (cat = %d)"), cat);
continue;
}
}
else {
dval = cat;
}
}
else
dval = Points->z[0];
x = Points->x[0];
y = Points->y[0];
p = Point(x,y);
OutPoints.push_back(p);
function_values.insert(std::make_pair(p, dval));
G_debug(3, "new point added: %f, %f, %f", x, y, dval);
npoints++;
}
G_progress(1, 1);
if (col)
db_CatValArray_free(&cvarr);
Vect_set_release_support(&Map);
Vect_close(&Map);
Vect_destroy_line_struct(Points);
G_debug(1, "read_points(): %d", npoints);
G_message("%d point loaded", npoints);
return npoints;
}
int export_areas_multi(struct Map_info *In, int field, int donocat,
OGRFeatureDefnH Ogr_featuredefn,OGRLayerH Ogr_layer,
struct field_info *Fi, dbDriver *driver, int ncol, int *colctype,
const char **colname, int doatt, int nocat,
int *n_noatt, int *n_nocat)
{
int i, n_exported, area;
int cat, ncats_field, line, type, findex, ipart;
struct line_pnts *Points;
struct line_cats *Cats;
struct ilist *cat_list, *line_list, *lcats;
OGRGeometryH Ogr_geometry, Ogr_geometry_part;
OGRFeatureH Ogr_feature;
OGRwkbGeometryType wkbtype, wkbtype_part;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
cat_list = Vect_new_list();
line_list = Vect_new_list();
lcats = Vect_new_list();
n_exported = 0;
/* check if category index is available for given field */
findex = Vect_cidx_get_field_index(In, field);
if (findex == -1)
G_fatal_error(_("Unable to export multi-features. No category index for layer %d."),
field);
/* determine type */
wkbtype_part = wkbPolygon;
wkbtype = get_multi_wkbtype(wkbtype_part);
ncats_field = Vect_cidx_get_unique_cats_by_index(In, findex, cat_list);
G_debug(1, "n_cats = %d for layer %d", ncats_field, field);
if (donocat)
G_message(_("Exporting features with category..."));
for (i = 0; i < cat_list->n_values; i++) {
G_percent(i, cat_list->n_values - 1, 5);
cat = cat_list->value[i];
/* find all centroids with given category */
Vect_cidx_find_all(In, field, GV_CENTROID, cat, line_list);
/* create multi-feature */
Ogr_geometry = OGR_G_CreateGeometry(wkbtype);
/* build simple features geometry, go through all parts */
for (ipart = 0; ipart < line_list->n_values; ipart++) {
line = line_list->value[ipart];
G_debug(3, "cat=%d, line=%d -> part=%d", cat, line, ipart);
/* get centroid's category */
Vect_read_line(In, NULL, Cats, line);
/* check for category consistency */
Vect_field_cat_get(Cats, field, lcats);
if (!Vect_val_in_list(lcats, cat))
G_fatal_error(_("Unable to create multi-feature. "
"Category %d not found in line %d, field %d"),
cat, line, field);
/* find correspoding area */
area = Vect_get_centroid_area(In, line);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry_part = create_polygon(In, area, Points);
/* add part */
OGR_G_AddGeometryDirectly(Ogr_geometry, Ogr_geometry_part);
}
if (!OGR_G_IsEmpty(Ogr_geometry)) {
/* write multi-feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
OGR_F_Destroy(Ogr_feature);
n_exported++;
}
else {
/* skip empty features */
G_debug(3, "multi-feature is empty -> skipped");
}
OGR_G_DestroyGeometry(Ogr_geometry);
}
if (donocat)
G_message(_("Exporting features without category..."));
/* check lines without category, if -c flag is given write them as
* one multi-feature */
Ogr_geometry = OGR_G_CreateGeometry(wkbtype);
Vect_rewind(In);
Vect_set_constraint_type(In, GV_CENTROID);
while(TRUE) {
type = Vect_read_next_line(In, NULL, Cats);
if (type < 0)
break;
/* get centroid's category */
Vect_cat_get(Cats, field, &cat);
if (cat > 0)
continue; /* skip features with category */
if (cat < 0 && !donocat) {
(*n_nocat)++;
continue; /* skip lines without category, do not export
* not labeled */
}
/* find correspoding area */
line = Vect_get_next_line_id(In);
area = Vect_get_centroid_area(In, line);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry_part = create_polygon(In, area, Points);
/* add part */
OGR_G_AddGeometryDirectly(Ogr_geometry, Ogr_geometry_part);
(*n_nocat)++;
}
if (!OGR_G_IsEmpty(Ogr_geometry)) {
/* write multi-feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
OGR_F_Destroy(Ogr_feature);
n_exported++;
}
else {
/* skip empty features */
G_debug(3, "multi-feature is empty -> skipped");
}
OGR_G_DestroyGeometry(Ogr_geometry);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
Vect_destroy_list(cat_list);
Vect_destroy_list(line_list);
Vect_destroy_list(lcats);
return n_exported;
}
void scan_z(struct Map_info *Map, int field,
const char *style, const char *rules,
const struct FPRange *range, struct Colors *colors)
{
int ltype, line, cat, i;
int items_alloc;
double zmin, zmax;
struct line_pnts *Points;
struct line_cats *Cats;
struct Colors vcolors;
dbCatValArray cvarr;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
items_alloc = 0;
db_CatValArray_init(&cvarr);
cvarr.ctype = DB_C_TYPE_DOUBLE;
Vect_set_constraint_field(Map, field);
Vect_set_constraint_type(Map, GV_POINTS); /* points, centroids or kernels only) */
G_message(_("Reading features..."));
line = i = 0;
while(TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
if (ltype == -2)
break; /* EOF */
G_progress(++line, 1e4);
if (Vect_cat_get(Cats, field, &cat) == -1)
continue; /* skip features without category */
/* add item into cat-value array */
if (i >= items_alloc) {
items_alloc += 1000;
db_CatValArray_realloc(&cvarr, items_alloc);
}
cvarr.n_values++;
cvarr.value[i].cat = cat;
cvarr.value[i++].val.d = Points->z[0];
if (line == 1 || Points->z[0] < zmin)
zmin = Points->z[0];
if (line == 1 || Points->z[0] > zmax)
zmax = Points->z[0];
}
G_progress(1, 1);
/* sort array by z-coordinate */
db_CatValArray_sort_by_value(&cvarr);
if (range) {
if (range->min >= zmin && range->min <= zmax)
zmin = range->min;
else
G_warning(_("Min value (%f) is out of range %f,%f"),
range->min, zmin, zmax);
if (range->max <= zmax && range->max >= zmin)
zmax = range->max;
else
G_warning(_("Max value (%f) is out of range %f,%f"),
range->max, zmin, zmax);
}
if (style)
make_colors(&vcolors, style, (DCELL) zmin, (DCELL) zmax, TRUE);
else if (rules) {
load_colors(&vcolors, rules, (DCELL) zmin, (DCELL) zmax, TRUE);
}
/* color table for categories */
color_rules_to_cats(&cvarr, TRUE, &vcolors, colors);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
db_CatValArray_free(&cvarr);
}
