예제 #1
0
/* 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 (&region);
	
	
	/* 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,
				  &region);
				
		col_idx =
			(long) G_easting_to_col (x,
				 &region);
		/* 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);
		}
}
예제 #2
0
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;
}
예제 #3
0
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;
}
예제 #4
0
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);

}