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