void print_shell(const struct Map_info *Map)
{
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
fprintf(stdout, "ogr_layer=%s\n",
Vect_get_ogr_layer_name(Map));
fprintf(stdout, "ogr_dsn=%s\n",
Vect_get_ogr_dsn_name(Map));
}
else {
fprintf(stdout, "name=%s\n",
Vect_get_name(Map));
fprintf(stdout, "mapset=%s\n",
Vect_get_mapset(Map));
}
fprintf(stdout, "location=%s\n",
G_location());
fprintf(stdout, "database=%s\n",
G_gisdbase());
fprintf(stdout, "title=%s\n",
Vect_get_map_name(Map));
fprintf(stdout, "scale=1:%d\n",
Vect_get_scale(Map));
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_ogr_format_info(Map));
}
else {
fprintf(stdout, "format=%s\n",
Vect_maptype_info(Map));
}
fprintf(stdout, "creator=%s\n",
Vect_get_person(Map));
fprintf(stdout, "organization=%s\n",
Vect_get_organization(Map));
fprintf(stdout, "source_date=%s\n",
Vect_get_map_date(Map));
fprintf(stdout, "level=%d\n",
Vect_level(Map));
if (Vect_level(Map) > 0) {
fprintf(stdout, "num_dblinks=%d\n",
Vect_get_num_dblinks(Map));
}
fprintf(stdout, "projection=%s\n",
Vect_get_proj_name(Map));
if (G_projection() == PROJECTION_UTM) {
fprintf(stdout, "zone=%d\n",
Vect_get_zone(Map));
}
fprintf(stdout, "digitization_threshold=%f\n",
Vect_get_thresh(Map));
fprintf(stdout, "comment=%s\n",
Vect_get_comment(Map));
}
int display_label(struct Map_info *Map, int type,
struct cat_list *Clist, LATTR *lattr, int chcat)
{
int ltype;
struct line_pnts *Points;
struct line_cats *Cats;
int ogr_centroids;
const struct Format_info *finfo;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_rewind(Map);
ogr_centroids = FALSE;
finfo = Vect_get_finfo(Map);
if (Vect_maptype(Map) == GV_FORMAT_OGR ||
(Vect_maptype(Map) == GV_FORMAT_POSTGIS &&
finfo->pg.toposchema_name == NULL)) {
if (Vect_level(Map) < 2)
G_warning(_("Topology level required for drawing centroids "
"for OGR layers"));
else if (Vect_get_num_primitives(Map, GV_CENTROID) > 0 &&
type & GV_CENTROID)
/* label centroids from topo, don't label boundaries */
ogr_centroids = TRUE;
}
while (TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
else if (ltype == -2) /* EOF */
break;
if (!(type & ltype) && !((type & GV_AREA) && (ltype & GV_CENTROID)))
continue; /* used for both lines and labels */
if (ogr_centroids && ltype == GV_BOUNDARY)
/* do not label boundaries */
continue;
process_line(ltype, Points, Cats, lattr, chcat, Clist);
}
if (ogr_centroids) {
/* show label for centroids stored in topo (for OGR layers
only) */
int line, nlines;
struct bound_box box;
struct boxlist *list;
list = Vect_new_boxlist(FALSE); /* bboxes not needed */
Vect_get_constraint_box(Map, &box);
nlines = Vect_select_lines_by_box(Map, &box, GV_CENTROID, list);
G_debug(3, "ncentroids (ogr) = %d", nlines);
for (line = 0; line < nlines; line++) {
ltype = Vect_read_line(Map, Points, Cats, list->id[line]);
process_line(ltype, Points, Cats, lattr, chcat, Clist);
}
Vect_destroy_boxlist(list);
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
/* *************************************************************** */
int plot1(struct Map_info *Map, int type, int area, struct cat_list *Clist,
const struct color_rgb *color, const struct color_rgb *fcolor,
int chcat, SYMBOL * Symb, int size, int id_flag,
int table_colors_flag, int cats_color_flag, char *rgb_column,
int default_width, char *width_column, double width_scale)
{
int i, ltype, nlines = 0, line, cat = -1;
double *x, *y;
struct line_pnts *Points, *PPoints;
struct line_cats *Cats;
double msize;
int x0, y0;
struct field_info *fi = NULL;
dbDriver *driver = NULL;
dbCatValArray cvarr_rgb, cvarr_width;
dbCatVal *cv_rgb = NULL, *cv_width = NULL;
int nrec_rgb = 0, nrec_width = 0;
int open_db;
int custom_rgb = FALSE;
char colorstring[12]; /* RRR:GGG:BBB */
int red, grn, blu;
RGBA_Color *line_color, *fill_color, *primary_color;
unsigned char which;
int width;
line_color = G_malloc(sizeof(RGBA_Color));
fill_color = G_malloc(sizeof(RGBA_Color));
primary_color = G_malloc(sizeof(RGBA_Color));
primary_color->a = RGBA_COLOR_OPAQUE;
/* change function prototype to pass RGBA_Color instead of color_rgb? */
if (color) {
line_color->r = color->r;
line_color->g = color->g;
line_color->b = color->b;
line_color->a = RGBA_COLOR_OPAQUE;
}
else
line_color->a = RGBA_COLOR_NONE;
if (fcolor) {
fill_color->r = fcolor->r;
fill_color->g = fcolor->g;
fill_color->b = fcolor->b;
fill_color->a = RGBA_COLOR_OPAQUE;
}
else
fill_color->a = RGBA_COLOR_NONE;
msize = size * (D_d_to_u_col(2.0) - D_d_to_u_col(1.0)); /* do it better */
Points = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
open_db = table_colors_flag || width_column;
if (open_db) {
fi = Vect_get_field(Map, (Clist->field > 0 ? Clist->field : 1));
if (fi == NULL) {
G_fatal_error(_("Database connection not defined for layer %d"),
(Clist->field > 0 ? Clist->field : 1));
}
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);
}
if (table_colors_flag) {
/* for reading RRR:GGG:BBB color strings from table */
if (rgb_column == NULL || *rgb_column == '\0')
G_fatal_error(_("Color definition column not specified"));
db_CatValArray_init(&cvarr_rgb);
nrec_rgb = db_select_CatValArray(driver, fi->table, fi->key,
rgb_column, NULL, &cvarr_rgb);
G_debug(3, "nrec_rgb (%s) = %d", rgb_column, nrec_rgb);
if (cvarr_rgb.ctype != DB_C_TYPE_STRING)
G_fatal_error(_("Color definition column (%s) not a string. "
"Column must be of form RRR:GGG:BBB where RGB values range 0-255."),
rgb_column);
if (nrec_rgb < 0)
G_fatal_error(_("Cannot select data (%s) from table"),
rgb_column);
G_debug(2, "\n%d records selected from table", nrec_rgb);
for (i = 0; i < cvarr_rgb.n_values; i++) {
G_debug(4, "cat = %d %s = %s", cvarr_rgb.value[i].cat,
rgb_column, db_get_string(cvarr_rgb.value[i].val.s));
}
}
if (width_column) {
if (*width_column == '\0')
G_fatal_error(_("Line width column not specified."));
db_CatValArray_init(&cvarr_width);
nrec_width = db_select_CatValArray(driver, fi->table, fi->key,
width_column, NULL, &cvarr_width);
G_debug(3, "nrec_width (%s) = %d", width_column, nrec_width);
if (cvarr_width.ctype != DB_C_TYPE_INT &&
cvarr_width.ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Line width column (%s) not a number."),
width_column);
if (nrec_width < 0)
G_fatal_error(_("Cannot select data (%s) from table"),
width_column);
G_debug(2, "\n%d records selected from table", nrec_width);
for (i = 0; i < cvarr_width.n_values; i++) {
G_debug(4, "cat = %d %s = %d", cvarr_width.value[i].cat,
width_column,
(cvarr_width.ctype ==
DB_C_TYPE_INT ? cvarr_width.value[i].val.
i : (int)cvarr_width.value[i].val.d));
}
}
if (open_db)
db_close_database_shutdown_driver(driver);
Vect_rewind(Map);
/* Is it necessary to reset line/label color in each loop ? */
if (color && !table_colors_flag && !cats_color_flag)
D_RGB_color(color->r, color->g, color->b);
if (Vect_level(Map) >= 2)
nlines = Vect_get_num_lines(Map);
line = 0;
while (1) {
if (Vect_level(Map) >= 2) {
line++;
if (line > nlines)
return 0;
if (!Vect_line_alive(Map, line))
continue;
ltype = Vect_read_line(Map, Points, Cats, line);
}
else {
ltype = Vect_read_next_line(Map, Points, Cats);
switch (ltype) {
case -1:
fprintf(stderr, _("\nERROR: vector map - can't read\n"));
return -1;
case -2: /* EOF */
return 0;
}
}
if (!(type & ltype))
continue;
if (chcat) {
int found = 0;
if (id_flag) { /* use line id */
if (!(Vect_cat_in_cat_list(line, Clist)))
continue;
}
else {
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = 1;
break;
}
}
if (!found)
continue;
}
}
else if (Clist->field > 0) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field) {
found = 1;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
if (table_colors_flag) {
/* only first category */
cat = Vect_get_line_cat(Map, line,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats >
0 ? Cats->field[0] : 1)));
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* Read RGB colors from db for current area # */
if (db_CatValArray_get_value(&cvarr_rgb, cat, &cv_rgb) !=
DB_OK) {
custom_rgb = FALSE;
}
else {
sprintf(colorstring, "%s", db_get_string(cv_rgb->val.s));
if (*colorstring != '\0') {
G_debug(3, "element %d: colorstring: %s", line,
colorstring);
if (G_str_to_color(colorstring, &red, &grn, &blu) ==
1) {
custom_rgb = TRUE;
G_debug(3, "element:%d cat %d r:%d g:%d b:%d",
line, cat, red, grn, blu);
}
else {
custom_rgb = FALSE;
G_warning(_("Error in color definition column (%s), element %d "
"with cat %d: colorstring [%s]"),
rgb_column, line, cat, colorstring);
}
}
else {
custom_rgb = FALSE;
G_warning(_("Error in color definition column (%s), element %d with cat %d"),
rgb_column, line, cat);
}
}
} /* end if cat */
else {
custom_rgb = FALSE;
}
} /* end if table_colors_flag */
/* random colors */
if (cats_color_flag) {
custom_rgb = FALSE;
if (Clist->field > 0) {
cat = Vect_get_line_cat(Map, line, Clist->field);
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* fetch color number from category */
which = (cat % palette_ncolors);
G_debug(3, "cat:%d which color:%d r:%d g:%d b:%d", cat,
which, palette[which].R, palette[which].G,
palette[which].B);
custom_rgb = TRUE;
red = palette[which].R;
grn = palette[which].G;
blu = palette[which].B;
}
}
else if (Cats->n_cats > 0) {
/* fetch color number from layer */
which = (Cats->field[0] % palette_ncolors);
G_debug(3, "layer:%d which color:%d r:%d g:%d b:%d",
Cats->field[0], which, palette[which].R,
palette[which].G, palette[which].B);
custom_rgb = TRUE;
red = palette[which].R;
grn = palette[which].G;
blu = palette[which].B;
}
}
if (nrec_width) {
/* only first category */
cat = Vect_get_line_cat(Map, line,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats >
0 ? Cats->field[0] : 1)));
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* Read line width from db for current area # */
if (db_CatValArray_get_value(&cvarr_width, cat, &cv_width) !=
DB_OK) {
width = default_width;
}
else {
width =
width_scale * (cvarr_width.ctype ==
DB_C_TYPE_INT ? cv_width->val.
i : (int)cv_width->val.d);
if (width < 0) {
G_warning(_("Error in line width column (%s), element %d "
"with cat %d: line width [%d]"),
width_column, line, cat, width);
width = default_width;
}
}
} /* end if cat */
else {
width = default_width;
}
D_line_width(width);
} /* end if nrec_width */
/* enough of the prep work, lets start plotting stuff */
x = Points->x;
y = Points->y;
if ((ltype & GV_POINTS) && Symb != NULL) {
if (!(color || fcolor || custom_rgb))
continue;
x0 = D_u_to_d_col(x[0]);
y0 = D_u_to_d_row(y[0]);
/* skip if the point is outside of the display window */
/* xy<0 tests make it go ever-so-slightly faster */
if (x0 < 0 || y0 < 0 ||
x0 > D_get_d_east() || x0 < D_get_d_west() ||
y0 > D_get_d_south() || y0 < D_get_d_north())
continue;
/* use random or RGB column color if given, otherwise reset */
/* centroids always use default color to stand out from underlying area */
if (custom_rgb && (ltype != GV_CENTROID)) {
primary_color->r = (unsigned char)red;
primary_color->g = (unsigned char)grn;
primary_color->b = (unsigned char)blu;
D_symbol2(Symb, x0, y0, primary_color, line_color);
}
else
D_symbol(Symb, x0, y0, line_color, fill_color);
}
else if (color || custom_rgb) {
if (!table_colors_flag && !cats_color_flag)
D_RGB_color(color->r, color->g, color->b);
else {
if (custom_rgb)
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
else
D_RGB_color(color->r, color->g, color->b);
}
/* Plot the lines */
if (Points->n_points == 1) /* line with one coor */
D_polydots_abs(x, y, Points->n_points);
else /*use different user defined render methods */
D_polyline_abs(x, y, Points->n_points);
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0; /* not reached */
}
void print_info(const struct Map_info *Map)
{
int i;
char line[100];
char tmp1[100], tmp2[100];
struct bound_box box;
divider('+');
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
/* for OGR format print also datasource and layer */
sprintf(line, "%-17s%s", _("OGR layer:"),
Vect_get_ogr_layer_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("OGR datasource:"),
Vect_get_ogr_dsn_name(Map));
printline(line);
}
else {
sprintf(line, "%-17s%s", _("Name:"),
Vect_get_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Mapset:"),
Vect_get_mapset(Map));
printline(line);
}
sprintf(line, "%-17s%s", _("Location:"),
G_location());
printline(line);
sprintf(line, "%-17s%s", _("Database:"),
G_gisdbase());
printline(line);
sprintf(line, "%-17s%s", _("Title:"),
Vect_get_map_name(Map));
printline(line);
sprintf(line, "%-17s1:%d", _("Map scale:"),
Vect_get_scale(Map));
printline(line);
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
sprintf(line, "%-17s%s (%s)", _("Map format:"),
Vect_maptype_info(Map), Vect_get_ogr_format_info(Map));
}
else {
sprintf(line, "%-17s%s", _("Map format:"),
Vect_maptype_info(Map));
}
printline(line);
sprintf(line, "%-17s%s", _("Name of creator:"),
Vect_get_person(Map));
printline(line);
sprintf(line, "%-17s%s", _("Organization:"),
Vect_get_organization(Map));
printline(line);
sprintf(line, "%-17s%s", _("Source date:"),
Vect_get_map_date(Map));
printline(line);
divider('|');
sprintf(line, " %s: %s (%s: %i)",
_("Type of map"), _("vector"), _("level"), Vect_level(Map));
printline(line);
if (Vect_level(Map) > 0) {
printline("");
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of points:"),
Vect_get_num_primitives(Map, GV_POINT),
_("Number of centroids:"),
Vect_get_num_primitives(Map, GV_CENTROID));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of lines:"),
Vect_get_num_primitives(Map, GV_LINE),
_("Number of boundaries:"),
Vect_get_num_primitives(Map, GV_BOUNDARY));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of areas:"),
Vect_get_num_areas(Map),
_("Number of islands:"),
Vect_get_num_islands(Map));
printline(line);
if (Vect_is_3d(Map)) {
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of faces:"),
Vect_get_num_primitives(Map, GV_FACE),
_("Number of kernels:"),
Vect_get_num_primitives(Map, GV_KERNEL));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of volumes:"),
Vect_get_num_volumes(Map),
_("Number of holes:"),
Vect_get_num_holes(Map));
printline(line);
}
printline("");
sprintf(line, " %-24s%s",
_("Map is 3D:"),
Vect_is_3d(Map) ? _("Yes") : _("No"));
printline(line);
sprintf(line, " %-24s%-9d",
_("Number of dblinks:"),
Vect_get_num_dblinks(Map));
printline(line);
}
printline("");
/* this differs from r.info in that proj info IS taken from the map here, not the location settings */
/* Vect_get_proj_name() and _zone() are typically unset?! */
if (G_projection() == PROJECTION_UTM)
sprintf(line, " %s: %s (%s %d)",
_("Projection:"),
Vect_get_proj_name(Map),
_("zone"), Vect_get_zone(Map));
else
sprintf(line, " %s: %s",
_("Projection"),
Vect_get_proj_name(Map));
printline(line);
printline("");
Vect_get_map_box(Map, &box);
G_format_northing(box.N, tmp1, G_projection());
G_format_northing(box.S, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'N', tmp1, 'S', tmp2);
printline(line);
G_format_easting(box.E, tmp1, G_projection());
G_format_easting(box.W, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'E', tmp1, 'W', tmp2);
printline(line);
if (Vect_is_3d(Map)) {
format_double(box.B, tmp1);
format_double(box.T, tmp2);
sprintf(line, " %c: %17s %c: %17s",
'B', tmp1, 'T', tmp2);
printline(line);
}
printline("");
format_double(Vect_get_thresh(Map), tmp1);
sprintf(line, " %s: %s", _("Digitization threshold"), tmp1);
printline(line);
sprintf(line, " %s:", _("Comment"));
printline(line);
sprintf(line, " %s", Vect_get_comment(Map));
printline(line);
divider('+');
fprintf(stdout, "\n");
}
void print_info(const struct Map_info *Map)
{
int i, map_type;
char line[1024];
char timebuff[256];
struct TimeStamp ts;
int time_ok, first_time_ok, second_time_ok;
struct bound_box box;
char tmp1[1024], tmp2[1024];
time_ok = first_time_ok = second_time_ok = FALSE;
map_type = Vect_maptype(Map);
/* Check the Timestamp */
time_ok = G_read_vector_timestamp(Vect_get_name(Map), NULL, "", &ts);
/* Check for valid entries, show none if no timestamp available */
if (time_ok == TRUE) {
if (ts.count > 0)
first_time_ok = TRUE;
if (ts.count > 1)
second_time_ok = TRUE;
}
divider('+');
sprintf(line, "%-17s%s", _("Name:"),
Vect_get_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Mapset:"),
Vect_get_mapset(Map));
printline(line);
sprintf(line, "%-17s%s", _("Location:"),
G_location());
printline(line);
sprintf(line, "%-17s%s", _("Database:"),
G_gisdbase());
printline(line);
sprintf(line, "%-17s%s", _("Title:"),
Vect_get_map_name(Map));
printline(line);
sprintf(line, "%-17s1:%d", _("Map scale:"),
Vect_get_scale(Map));
printline(line);
sprintf(line, "%-17s%s", _("Name of creator:"),
Vect_get_person(Map));
printline(line);
sprintf(line, "%-17s%s", _("Organization:"),
Vect_get_organization(Map));
printline(line);
sprintf(line, "%-17s%s", _("Source date:"),
Vect_get_map_date(Map));
printline(line);
/* This shows the TimeStamp (if present) */
if (time_ok == TRUE && (first_time_ok || second_time_ok)) {
G_format_timestamp(&ts, timebuff);
sprintf(line, "%-17s%s", _("Timestamp (first layer): "), timebuff);
printline(line);
}
else {
strcpy(line, _("Timestamp (first layer): none"));
printline(line);
}
divider('|');
if (map_type == GV_FORMAT_OGR ||
map_type == GV_FORMAT_OGR_DIRECT) {
sprintf(line, "%-17s%s (%s)", _("Map format:"),
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
printline(line);
/* for OGR format print also datasource and layer */
sprintf(line, "%-17s%s", _("OGR layer:"),
Vect_get_finfo_layer_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("OGR datasource:"),
Vect_get_finfo_dsn_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Feature type:"),
Vect_get_finfo_geometry_type(Map));
printline(line);
}
else if (map_type == GV_FORMAT_POSTGIS) {
int topo_format;
char *toposchema_name, *topogeom_column;
int topo_geo_only;
const struct Format_info *finfo;
finfo = Vect_get_finfo(Map);
sprintf(line, "%-17s%s (%s)", _("Map format:"),
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
printline(line);
/* for PostGIS format print also datasource and layer */
sprintf(line, "%-17s%s", _("DB table:"),
Vect_get_finfo_layer_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("DB name:"),
Vect_get_finfo_dsn_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Geometry column:"),
finfo->pg.geom_column);
printline(line);
sprintf(line, "%-17s%s", _("Feature type:"),
Vect_get_finfo_geometry_type(Map));
printline(line);
topo_format = Vect_get_finfo_topology_info(Map,
&toposchema_name, &topogeom_column,
&topo_geo_only);
if (topo_format == GV_TOPO_POSTGIS) {
sprintf(line, "%-17s%s (%s %s%s)", _("Topology:"), "PostGIS",
_("schema:"), toposchema_name,
topo_geo_only ? ", topo-geo-only: yes" : "");
printline(line);
sprintf(line, "%-17s%s", _("Topology column:"),
topogeom_column);
}
else
sprintf(line, "%-17s%s", _("Topology:"), "pseudo (simple features)");
printline(line);
}
else {
sprintf(line, "%-17s%s", _("Map format:"),
Vect_maptype_info(Map));
printline(line);
}
divider('|');
sprintf(line, " %s: %s (%s: %i)",
_("Type of map"), _("vector"), _("level"), Vect_level(Map));
printline(line);
if (Vect_level(Map) > 0) {
printline("");
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of points:"),
Vect_get_num_primitives(Map, GV_POINT),
_("Number of centroids:"),
Vect_get_num_primitives(Map, GV_CENTROID));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of lines:"),
Vect_get_num_primitives(Map, GV_LINE),
_("Number of boundaries:"),
Vect_get_num_primitives(Map, GV_BOUNDARY));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of areas:"),
Vect_get_num_areas(Map),
_("Number of islands:"),
Vect_get_num_islands(Map));
printline(line);
if (Vect_is_3d(Map)) {
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of faces:"),
Vect_get_num_primitives(Map, GV_FACE),
_("Number of kernels:"),
Vect_get_num_primitives(Map, GV_KERNEL));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of volumes:"),
Vect_get_num_volumes(Map),
_("Number of holes:"),
Vect_get_num_holes(Map));
printline(line);
}
printline("");
sprintf(line, " %-24s%s",
_("Map is 3D:"),
Vect_is_3d(Map) ? _("Yes") : _("No"));
printline(line);
sprintf(line, " %-24s%-9d",
_("Number of dblinks:"),
Vect_get_num_dblinks(Map));
printline(line);
}
printline("");
/* this differs from r.info in that proj info IS taken from the map here, not the location settings */
/* Vect_get_proj_name() and _zone() are typically unset?! */
if (G_projection() == PROJECTION_UTM) {
int utm_zone;
utm_zone = Vect_get_zone(Map);
if (utm_zone < 0 || utm_zone > 60)
strcpy(tmp1, _("invalid"));
else if (utm_zone == 0)
strcpy(tmp1, _("unspecified"));
else
sprintf(tmp1, "%d", utm_zone);
sprintf(line, " %s: %s (%s %s)",
_("Projection"), Vect_get_proj_name(Map),
_("zone"), tmp1);
}
else
sprintf(line, " %s: %s",
_("Projection"), Vect_get_proj_name(Map));
printline(line);
printline("");
Vect_get_map_box(Map, &box);
G_format_northing(box.N, tmp1, G_projection());
G_format_northing(box.S, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'N', tmp1, 'S', tmp2);
printline(line);
G_format_easting(box.E, tmp1, G_projection());
G_format_easting(box.W, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'E', tmp1, 'W', tmp2);
printline(line);
if (Vect_is_3d(Map)) {
format_double(box.B, tmp1);
format_double(box.T, tmp2);
sprintf(line, " %c: %17s %c: %17s",
'B', tmp1, 'T', tmp2);
printline(line);
}
printline("");
format_double(Vect_get_thresh(Map), tmp1);
sprintf(line, " %s: %s", _("Digitization threshold"), tmp1);
printline(line);
sprintf(line, " %s:", _("Comment"));
printline(line);
sprintf(line, " %s", Vect_get_comment(Map));
printline(line);
divider('+');
fprintf(stdout, "\n");
}
void print_shell(const struct Map_info *Map, const char *field_opt)
{
int map_type;
int time_ok, first_time_ok, second_time_ok;
char timebuff[256];
struct field_info *fi;
struct TimeStamp ts;
time_ok = first_time_ok = second_time_ok = FALSE;
/* Check the Timestamp */
time_ok = G_read_vector_timestamp(Vect_get_name(Map), NULL, "", &ts);
/* Check for valid entries, show none if no timestamp available */
if (time_ok == TRUE) {
if (ts.count > 0)
first_time_ok = TRUE;
if (ts.count > 1)
second_time_ok = TRUE;
}
map_type = Vect_maptype(Map);
fprintf(stdout, "name=%s\n",
Vect_get_name(Map));
fprintf(stdout, "mapset=%s\n",
Vect_get_mapset(Map));
fprintf(stdout, "location=%s\n",
G_location());
fprintf(stdout, "database=%s\n",
G_gisdbase());
fprintf(stdout, "title=%s\n",
Vect_get_map_name(Map));
fprintf(stdout, "scale=1:%d\n",
Vect_get_scale(Map));
fprintf(stdout, "creator=%s\n",
Vect_get_person(Map));
fprintf(stdout, "organization=%s\n",
Vect_get_organization(Map));
fprintf(stdout, "source_date=%s\n",
Vect_get_map_date(Map));
/* This shows the TimeStamp (if present) */
if (time_ok == TRUE && (first_time_ok || second_time_ok)) {
G_format_timestamp(&ts, timebuff);
fprintf(stdout, "timestamp=%s\n", timebuff);
}
else {
fprintf(stdout, "timestamp=none\n");
}
if (map_type == GV_FORMAT_OGR ||
map_type == GV_FORMAT_OGR_DIRECT) {
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
fprintf(stdout, "ogr_layer=%s\n",
Vect_get_finfo_layer_name(Map));
fprintf(stdout, "ogr_dsn=%s\n",
Vect_get_finfo_dsn_name(Map));
fprintf(stdout, "feature_type=%s\n",
Vect_get_finfo_geometry_type(Map));
}
else if (map_type == GV_FORMAT_POSTGIS) {
int topo_format;
char *toposchema_name, *topogeom_column;
const struct Format_info *finfo;
finfo = Vect_get_finfo(Map);
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
fprintf(stdout, "pg_table=%s\n",
Vect_get_finfo_layer_name(Map));
fprintf(stdout, "pg_dbname=%s\n",
Vect_get_finfo_dsn_name(Map));
fprintf(stdout, "geometry_column=%s\n",
finfo->pg.geom_column);
fprintf(stdout, "feature_type=%s\n",
Vect_get_finfo_geometry_type(Map));
topo_format = Vect_get_finfo_topology_info(Map, &toposchema_name, &topogeom_column, NULL);
if (topo_format == GV_TOPO_POSTGIS) {
fprintf(stdout, "pg_topo_schema=%s\n",
toposchema_name);
fprintf(stdout, "pg_topo_column=%s\n",
topogeom_column);
}
}
else {
fprintf(stdout, "format=%s\n",
Vect_maptype_info(Map));
}
fprintf(stdout, "level=%d\n",
Vect_level(Map));
if (Vect_level(Map) > 0) {
fprintf(stdout, "num_dblinks=%d\n",
Vect_get_num_dblinks(Map));
if (Vect_get_num_dblinks(Map) > 0) {
fi = Vect_get_field2(Map, field_opt);
if(fi != NULL) {
fprintf(stdout, "attribute_layer_number=%i\n",fi->number);
fprintf(stdout, "attribute_layer_name=%s\n",fi->name);
fprintf(stdout, "attribute_database=%s\n",fi->database);
fprintf(stdout, "attribute_database_driver=%s\n",fi->driver);
fprintf(stdout, "attribute_table=%s\n",fi->table);
fprintf(stdout, "attribute_primary_key=%s\n",fi->key);
}
}
}
fprintf(stdout, "projection=%s\n",
Vect_get_proj_name(Map));
if (G_projection() == PROJECTION_UTM) {
fprintf(stdout, "zone=%d\n",
Vect_get_zone(Map));
}
fprintf(stdout, "digitization_threshold=%f\n",
Vect_get_thresh(Map));
fprintf(stdout, "comment=%s\n",
Vect_get_comment(Map));
}
/*!
\brief Copy all alive vector features from given layer of opened
vector map to another opened vector map
\param In input vector map
\param field layer number (-1 for all layers)
\param[out] Out output vector map
\return 0 on success
\return 1 on error
*/
int Vect_copy_map_lines_field(struct Map_info *In, int field,
struct Map_info *Out)
{
int i, type, nlines, ret, left, rite, centroid;
struct line_pnts *Points, *CPoints;
struct line_cats *Cats, *CCats;
Points = Vect_new_line_struct();
CPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
CCats = Vect_new_cats_struct();
if (Vect_level(In) < 1)
G_fatal_error("Vect_copy_map_lines(): %s",
_("input vector map is not open"));
ret = 0;
/* Note: sometimes is important to copy on level 2 (pseudotopo centroids)
* and sometimes on level 1 if build take too long time */
if (Vect_level(In) >= 2) {
nlines = Vect_get_num_lines(In);
for (i = 1; i <= nlines; i++) {
if (!Vect_line_alive(In, i))
continue;
type = Vect_read_line(In, Points, Cats, i);
if (type == -1) {
G_warning(_("Unable to read vector map <%s>"),
Vect_get_full_name(In));
ret = 1;
break;
}
if (type == 0)
continue; /* dead line */
/* don't skips boundaries if field != -1 */
if (field != -1) {
if (type & GV_BOUNDARY) {
if (Vect_cat_get(Cats, field, NULL) == 0) {
int skip_bndry = 1;
Vect_get_line_areas(In, i, &left, &rite);
if (left < 0)
left = Vect_get_isle_area(In, abs(left));
if (left > 0) {
if ((centroid =
Vect_get_area_centroid(In, left)) > 0) {
Vect_read_line(In, CPoints, CCats, centroid);
if (Vect_cat_get(CCats, field, NULL) != 0)
skip_bndry = 0;
}
}
if (skip_bndry) {
if (rite < 0)
rite = Vect_get_isle_area(In, abs(rite));
if (rite > 0) {
if ((centroid =
Vect_get_area_centroid(In, rite)) > 0) {
Vect_read_line(In, CPoints, CCats,
centroid);
if (Vect_cat_get(CCats, field, NULL) != 0)
skip_bndry = 0;
}
}
}
if (skip_bndry)
continue;
}
}
else if (Vect_cat_get(Cats, field, NULL) == 0)
continue; /* different layer */
}
Vect_write_line(Out, type, Points, Cats);
}
}
else { /* Level 1 */
Vect_rewind(In);
while (1) {
type = Vect_read_next_line(In, Points, Cats);
if (type == -1) {
G_warning(_("Unable to read vector map <%s>"),
Vect_get_full_name(In));
ret = 1;
break;
}
else if (type == -2) { /* EOF */
break;
}
else if (type == 0) { /* dead line */
continue;
}
/* don't skip boundaries if field != -1 */
if (field != -1 && !(type & GV_BOUNDARY) &&
Vect_cat_get(Cats, field, NULL) == 0)
continue; /* different layer */
Vect_write_line(Out, type, Points, Cats);
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(CPoints);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(CCats);
return ret;
}
int display_topo(struct Map_info *Map, int type, LATTR *lattr, double dsize)
{
int ltype, num, el;
double msize;
struct line_pnts *Points;
struct line_cats *Cats;
char text[50];
LATTR lattr2 = *lattr;
if (Vect_level(Map) < 2) {
G_warning(_("Unable to display topology, not available."
"Please try to rebuild topology using "
"v.build or v.build.all."));
return 1;
}
msize = dsize * (D_d_to_u_col(2.0) - D_d_to_u_col(1.0)); /* do it better */
lattr2.xref = lattr->xref == LRIGHT ? LLEFT : LRIGHT;
G_debug(1, "display topo:");
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
D_RGB_color(lattr->color.R, lattr->color.G, lattr->color.B);
D_text_size(lattr->size, lattr->size);
if (lattr->font)
D_font(lattr->font);
if (lattr->enc)
D_encoding(lattr->enc);
Vect_rewind(Map);
num = Vect_get_num_lines(Map);
G_debug(1, "n_lines = %d", num);
/* Lines */
for (el = 1; el <= num; el++) {
if (!Vect_line_alive(Map, el))
continue;
ltype = Vect_read_line(Map, Points, Cats, el);
G_debug(3, "ltype = %d", ltype);
switch (ltype) {
case -1:
G_fatal_error(_("Unable to read vector map"));
case -2: /* EOF */
return 0;
}
if (!(type & ltype))
continue; /* used for both lines and labels */
sprintf(text, "%d", el);
show_label_line(Points, ltype, lattr, text);
}
num = Vect_get_num_nodes(Map);
G_debug(1, "n_nodes = %d", num);
/* Nodes */
for (el = 1; el <= num; el++) {
double X, Y;
if (!Vect_node_alive(Map, el))
continue;
Vect_get_node_coor(Map, el, &X, &Y, NULL);
G_debug(3, "node = %d", el);
sprintf(text, "n%d", el);
show_label(&X, &Y, &lattr2, text);
D_plot_icon(X, Y, G_ICON_BOX, 0, msize);
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
/*!
\brief Write data to GRASS ASCII vector format
Prints message if some features without category are skipped.
\param[out] ascii pointer to the output ASCII file
\param[out] att att file (< version 5 only)
\param Map pointer to Map_info structure
\param ver version number 4 or 5
\param format format GV_ASCII_FORMAT_POINT or GV_ASCII_FORMAT_STD
\param dp number of significant digits
\param fs field separator
\param region_flag check region
\param type feature type filter
\param field field number
\param Clist list of categories to filter features or NULL
\param where SQL select where statement to filter features or NULL
\param column_names array of columns to be included to the output or NULL
"*" as the first item in the array indicates all columns
\param header TRUE to print also header
\return number of written features
\return -1 on error
*/
int Vect_write_ascii(FILE *ascii,
FILE *att, struct Map_info *Map, int ver,
int format, int dp, char *fs, int region_flag, int type,
int field, const struct cat_list *Clist, const char* where,
const char **column_names, int header)
{
int ltype, ctype, i, cat, line, left, right, found;
double *xptr, *yptr, *zptr, x, y;
static struct line_pnts *Points;
struct line_cats *Cats, *ACats;
char *xstring, *ystring, *zstring;
size_t xsize, ysize, zsize;
struct Cell_head window;
struct ilist *fcats;
int count, n_skipped;
/* where || columns */
struct field_info *Fi;
dbDriver *driver;
dbValue value;
dbHandle handle;
int *cats, ncats, more;
dbTable *Table;
dbString dbstring;
dbColumn *Column;
dbValue *Value;
char *buf;
size_t bufsize;
dbCursor cursor;
/* columns */
char **columns;
int *coltypes;
char *all_columns;
Fi = NULL;
driver = NULL;
columns = NULL;
coltypes = NULL;
all_columns = NULL;
G_zero(&value, sizeof(dbValue));
db_init_string(&dbstring);
xstring = NULL;
ystring = NULL;
zstring = NULL;
xsize = 0;
ysize = 0;
zsize = 0;
buf = NULL;
bufsize = 0;
/* get the region */
G_get_window(&window);
count = ncats = 0;
xstring = ystring = zstring = NULL;
cats = NULL;
if (field > 0 && (where || column_names)) {
Fi = Vect_get_field(Map, field);
if (!Fi) {
G_fatal_error(_("Database connection not defined for layer %d"),
field);
}
driver = db_start_driver(Fi->driver);
if (!driver)
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
db_init_handle(&handle);
db_set_handle(&handle, Fi->database, NULL);
if (db_open_database(driver, &handle) != DB_OK)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* select cats (sorted array) */
ncats = db_select_int(driver, Fi->table, Fi->key, where, &cats);
G_debug(3, "%d categories selected from table <%s>", ncats, Fi->table);
if (!column_names) {
db_close_database(driver);
db_shutdown_driver(driver);
}
else {
int icol, ncols;
const char *col_name;
int len_all = 0;
db_set_string(&dbstring, Fi->table);
if (db_describe_table(driver, &dbstring, &Table) != DB_OK) {
G_warning(_("Unable to describe table <%s>"), Fi->table);
return -1;
}
ncols = db_get_table_number_of_columns(Table);
columns = (char **) G_malloc((ncols + 1) * sizeof(char *));
if (column_names[0] && strcmp(column_names[0], "*") == 0) {
/* all columns */
icol = 0;
for (i = 0; i < ncols; i++) {
col_name = db_get_column_name(db_get_table_column(Table, i));
/* key column skipped */
if (strcmp(Fi->key, col_name) != 0)
columns[icol++] = G_store(col_name);
}
columns[icol] = NULL;
}
else {
int j;
icol = 0;
i = 0;
while (column_names[i]) {
/* key column skipped */
if (strcmp(Fi->key, column_names[i]) != 0) {
found = 0;
for (j = 0; j < ncols; j++) {
col_name = db_get_column_name(db_get_table_column(Table, j));
if (strcmp(col_name, column_names[i]) == 0) {
columns[icol++] = G_store(col_name);
found = 1;
break;
}
}
if (!found) {
G_warning(_("Column <%s> does not exist"),
column_names[i]);
G_important_message(_("Available columns:"));
for (j = 0; j < ncols; j++) {
col_name = db_get_column_name(db_get_table_column(Table, j));
G_important_message("%s", col_name);
}
G_warning(_("Export cancelled"));
db_close_database(driver);
db_shutdown_driver(driver);
return -1;
}
}
i++;
}
columns[icol] = NULL;
}
db_zero_string(&dbstring);
db_free_table(Table);
Table = NULL;
if (columns[0]) {
/* selected columns only */
i = 0;
while (columns[i])
len_all += strlen(columns[i++]);
coltypes = G_malloc(i * sizeof(int));
all_columns = G_malloc(len_all + i + 2);
i = 0;
strcpy(all_columns, columns[0]);
while (columns[i]) {
/* get column types */
coltypes[i] = db_column_Ctype(driver, Fi->table, columns[i]);
if (coltypes[i] < 0) {
db_close_database(driver);
db_shutdown_driver(driver);
G_warning(_("Unknown type of column <%s>, export cancelled"),
columns[i]);
return -1;
}
if (i > 0) {
strcat(all_columns, ",");
strcat(all_columns, columns[i]);
}
i++;
}
}
else {
/* no column or only key column selected */
G_free(columns);
columns = NULL;
db_close_database(driver);
db_shutdown_driver(driver);
}
}
}
if (format == GV_ASCII_FORMAT_POINT && header) {
/* print header */
if (Map->head.with_z)
fprintf(ascii, "east%snorth%sheight%scat", fs, fs, fs);
else
fprintf(ascii, "east%snorth%scat", fs, fs);
if (columns) {
for (i = 0; columns[i]; i++) {
if (db_select_value
(driver, Fi->table, Fi->key, cat,
columns[i], &value) < 0)
G_fatal_error(_("Unable to select record from table <%s> (key %s, column %s)"),
Fi->table, Fi->key, columns[i]);
if (columns[i])
fprintf(ascii, "%s%s", fs, columns[i]);
else
fprintf(ascii, "%s", columns[i]); /* can not happen */
}
}
fprintf(ascii, "%s", HOST_NEWLINE);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ACats = Vect_new_cats_struct();
fcats = Vect_new_list();
/* by default, read_next_line will NOT read Dead lines */
/* but we can override that (in Level I only) by specifying */
/* the type -1, which means match all line types */
Vect_rewind(Map);
count = n_skipped = line = 0;
while (TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1 ) { /* failure */
if (columns) {
db_close_database(driver);
db_shutdown_driver(driver);
free_col_arrays(coltypes, all_columns,
column_names && strcmp(column_names[0], "*") == 0 ? columns : NULL);
}
return -1;
}
if (ltype == -2) { /* EOF */
if (columns) {
db_close_database(driver);
db_shutdown_driver(driver);
free_col_arrays(coltypes, all_columns,
column_names && strcmp(column_names[0], "*") == 0 ? columns : NULL);
}
break;
}
line++;
if (!(ltype & type))
continue;
if (format == GV_ASCII_FORMAT_POINT && !(ltype & GV_POINTS))
continue;
found = get_cat(Cats, Clist, cats, ncats, field, &cat);
if (!found && field > 0 && ltype == GV_BOUNDARY &&
type & GV_AREA && Vect_level(Map) > 1) {
Vect_get_line_areas(Map, line, &left, &right);
if (left < 0)
left = Vect_get_isle_area(Map, abs(left));
if (left > 0) {
Vect_get_area_cats(Map, left, ACats);
found = get_cat(ACats, Clist, cats, ncats, field, &cat);
}
if (right < 0)
right = Vect_get_isle_area(Map, abs(right));
if (!found && right > 0) {
Vect_get_area_cats(Map, right, ACats);
found = get_cat(ACats, Clist, cats, ncats, field, &cat);
}
}
if (!found) {
if (Cats->n_cats < 1)
n_skipped++;
continue;
}
if (ver < 5) {
Vect_cat_get(Cats, 1, &cat);
}
switch (ltype) {
case GV_BOUNDARY:
if (ver == 5)
ctype = 'B';
else
ctype = 'A';
break;
case GV_CENTROID:
if (ver < 5) {
if (att != NULL) {
if (cat > 0) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
fprintf(att, "A %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
}
continue;
}
ctype = 'C';
break;
case GV_LINE:
ctype = 'L';
break;
case GV_POINT:
ctype = 'P';
break;
case GV_FACE:
ctype = 'F';
break;
case GV_KERNEL:
ctype = 'K';
break;
default:
ctype = 'X';
G_warning(_("Unknown feature type %d"), (int)ltype);
break;
}
if (format == GV_ASCII_FORMAT_POINT) {
if (region_flag) {
if ((window.east < Points->x[0]) ||
(window.west > Points->x[0]))
continue;
}
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
if (region_flag) {
if ((window.north < Points->y[0]) ||
(window.south > Points->y[0]))
continue;
}
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
Vect_field_cat_get(Cats, field, fcats);
if (Map->head.with_z && ver == 5) {
if (region_flag) {
if ((window.top < Points->z[0]) ||
(window.bottom > Points->z[0]))
continue;
}
G_rasprintf(&zstring, &zsize, "%.*f", dp, Points->z[0]);
G_trim_decimal(zstring);
fprintf(ascii, "%s%s%s%s%s", xstring, fs, ystring, fs,
zstring);
}
else {
fprintf(ascii, "%s%s%s", xstring, fs, ystring);
}
if (fcats->n_values > 0 && cat > -1) {
if (fcats->n_values > 1) {
G_warning(_("Feature has more categories. Only one category (%d) "
"is exported."), cat);
}
fprintf(ascii, "%s%d", fs, cat);
/* print attributes */
if (columns) {
G_rasprintf(&buf, &bufsize, "SELECT %s FROM %s WHERE %s = %d",
all_columns, Fi->table, Fi->key, cat);
G_debug(2, "SQL: %s", buf);
db_set_string(&dbstring, buf);
if (db_open_select_cursor
(driver, &dbstring, &cursor, DB_SEQUENTIAL) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Cannot select attributes for cat = %d"),
cat);
}
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to fetch data from table"));
}
Table = db_get_cursor_table(&cursor);
for (i = 0; columns[i]; i++) {
Column = db_get_table_column(Table, i);
Value = db_get_column_value(Column);
if (db_test_value_isnull(Value)) {
fprintf(ascii, "%s", fs);
}
else {
switch(coltypes[i])
{
case DB_C_TYPE_INT: {
fprintf(ascii, "%s%d", fs, db_get_value_int(Value));
break;
}
case DB_C_TYPE_DOUBLE: {
fprintf(ascii, "%s%.*f", fs, dp, db_get_value_double(Value));
break;
}
case DB_C_TYPE_STRING: {
fprintf(ascii, "%s%s", fs, db_get_value_string(Value));
break;
}
case DB_C_TYPE_DATETIME: {
break;
}
case -1:
G_fatal_error(_("Column <%s> not found in table <%s>"),
columns[i], Fi->table);
default: G_fatal_error(_("Column <%s>: unsupported data type"),
columns[i]);
}
}
}
db_close_cursor(&cursor);
}
}
fprintf(ascii, "%s", HOST_NEWLINE);
}
else if (format == GV_ASCII_FORMAT_STD) {
/* FORMAT_STANDARD */
if (ver == 5 && Cats->n_cats > 0)
fprintf(ascii, "%c %d %d%s", ctype, Points->n_points,
Cats->n_cats, HOST_NEWLINE);
else
fprintf(ascii, "%c %d%s", ctype, Points->n_points, HOST_NEWLINE);
xptr = Points->x;
yptr = Points->y;
zptr = Points->z;
while (Points->n_points--) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, *xptr++);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, *yptr++);
G_trim_decimal(ystring);
if (ver == 5) {
if (Map->head.with_z) {
G_rasprintf(&zstring, &zsize, "%.*f", dp, *zptr++);
G_trim_decimal(zstring);
fprintf(ascii, " %-12s %-12s %-12s%s", xstring,
ystring, zstring, HOST_NEWLINE);
}
else {
fprintf(ascii, " %-12s %-12s%s", xstring, ystring, HOST_NEWLINE);
}
} /*Version 4 */
else {
fprintf(ascii, " %-12s %-12s%s", ystring, xstring, HOST_NEWLINE);
}
}
if (ver == 5) {
for (i = 0; i < Cats->n_cats; i++) {
fprintf(ascii, " %-5d %-10d%s", Cats->field[i],
Cats->cat[i], HOST_NEWLINE);
}
}
else {
if (cat > -1) {
if (ltype == GV_POINT) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
fprintf(att, "P %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
else {
x = (Points->x[1] + Points->x[0]) / 2;
y = (Points->y[1] + Points->y[0]) / 2;
G_rasprintf(&xstring, &xsize, "%.*f", dp, x);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, y);
G_trim_decimal(ystring);
fprintf(att, "L %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
}
}
}
else if (format == GV_ASCII_FORMAT_WKT) {
if (ltype & (GV_BOUNDARY | GV_CENTROID | GV_FACE | GV_KERNEL))
continue;
/* Well-Known Text */
Vect_sfa_line_astext(Points, ltype, Vect_is_3d(Map), dp, ascii);
count++;
}
else {
G_fatal_error(_("Unknown format"));
}
count++;
}
if (format == GV_ASCII_FORMAT_WKT) {
/* process areas - topology required */
int i, area, nareas, isle, nisles;
if (Vect_level(Map) < 2) {
G_warning(_("Topology not available, unable to process areas"));
nareas = 0;
}
else {
nareas = Vect_get_num_areas(Map);
}
for (area = 1; area <= nareas; area++) {
if (!Vect_area_alive(Map, area)) /* skip dead areas */
continue;
if (Vect_get_area_cat(Map, area, field) < 0)
continue;
/* get boundary -> linearring */
if (Vect_get_area_points(Map, area, Points) < 0) {
G_warning(_("Unable to get boundary of area id %d"), area);
continue;
}
fprintf(ascii, "POLYGON(");
/* write outter ring */
Vect_sfa_line_astext(Points, GV_BOUNDARY, 0, dp, ascii); /* boundary is always 2D */
/* get isles (holes) -> inner rings */
nisles = Vect_get_area_num_isles(Map, area);
for (i = 0; i < nisles; i++) {
/* get isle boundary -> linearring */
isle = Vect_get_area_isle(Map, area, i);
if (Vect_get_isle_points(Map, isle, Points) < 0) {
G_warning(_("Unable to get boundary of isle id %d (area id %d)"), isle, area);
continue;
}
fprintf(ascii, ", ");
/* write inner ring */
Vect_sfa_line_astext(Points, GV_BOUNDARY, 0, dp, ascii); /* boundary is always 2D */
}
fprintf(ascii, ")%s", HOST_NEWLINE);
count++;
}
}
if (n_skipped > 0)
G_important_message(_("%d features without category skipped. To export also "
"features without category use '%s=-1'."), n_skipped, "layer");
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(ACats);
return count;
}
int display_area(struct Map_info *Map, struct cat_list *Clist, const struct Cell_head *window,
const struct color_rgb *bcolor, const struct color_rgb *fcolor, int chcat,
int id_flag, int cats_color_flag,
int default_width, double width_scale,
struct Colors *zcolors,
dbCatValArray *cvarr_rgb, struct Colors *colors,
dbCatValArray *cvarr_width, int nrec_width)
{
int num, area, isle, n_isles, n_points;
double xl, yl;
struct line_pnts *Points, * APoints, **IPoints;
struct line_cats *Cats;
int n_ipoints_alloc;
int cat, centroid;
int red, grn, blu;
int i, custom_rgb, found;
int width;
struct bound_box box;
if (Vect_level(Map) < 2) {
G_warning(_("Unable to display areas, topology not available. "
"Please try to rebuild topology using "
"v.build or v.build.all."));
return 1;
}
G_debug(1, "display areas:");
centroid = 0;
Points = Vect_new_line_struct();
APoints = Vect_new_line_struct();
n_ipoints_alloc = 10;
IPoints = (struct line_pnts **)G_malloc(n_ipoints_alloc * sizeof(struct line_pnts *));
for (i = 0; i < n_ipoints_alloc; i++) {
IPoints[i] = Vect_new_line_struct();
}
Cats = Vect_new_cats_struct();
num = Vect_get_num_areas(Map);
G_debug(2, "\tn_areas = %d", num);
for (area = 1; area <= num; area++) {
G_debug(3, "\tarea = %d", area);
if (!Vect_area_alive(Map, area))
continue;
centroid = Vect_get_area_centroid(Map, area);
if (!centroid) {
continue;
}
/* Check box */
Vect_get_area_box(Map, area, &box);
if (box.N < window->south || box.S > window->north ||
box.E < window->west || box.W > window->east) {
if (window->proj != PROJECTION_LL)
continue;
else { /* out of bounds for -180 to 180, try 0 to 360 as well */
if (box.N < window->south || box.S > window->north)
continue;
if (box.E + 360 < window->west || box.W + 360 > window->east)
continue;
}
}
custom_rgb = FALSE;
found = FALSE;
if (chcat) {
if (id_flag) {
if (!(Vect_cat_in_cat_list(area, Clist)))
continue;
}
else {
G_debug(3, "centroid = %d", centroid);
if (centroid < 1)
continue;
Vect_read_line(Map, Points, Cats, centroid);
for (i = 0; i < Cats->n_cats; i++) {
G_debug(3, " centroid = %d, field = %d, cat = %d",
centroid, Cats->field[i], Cats->cat[i]);
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = TRUE;
break;
}
}
if (!found)
continue;
}
}
else if (Clist->field > 0) {
found = FALSE;
G_debug(3, "\tcentroid = %d", centroid);
if (centroid < 1)
continue;
Vect_read_line(Map, NULL, Cats, centroid);
for (i = 0; i < Cats->n_cats; i++) {
G_debug(3, "\tcentroid = %d, field = %d, cat = %d", centroid,
Cats->field[i], Cats->cat[i]);
if (Cats->field[i] == Clist->field) {
found = TRUE;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
/* fill */
Vect_get_area_points(Map, area, APoints);
G_debug(3, "\tn_points = %d", APoints->n_points);
if (APoints->n_points < 3) {
G_warning(_("Invalid area %d skipped (not enough points)"), area);
continue;
}
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
n_points = Points->n_points;
xl = Points->x[n_points - 1];
yl = Points->y[n_points - 1];
n_isles = Vect_get_area_num_isles(Map, area);
if (n_isles >= n_ipoints_alloc) {
IPoints = (struct line_pnts **)G_realloc(IPoints, (n_isles + 10) * sizeof(struct line_pnts *));
for (i = n_ipoints_alloc; i < n_isles + 10; i++) {
IPoints[i] = Vect_new_line_struct();
}
n_ipoints_alloc = n_isles + 10;
}
for (i = 0; i < n_isles; i++) {
isle = Vect_get_area_isle(Map, area, i);
Vect_get_isle_points(Map, isle, IPoints[i]);
Vect_append_points(Points, IPoints[i], GV_FORWARD);
Vect_append_point(Points, xl, yl, 0.0); /* ??? */
}
cat = Vect_get_area_cat(Map, area,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats > 0 ? Cats->field[0] : 1)));
if (!centroid && cat == -1) {
continue;
}
/* z height colors */
if (zcolors) {
if (Rast_get_d_color(&Points->z[0], &red, &grn, &blu, zcolors) == 1)
custom_rgb = TRUE;
else
custom_rgb = FALSE;
}
/* custom colors */
if (colors || cvarr_rgb) {
custom_rgb = get_table_color(cat, area, colors, cvarr_rgb,
&red, &grn, &blu);
}
/* random colors */
if (cats_color_flag) {
custom_rgb = get_cat_color(area, Cats, Clist,
&red, &grn, &blu);
}
/* line width */
if (nrec_width) {
width = (int) get_property(cat, area, cvarr_width,
(double) width_scale,
(double) default_width);
D_line_width(width);
}
if (fcolor || zcolors) {
if (!cvarr_rgb && !cats_color_flag && !zcolors && !colors) {
D_RGB_color(fcolor->r, fcolor->g, fcolor->b);
D_polygon_abs(Points->x, Points->y, Points->n_points);
}
else {
if (custom_rgb) {
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
}
else {
D_RGB_color(fcolor->r, fcolor->g, fcolor->b);
}
if (cat >= 0) {
D_polygon_abs(Points->x, Points->y, Points->n_points);
}
}
}
/* boundary */
if (bcolor) {
if (custom_rgb) {
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
}
else {
D_RGB_color(bcolor->r, bcolor->g, bcolor->b);
}
/* use different user defined render methods */
D_polyline_abs(APoints->x, APoints->y, APoints->n_points);
for (i = 0; i < n_isles; i++) {
/* use different user defined render methods */
D_polyline_abs(IPoints[i]->x, IPoints[i]->y, IPoints[i]->n_points);
}
}
}
if ((colors || cvarr_rgb) && get_num_color_rules_skipped() > 0)
G_warning(_n("%d invalid color rule for areas skipped",
"%d invalid color rules for areas skipped",
get_num_color_rules_skipped()),
get_num_color_rules_skipped());
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(APoints);
for (i = 0; i < n_ipoints_alloc; i++) {
Vect_destroy_line_struct(IPoints[i]);
}
G_free(IPoints);
Vect_destroy_cats_struct(Cats);
return 0;
}
