int do_color(char *buff)
{
char in_color[64];
int R, G, B, color = 0;
if (1 != sscanf(buff, "%*s %s", in_color)) {
G_warning(_("Unable to read color"));
return (-1);
}
/* Parse and select color */
color = G_str_to_color(in_color, &R, &G, &B);
if (color == 0) {
G_warning(_("[%s]: No such color"), in_color);
/* store for backup */
last_color.a = RGBA_COLOR_NONE;
return (-1);
}
if (color == 1) {
R_RGB_color(R, G, B);
/* store for backup */
set_last_color(R, G, B, RGBA_COLOR_OPAQUE);
}
if (color == 2) { /* color == 'none' */
R = D_translate_color(DEFAULT_BG_COLOR);
R_standard_color(R);
/* store for backup */
set_last_color(0, 0, 0, RGBA_COLOR_NONE);
}
return (0);
}
/*!
\brief Get color value from color string (name or RGB triplet)
\param color_str color string
\return color value
*/
int Nviz_color_from_str(const char *color_str)
{
int red, grn, blu;
if (G_str_to_color(color_str, &red, &grn, &blu) != 1) {
G_warning(_("Invalid color (%s), using \"white\" as default"),
color_str);
red = grn = blu = 255;
}
return (red & RED_MASK) + ((int)((grn) << 8) & GRN_MASK) +
((int)((blu) << 16) & BLU_MASK);
}
int get_table_color(int cat, int line,
struct Colors *colors, dbCatValArray *cvarr,
int *red, int *grn, int *blu)
{
int custom_rgb;
char colorstring[12]; /* RRR:GGG:BBB */
dbCatVal *cv;
custom_rgb = FALSE;
cv = NULL;
if (cat < 0)
return custom_rgb;
if (colors) {
/* read color table */
if (Rast_get_c_color(&cat, red, grn, blu, colors) == 1) {
custom_rgb = TRUE;
G_debug(3, "\tb: %d, g: %d, r: %d", *blu, *grn, *red);
}
}
/* read RGB colors from db for current area # */
if (cvarr && db_CatValArray_get_value(cvarr, cat, &cv) == DB_OK) {
sprintf(colorstring, "%s", db_get_string(cv->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 {
G_debug(3, "Invalid color definition '%s' ignored", colorstring);
ncolor_rules_skipped++;
}
}
else {
G_debug(3, "Invalid color definition '%s' ignored", colorstring);
ncolor_rules_skipped++;
}
}
return custom_rgb;
}
int read_outline(void)
{
char buf[1024];
char ch, *key, *data;
PSCOLOR color;
int ret, r, g, b;
PS.outline_width = 1.;
set_color(&color, 0, 0, 0);
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&color, r, g, b);
else if (ret == 2) /* i.e. "none" */
/* unset_color(&color); */
error(key, data, _("Unsupported color request"));
else
error(key, data, _("illegal color request"));
continue;
}
if (KEY("width")) {
PS.outline_width = -1.;
ch = ' ';
if (sscanf(data, "%lf%c", &(PS.outline_width), &ch) < 1
|| PS.outline_width < 0.) {
PS.outline_width = 1.;
error(key, data, _("illegal width request"));
}
if (ch == 'i')
PS.outline_width = PS.outline_width * 72.;
continue;
}
error(key, data, _("illegal outline sub-request"));
}
PS.outline_color = color;
PS.do_outline = 1;
return 0;
}
/* sets *color and returns 1 on success, -1 if no color found */
int get_ps_color_rgbcol_varea(struct Map_info *map, int vec, int area,
dbCatValArray * cvarr_rgb, PSCOLOR *color)
{
int cat, ret;
dbCatVal *cv_rgb;
int red, grn, blu;
char *rgbstring = NULL;
cat = Vect_get_area_cat(map, area, vector.layer[vec].field);
ret = db_CatValArray_get_value(cvarr_rgb, cat, &cv_rgb);
if (ret != DB_OK) {
G_warning(_("No record for category [%d]"), cat);
}
else {
rgbstring = db_get_string(cv_rgb->val.s);
if (rgbstring == NULL ||
G_str_to_color(rgbstring, &red, &grn, &blu) != 1) {
G_warning(_("Invalid RGB color definition in column <%s> for category [%d]"),
vector.layer[vec].rgbcol, cat);
rgbstring = NULL;
}
}
if (rgbstring) {
G_debug(3, " dynamic varea fill rgb color = %s", rgbstring);
set_color(color, red, grn, blu);
}
else {
set_color(color, 0, 0, 0);
return -1;
}
return 1;
}
int read_point(double e, double n)
{
char buf[1024], symb[1024];
int r, g, b;
int color_R, color_G, color_B;
int fcolor_R, fcolor_G, fcolor_B;
int ret;
double size, width, rotate;
int have_icon;
char ch;
char *key, *data;
int masked;
static char *help[] = {
"color color",
"fcolor fill color",
"symbol group/symbol",
"size #",
"width #",
"rotate #",
"masked [y|n]",
""
};
size = 6.0;
width = -1.0; /* default is proportionate to symbol size */
rotate = 0.0;
have_icon = 0;
masked = 0;
color_R = color_G = color_B = 0;
fcolor_R = fcolor_G = fcolor_B = 128;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("masked")) {
masked = yesno(key, data);
if (masked)
PS.mask_needed = 1;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1) {
color_R = r;
color_G = g;
color_B = b;
}
else if (ret == 2) /* i.e. "none" */
color_R = color_G = color_B = -1;
else
error(key, data, "illegal color request");
continue;
}
if (KEY("fcolor")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1) {
fcolor_R = r;
fcolor_G = g;
fcolor_B = b;
}
else if (ret == 2) /* i.e. "none" */
fcolor_R = fcolor_G = fcolor_B = -1;
else
error(key, data, "illegal color request");
continue;
}
if (KEY("symbol")) {
/* TODO: check if exists */
strcpy(symb, data);
continue;
}
if (KEY("size")) {
if (sscanf(data, "%lf", &size) != 1 || size <= 0.0) {
size = 1.0;
error(key, data, "illegal size request");
}
continue;
}
if (KEY("width")) {
ch = ' ';
if (sscanf(data, "%lf%c", &width, &ch) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width request");
}
if (ch == 'i')
width = width * 72.;
continue;
}
if (KEY("rotate")) {
if (sscanf(data, "%lf", &rotate) != 1) {
rotate = 0.0;
error(key, data, "illegal rotate request");
}
continue;
}
error(key, data, "illegal point request");
}
sprintf(buf, "P %d %f %f %d %d %d %d %d %d %f %f %s %.2f", masked, e, n,
color_R, color_G, color_B, fcolor_R, fcolor_G, fcolor_B, size,
rotate, symb, width);
add_to_plfile(buf);
return 0;
}
int read_rectangle(double e1, double n1, double e2, double n2)
{
char buf[300];
int r, g, b;
int color_R, color_G, color_B;
int fcolor_R, fcolor_G, fcolor_B;
int ret;
double width;
int masked;
char ch, *key, *data;
static char *help[] = {
"color color",
"fcolor fill color",
"width #",
"masked [y|n]",
""
};
width = 1.;
masked = 0;
color_R = color_G = color_B = 0;
fcolor_R = fcolor_G = fcolor_B = -1; /* not filled by default */
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("masked")) {
masked = yesno(key, data);
if (masked)
PS.mask_needed = 1;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1) {
color_R = r;
color_G = g;
color_B = b;
}
else if (ret == 2) /* i.e. "none" */
color_R = color_G = color_B = -1;
else
error(key, data, "illegal color request");
continue;
}
if (KEY("fcolor")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1) {
fcolor_R = r;
fcolor_G = g;
fcolor_B = b;
}
else if (ret == 2) /* i.e. "none" */
fcolor_R = fcolor_G = fcolor_B = -1;
else
error(key, data, "illegal color request");
continue;
}
if (KEY("width")) {
ch = ' ';
if (sscanf(data, "%lf%c", &width, &ch) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width request");
}
if (ch == 'i')
width = width * 72.;
continue;
}
error(key, data, "illegal rectangle request");
}
sprintf(buf, "R %d %f %f %f %f %d %d %d %d %d %d %.2f",
masked, e1, n1, e2, n2, color_R, color_G, color_B,
fcolor_R, fcolor_G, fcolor_B, width);
add_to_plfile(buf);
return 0;
}
void rgb2colr(const struct Map_info *Map, int layer, const char *rgb_column,
struct Colors *colors)
{
int i, ret, nskipped;
int red, grn, blu;
const char *rgb;
struct field_info *fi;
dbDriver *driver;
dbCatValArray cvarr;
dbCatVal *cv;
fi = Vect_get_field(Map, layer);
if (!fi)
G_fatal_error(_("Database connection not defined for layer %d"),
layer);
driver = db_start_driver_open_database(fi->driver, fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
if (db_column_Ctype(driver, fi->table, rgb_column) != DB_C_TYPE_STRING)
G_fatal_error(_("Data type of RGB column <%s> must be char"),
rgb_column);
if (0 > db_select_CatValArray(driver, fi->table, fi->key,
rgb_column, NULL, &cvarr))
G_warning(_("No RGB values found"));
Rast_init_colors(colors);
cv = NULL;
nskipped = 0;
for (i = 0; i < cvarr.n_values; i++) {
cv = &(cvarr.value[i]);
rgb = db_get_string(cv->val.s);
G_debug(3, "cat = %d RGB = %s", cv->cat, rgb);
if (!rgb) {
nskipped++;
continue;
}
ret = G_str_to_color(rgb, &red, &grn, &blu);
if (ret != 1) {
G_debug(3, "Invalid RGB value '%s'", rgb);
nskipped++;
continue;
}
Rast_add_c_color_rule((const CELL*) &(cv->cat), red, grn, blu,
(const CELL*) &(cv->cat), red, grn, blu, colors);
}
if (nskipped > 0)
G_warning(_("%d invalid RGB color values skipped"), nskipped);
db_close_database_shutdown_driver(driver);
}
int PNG_Graph_set(void)
{
unsigned int red, grn, blu;
int do_read = 0;
int do_map = 0;
char *p;
G_gisinit("PNG driver");
p = getenv("GRASS_PNGFILE");
if (!p || strlen(p) == 0)
p = FILE_NAME;
png.file_name = p;
p = getenv("GRASS_TRUECOLOR");
png.true_color = !p || strcmp(p, "FALSE") != 0;
G_verbose_message(_("png: truecolor status %s"),
png.true_color ? _("enabled") : _("disabled"));
p = getenv("GRASS_PNG_MAPPED");
do_map = p && strcmp(p, "TRUE") == 0;
if (do_map) {
char *ext = png.file_name + strlen(png.file_name) - 4;
if (G_strcasecmp(ext, ".bmp") != 0)
do_map = 0;
}
p = getenv("GRASS_PNG_READ");
do_read = p && strcmp(p, "TRUE") == 0;
if (do_read && access(png.file_name, 0) != 0)
do_read = 0;
png.width = screen_width;
png.height = screen_height;
png.clip_top = 0;
png.clip_bot = png.height;
png.clip_left = 0;
png.clip_rite = png.width;
p = getenv("GRASS_TRANSPARENT");
png.has_alpha = p && strcmp(p, "TRUE") == 0;
png_init_color_table();
p = getenv("GRASS_BACKGROUNDCOLOR");
if (p && *p &&
(sscanf(p, "%02x%02x%02x", &red, &grn, &blu) == 3 ||
G_str_to_color(p, (int *)&red, (int *)&grn, (int *)&blu) == 1)) {
png.background = png_get_color(red, grn, blu, png.has_alpha ? 255 : 0);
}
else {
/* 0xffffff = white, 0x000000 = black */
if (strcmp(DEFAULT_FG_COLOR, "white") == 0)
/* foreground: white, background: black */
png.background = png_get_color(0, 0, 0, png.has_alpha ? 255 : 0);
else
/* foreground: black, background: white */
png.background = png_get_color(255, 255, 255, png.has_alpha ? 255 : 0);
}
G_verbose_message(_("png: collecting to file '%s'"), png.file_name);
G_verbose_message(_("png: image size %dx%d"),
png.width, png.height);
if (do_read && do_map)
map_file();
if (!png.mapped)
png.grid = G_malloc(png.width * png.height * sizeof(unsigned int));
if (!do_read) {
PNG_Erase();
png.modified = 1;
}
if (do_read && !png.mapped)
read_image();
if (do_map && !png.mapped) {
write_image();
map_file();
}
return 0;
}
int read_info(void)
{
char buf[1024];
char *key, *data;
int fontsize;
double x, y;
int r, g, b, ret;
PSCOLOR color, bgcolor, border;
fontsize = 0;
set_color(&color, 0, 0, 0);
set_color(&bgcolor, 255, 255, 255);
unset_color(&border);
x = y = 0.0;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("where")) {
if (sscanf(data, "%lf %lf", &x, &y) != 2) {
x = y = 0.0;
error(key, data, _("illegal where request"));
}
else
continue;
}
if (KEY("fontsize")) {
fontsize = atoi(data);
if (fontsize < 4 || fontsize > 50)
fontsize = 0;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&color, r, g, b);
else if (ret == 2) /* i.e. "none" */
/* unset_color(&color); */
error(key, data, _("Unsupported color request"));
else
error(key, data, _("illegal color request"));
continue;
}
if (KEY("background")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&bgcolor, r, g, b);
else if (ret == 2) /* i.e. "none" */
unset_color(&bgcolor);
else
error(key, data, _("illegal bgcolor request"));
continue;
}
if (KEY("border")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&border, r, g, b);
else if (ret == 2) /* i.e. "none" */
unset_color(&border);
else
error(key, data, _("illegal border color request"));
continue;
}
if (KEY("font")) {
get_font(data);
m_info.font = G_store(data);
continue;
}
error(key, data, _("illegal mapinfo sub-request"));
}
m_info.x = x;
m_info.y = y;
m_info.color = color;
m_info.bgcolor = bgcolor;
m_info.border = border;
if (fontsize)
m_info.fontsize = fontsize;
return 0;
}
int read_header(void)
{
char buf[1024];
char *key, *data;
int fontsize;
PSCOLOR color;
int ret, r, g, b;
fontsize = 0;
set_color(&color, 0, 0, 0);
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("none")) {
PS.do_header = 0;
continue;
}
if (KEY("file")) {
G_strip(data);
hdr.fp = fopen(data, "r");
if (hdr.fp != NULL)
hdr.file = G_store(data);
continue;
}
if (KEY("fontsize")) {
fontsize = atoi(data);
if (fontsize < 4 || fontsize > 50)
fontsize = 0;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&color, r, g, b);
else if (ret == 2) /* i.e. "none" */
/* unset_color(&color); */
error(key, data, _("Unsupported color request"));
else
error(key, data, _("illegal color request"));
continue;
}
if (KEY("font")) {
get_font(data);
hdr.font = G_store(data);
continue;
}
error(key, data, _("illegal header sub-request"));
}
hdr.color = color;
if (fontsize)
hdr.fontsize = fontsize;
return 0;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct GParams *params;
int i, ret;
int red, grn, blu;
float size;
double vp_height, z_exag; /* calculated viewpoint height, z-exag */
int width, height; /* output image size */
char *output_name;
nv_data data;
struct render_window *offscreen;
/* initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("visualization"));
G_add_keyword(_("graphics"));
G_add_keyword(_("raster"));
G_add_keyword(_("vector"));
G_add_keyword(_("raster3d"));
module->label = _("Creates a 3D rendering of GIS data.");
module->description = _("Renders surfaces (raster data), "
"2D/3D vector data, and "
"volumes (3D raster data) in 3D.");
params = (struct GParams *)G_malloc(sizeof(struct GParams));
/* define options, call G_parser() */
parse_command(argc, argv, params);
/* check parameters consistency */
check_parameters(params);
width = atoi(params->size->answers[0]);
height = atoi(params->size->answers[1]);
G_asprintf(&output_name, "%s.%s", params->output->answer,
params->format->answer);
GS_libinit();
GVL_libinit();
GS_set_swap_func(swap_gl);
/* define render window */
offscreen = Nviz_new_render_window();
Nviz_init_render_window(offscreen);
if (Nviz_create_render_window(offscreen, NULL, width, height) == -1)
G_fatal_error(_("Unable to render data"));
Nviz_make_current_render_window(offscreen);
/* initialize nviz data */
Nviz_init_data(&data);
/* define default attributes for map objects */
Nviz_set_surface_attr_default();
/* set background color */
Nviz_set_bgcolor(&data, Nviz_color_from_str(params->bgcolor->answer));
/* init view, lights */
Nviz_init_view(&data);
/* load raster maps (surface topography) & set attributes (map/constant) */
load_rasters(params, &data);
/* set draw mode of loaded surfaces */
surface_set_draw_mode(params);
/* load line vector maps */
if (params->vlines->answer) {
load_vlines(params, &data);
/* set attributes of 2d lines */
vlines_set_attrb(params);
}
/* load point vector maps */
if (params->vpoints->answer) {
load_vpoints(params, &data);
/* set attributes for points */
vpoints_set_attrb(params);
}
/* load volumes */
if (params->volume->answer) {
load_rasters3d(params, &data);
}
/* define isosurfaces for displaying volumes */
if (params->isosurf_level->answer) {
add_isosurfs(params, &data);
}
/* define slices for displaying volumes */
if (params->slice->answer) {
add_slices(params, &data);
}
/* focus on loaded data */
Nviz_set_focus_map(MAP_OBJ_UNDEFINED, -1);
/* define view point */
if (params->exag->answer) {
z_exag = atof(params->exag->answer);
}
else {
z_exag = Nviz_get_exag();
G_verbose_message(_("Vertical exaggeration not given, using calculated "
"value %.0f"), z_exag);
}
Nviz_change_exag(&data, z_exag);
if (params->height->answer) {
vp_height = atof(params->height->answer);
}
else {
double min, max;
Nviz_get_exag_height(&vp_height, &min, &max);
G_verbose_message(_("Viewpoint height not given, using calculated "
"value %.0f"), vp_height);
}
Nviz_set_viewpoint_height(vp_height);
Nviz_set_viewpoint_position(atof(params->pos->answers[0]),
atof(params->pos->answers[1]));
Nviz_set_viewpoint_twist(atoi(params->twist->answer));
Nviz_set_viewpoint_persp(atoi(params->persp->answer));
if (params->focus->answer) {
Nviz_set_focus(&data, atof(params->focus->answers[0]),
atof(params->focus->answers[1]),
atof(params->focus->answers[2]));
}
/* set lights */
Nviz_set_light_position(&data, 1,
atof(params->light_pos->answers[0]),
atof(params->light_pos->answers[1]),
atof(params->light_pos->answers[2]), 0.0);
Nviz_set_light_bright(&data, 1,
atoi(params->light_bright->answer) / 100.0);
if (G_str_to_color(params->light_color->answer, &red, &grn, &blu) != 1) {
red = grn = blu = 255;
}
Nviz_set_light_color(&data, 1, red, grn, blu);
Nviz_set_light_ambient(&data, 1,
atof(params->light_ambient->answer) / 100.0);
/* define fringes */
if (params->fringe->answer) {
int nw, ne, sw, se;
i = 0;
nw = ne = sw = se = 0;
while (params->fringe->answers[i]) {
const char *edge = params->fringe->answers[i++];
if (strcmp(edge, "nw") == 0)
nw = 1;
else if (strcmp(edge, "ne") == 0)
ne = 1;
else if (strcmp(edge, "sw") == 0)
sw = 1;
else if (strcmp(edge, "se") == 0)
se = 1;
}
Nviz_new_fringe(&data, -1,
Nviz_color_from_str(params->fringe_color->answer),
atof(params->fringe_elev->answer), nw, ne, sw, se);
}
/* draw north arrow */
if (params->north_arrow->answer) {
if (!params->north_arrow_size->answer)
size = Nviz_get_longdim(&data) / 8.;
else
size = atof(params->north_arrow_size->answer);
Nviz_set_arrow(&data, atoi(params->north_arrow->answers[0]),
atoi(params->north_arrow->answers[1]),
size,
Nviz_color_from_str(params->north_arrow_color->
answer));
Nviz_draw_arrow(&data);
}
GS_clear(data.bgcolor);
/* cutting planes */
if (params->cplane->answer)
draw_cplane(params, &data);
/* draw */
Nviz_draw_all(&data);
/* write to image */
ret = 0;
if (strcmp(params->format->answer, "ppm") == 0)
ret = write_img(output_name, FORMAT_PPM);
if (strcmp(params->format->answer, "tif") == 0)
ret = write_img(output_name, FORMAT_TIF);
if (!ret)
G_fatal_error(_("Unsupported output format"));
G_done_msg(_("File <%s> created."), output_name);
Nviz_destroy_data(&data);
Nviz_destroy_render_window(offscreen);
G_free((void *)output_name);
G_free((void *)params);
exit(EXIT_SUCCESS);
}
/*!
\brief Load styles for geolines based on thematic mapping
\param gv pointer to geovect structure
\param colors pointer to Colors structure or NULL
\return number of features defined by thematic mapping
\return -1 on error
*/
int Gv_load_vect_thematic(geovect *gv, struct Colors *colors)
{
geoline *gvt;
struct Map_info Map;
struct field_info *Fi;
int nvals, cat, nlines, nskipped;
int red, blu, grn;
const char *str;
const char *mapset;
dbDriver *driver;
dbValue value;
if(!gv || !gv->tstyle || !gv->filename)
return -1;
mapset = G_find_vector2(gv->filename, "");
if (!mapset) {
G_fatal_error(_("Vector map <%s> not found"), gv->filename);
}
Vect_set_open_level(1);
if (Vect_open_old(&Map, gv->filename, "") == -1) {
G_fatal_error(_("Unable to open vector map <%s>"),
G_fully_qualified_name(gv->filename, mapset));
}
Fi = Vect_get_field(&Map, gv->tstyle->layer);
if (!Fi) {
G_warning(_("Database connection not defined for layer %d"),
gv->tstyle->layer);
}
else {
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
G_message(_("Loading thematic vector layer <%s>..."),
G_fully_qualified_name(gv->filename, mapset));
nlines = nskipped = 0;
for(gvt = gv->lines; gvt; gvt = gvt->next) {
gvt->style = (gvstyle *) G_malloc(sizeof(gvstyle));
G_zero(gvt->style, sizeof(gvstyle));
/* use default style */
gvt->style->color = gv->style->color;
gvt->style->symbol = gv->style->symbol;
gvt->style->size = gv->style->size;
gvt->style->width = gv->style->width;
cat = -1;
if (gvt->cats)
Vect_cat_get(gvt->cats, gv->tstyle->layer, &cat);
if (cat < 0) {
nskipped++;
continue;
}
/* color */
if (colors) {
if (!Rast_get_c_color((const CELL *) &cat, &red, &grn, &blu, colors)) {
G_warning(_("No color rule defined for category %d"), cat);
gvt->style->color = gv->style->color;
}
gvt->style->color = (red & RED_MASK) + ((int)((grn) << 8) & GRN_MASK) +
((int)((blu) << 16) & BLU_MASK);
}
if (gv->tstyle->color_column) {
nvals = db_select_value(driver, Fi->table, Fi->key, cat, gv->tstyle->color_column, &value);
if (nvals < 1)
continue;
str = db_get_value_string(&value);
if (!str)
continue;
if (G_str_to_color(str, &red, &grn, &blu) != 1) {
G_warning(_("Invalid color definition (%s)"),
str);
gvt->style->color = gv->style->color;
}
else {
gvt->style->color = (red & RED_MASK) + ((int)((grn) << 8) & GRN_MASK) +
((int)((blu) << 16) & BLU_MASK);
}
}
/* width */
if (gv->tstyle->width_column) {
nvals = db_select_value(driver, Fi->table, Fi->key, cat, gv->tstyle->width_column, &value);
if (nvals < 1)
continue;
gvt->style->width = db_get_value_int(&value);
}
nlines++;
}
if (nskipped > 0)
G_warning(_("%d features without category. "
"Unable to determine color rules for features without category."),
nskipped);
return nlines;
}
int getgrid(void)
{
int spacing;
int fontsize = PS_FONT_DEFAULT_SIZE;
int ret, r, g, b;
char temp[30];
char buf[1024];
char ch, *key, *data;
PSCOLOR color, text_color;
PS.grid_font = G_store("Helvetica");
PS.grid_fontsize = 0;
PS.grid_numbers = 0;
PS.grid_cross = 0.;
PS.grid_width = 0.25;
set_color(&color, 0, 0, 0);
set_color(&text_color, 0, 0, 0);
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&color, r, g, b);
else if (ret == 2) /* i.e. "none" */
/* unset_color(&color); */
error(key, data, _("Unsupported color request"));
else
error(key, data, _("illegal color request"));
continue;
}
if (KEY("numbers")) {
spacing = -1;
if (strlen(data) == 0) {
spacing = 1;
set_color(&text_color, 0, 0, 0);
}
switch (sscanf(data, "%d %[^\n]", &spacing, temp)) {
case 1:
set_color(&text_color, 0, 0, 0);
break;
case 2:
ret = G_str_to_color(temp, &r, &g, &b);
if (ret == 1)
set_color(&text_color, r, g, b);
else if (ret == 2) /* i.e. "none" */
error(key, data, _("Unsupported color request"));
else
error(key, data, _("illegal color request"));
if (ret < 1)
spacing = -1;
break;
}
if (spacing < 0)
error(key, data, _("illegal numbers request"));
else {
PS.grid_numbers = spacing;
PS.grid_numbers_color = text_color;
}
continue;
}
if (KEY("cross")) {
PS.grid_cross = atof(data);
continue;
}
if (KEY("fontsize")) {
fontsize = atoi(data);
if (fontsize < PS_FONT_MIN_SIZE || fontsize > PS_FONT_MAX_SIZE)
fontsize = PS_FONT_DEFAULT_SIZE;
continue;
}
if (KEY("font")) {
get_font(data);
PS.grid_font = G_store(data);
continue;
}
if (KEY("width")) {
PS.grid_width = -1.;
ch = ' ';
if ((sscanf(data, "%lf%c", &PS.grid_width, &ch) < 1) ||
(PS.grid_width < 0.)) {
PS.grid_width = 1.;
error(key, data, _("illegal grid width request"));
}
if (ch == 'i')
PS.grid_width = PS.grid_width * 72.0;
continue;
}
error(key, data, _("illegal request (grid)"));
}
PS.grid_fontsize = fontsize;
PS.grid_color = color;
return 0;
}
int read_text(char *east, char *north, char *text)
{
PSCOLOR color, hcolor, background, border;
int r, g, b;
int ret;
int xoffset;
int yoffset;
float size;
int fontsize;
double width;
double hwidth;
double rotate;
int xref, yref;
int opaque;
char t1[128];
char buf[1024];
char *key, *data;
FILE *fd;
char fontname[128];
set_color(&color, 0, 0, 0); /* black */
unset_color(&hcolor);
unset_color(&background);
unset_color(&border);
opaque = TRUE;
size = 0.0;
fontsize = 0;
xoffset = 0;
yoffset = 0;
width = 1.;
hwidth = 0.;
rotate = 0.0;
xref = CENTER;
yref = CENTER;
G_strcpy(fontname, "Helvetica");
while (*text == ' ' || *text == '\t')
text++;
if (*text == '\\')
text++;
if (*text == 0) {
error("text", "", "no text given");
gobble_input();
return 0;
}
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("font")) {
get_font(data);
strcpy(fontname, data);
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&color, r, g, b);
else if (ret == 2)
error(key, data, "primary color cannot be \"none\"");
else
error(key, data, "illegal color request");
continue;
}
if (KEY("hcolor")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&hcolor, r, g, b);
else if (ret == 2)
unset_color(&hcolor);
else
error(key, data, "illegal hcolor request");
if (color_none(&hcolor) || hwidth <= 0.)
hwidth = 0.;
continue;
}
if (KEY("background")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&background, r, g, b);
else if (ret == 2) {
unset_color(&background);
opaque = FALSE;
}
else
error(key, data, "illegal background color request");
continue;
}
if (KEY("border")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&border, r, g, b);
else if (ret == 2)
unset_color(&border);
else
error(key, data, "illegal border color request");
continue;
}
if (KEY("opaque")) {
opaque = yesno(key, data);
continue;
}
if (KEY("width")) {
width = -1.;
*t1 = 0;
if (sscanf(data, "%lf%1s", &width, t1) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width request");
}
if (t1 && t1[0] == 'i')
width = width / 72.0;
continue;
}
if (KEY("hwidth")) {
hwidth = -1.;
*t1 = 0;
if (sscanf(data, "%lf%1s", &hwidth, t1) < 1 || hwidth < 0.) {
hwidth = 0.;
error(key, data, "illegal width request");
}
if (t1 && t1[0] == 'i')
hwidth = hwidth / 72.0;
continue;
}
if (KEY("size")) {
double x;
if (!scan_resolution(data, &x)) {
size = 0.0;
error(key, data, "illegal size request");
}
else
size = x;
continue;
}
if (KEY("fontsize")) {
if (sscanf(data, "%d", &fontsize) != 1 || fontsize <= 0) {
error(key, data, "illegal fontsize request");
}
else
continue;
}
if (KEY("xoffset")) {
*t1 = 0;
if (sscanf(data, "%d%1s", &xoffset, t1) != 1 || *t1) {
xoffset = 0;
error(key, data, "illegal request (text)");
}
continue;
}
if (KEY("yoffset")) {
*t1 = 0;
if (sscanf(data, "%d%1s", &yoffset, t1) != 1 || *t1) {
yoffset = 0;
error(key, data, "illegal request (text)");
}
continue;
}
if (KEY("rotate")) {
if (sscanf(data, "%lf", &rotate) != 1) {
rotate = 0.0;
error(key, data, "illegal rotate request");
}
continue;
}
if (KEY("ref")) {
if (!scan_ref(data, &xref, &yref)) {
xref = CENTER;
yref = CENTER;
error(key, data, "illegal ref request");
}
continue;
}
error(key, data, "illegal request (text)");
}
/* if file doesn't exist create it and close it */
if (labels.other == NULL) {
labels.other = G_tempfile();
if ((fd = fopen(labels.other, "w")) != NULL)
fclose(fd);
}
/* open file in append mode */
fd = fopen(labels.other, "a");
if (fd == NULL) {
error("misc labels file", "", "can't open");
return 1;
}
/* write the file */
fprintf(fd, "font: %s\n", fontname);
fprintf(fd, "east: %s\n", east);
fprintf(fd, "north: %s\n", north);
fprintf(fd, "xoffset: %d\n", xoffset);
fprintf(fd, "yoffset: %d\n", yoffset);
fprintf(fd, "width: %f\n", width);
fprintf(fd, "hwidth: %f\n", hwidth);
fprintf(fd, "size: %f\n", size);
fprintf(fd, "fontsize: %d\n", fontsize);
fprintf(fd, "opaque: %s\n", opaque ? "yes" : "no");
if (rotate != 0)
fprintf(fd, "rotate: %f\n", rotate);
fprintf(fd, "color: ");
if (!color_none(&color))
fprintf(fd, "%d:%d:%d\n", color.r, color.g, color.b);
else
fprintf(fd, "black\n");
fprintf(fd, "hcolor: ");
if (!color_none(&hcolor))
fprintf(fd, "%d:%d:%d\n", hcolor.r, hcolor.g, hcolor.b);
else
fprintf(fd, "none\n");
fprintf(fd, "background: ");
if (!color_none(&background))
fprintf(fd, "%d:%d:%d\n", background.r, background.g, background.b);
else
fprintf(fd, "none\n");
fprintf(fd, "border: ");
if (!color_none(&border))
fprintf(fd, "%d:%d:%d\n", border.r, border.g, border.b);
else
fprintf(fd, "none\n");
fprintf(fd, "ref: ");
switch (yref) {
case UPPER:
fprintf(fd, "upper");
break;
case LOWER:
fprintf(fd, "lower");
break;
case CENTER:
fprintf(fd, "center");
break;
}
switch (xref) {
case LEFT:
fprintf(fd, " left");
break;
case RIGHT:
fprintf(fd, " right");
break;
case CENTER:
fprintf(fd, "%s", (xref == CENTER) ? "" : " center");
break;
}
fprintf(fd, "\n");
fprintf(fd, "text:%s\n\n", text);
fclose(fd);
return 0;
}
int do_symbol(char *buff)
{
double xper, yper;
int size;
int ix, iy;
char *symb_name;
SYMBOL *Symb;
char *line_color_str, *fill_color_str;
RGBA_Color *line_color, *fill_color;
int R, G, B, ret;
line_color = G_malloc(sizeof(RGBA_Color));
fill_color = G_malloc(sizeof(RGBA_Color));
symb_name = G_malloc(sizeof(char) * strlen(buff) + 1); /* well, it won't be any bigger than this */
line_color_str = G_malloc(sizeof(char) * strlen(buff) + 1);
fill_color_str = G_malloc(sizeof(char) * strlen(buff) + 1);
G_debug(3, "do_symbol() [%s]", buff);
/* set default colors so colors are optional */
strcpy(line_color_str, DEFAULT_FG_COLOR);
strcpy(fill_color_str, "grey");
if (sscanf
(buff, "%*s %s %d %lf %lf %s %s", symb_name, &size, &xper, &yper,
line_color_str, fill_color_str) < 4) {
G_warning(_("Problem parsing command [%s]"), buff);
return (-1);
}
if (mapunits) {
ix = (int)(D_u_to_d_col(xper) + 0.5);
iy = (int)(D_u_to_d_row(yper) + 0.5);
/* consider size in map units too? maybe as percentage of display?
perhaps use "size * D_get_u_to_d_yconv()" to convert */
}
else {
if (xper < 0. || yper < 0. || xper > 100. || yper > 100.)
return (-1);
ix = l + (int)(xper * xincr);
iy = b - (int)(yper * yincr);
}
/* parse line color */
ret = G_str_to_color(line_color_str, &R, &G, &B);
line_color->r = (unsigned char)R;
line_color->g = (unsigned char)G;
line_color->b = (unsigned char)B;
if (ret == 1) {
/* here alpha is only used as an on/off switch, otherwise unused by the display drivers */
line_color->a = RGBA_COLOR_OPAQUE;
}
else if (ret == 2)
line_color->a = RGBA_COLOR_NONE;
else {
G_warning(_("[%s]: No such color"), line_color_str);
return (-1);
}
/* parse fill color */
ret = G_str_to_color(fill_color_str, &R, &G, &B);
fill_color->r = (unsigned char)R;
fill_color->g = (unsigned char)G;
fill_color->b = (unsigned char)B;
if (ret == 1)
fill_color->a = RGBA_COLOR_OPAQUE;
else if (ret == 2)
fill_color->a = RGBA_COLOR_NONE;
else {
G_warning(_("[%s]: No such color"), fill_color_str);
return (-1);
}
Symb = S_read(symb_name);
if (Symb == NULL) {
G_warning(_("Cannot read symbol, cannot display points"));
return (-1);
}
else
S_stroke(Symb, size, rotation, 0);
D_symbol(Symb, ix, iy, line_color, fill_color);
/* restore previous d.graph draw color */
if (last_color.a == RGBA_COLOR_OPAQUE)
R_RGB_color(last_color.r, last_color.g, last_color.b);
else if (last_color.a == RGBA_COLOR_NONE)
D_raster_use_color(D_parse_color(DEFAULT_BG_COLOR, 0));
else /* unset or bad */
R_RGB_color(line_color->r, line_color->g, line_color->b);
G_free(symb_name);
G_free(line_color_str);
G_free(fill_color_str);
G_free(line_color);
G_free(fill_color);
return (0);
}
int draw_n_arrow(double east, double north, double fontsize,
char *n_arrow_num, double line_width)
{
double x_pos, y_pos;
double t, b, l, r;
double tt, tb, tl, tr; /* text box*/
SYMBOL *Symb;
RGBA_Color *line_color, *fill_color;
int R, G, B;
double x0, y0;
char icon[64];
double symbol_size;
/* Establish text size */
if (fontsize > 0)
D_text_size(fontsize, fontsize);
D_setup_unity(0);
D_get_src(&t, &b, &l, &r);
x_pos = east * (r - l) / 100.;
y_pos = (100. - north) * (b - t) / 100.;
if (line_width > 0)
D_line_width(line_width);
if (fontsize > 0) {
/* draw the "N" */
D_get_text_box("N", &tt, &tb, &tl, &tr);
D_use_color(fg_color);
/* positions manually tuned */
switch (n_arrow_num[0]) {
case '1':
D_pos_abs(x_pos - (tr + tl) / 2, y_pos - 45);
D_text("N");
break;
case '3':
D_pos_abs(x_pos - (tr + tl) / 2, y_pos - 60);
D_text("N");
break;
case '4':
D_pos_abs(x_pos - (tr + tl) / 2, y_pos - 45);
D_text("N");
break;
case '7':
D_pos_abs(x_pos - (tr + tl) / 2, y_pos - 70);
D_text("N");
break;
case '9':
case 'f':
D_pos_abs(x_pos - (tr + tl) / 2, y_pos - 55);
D_text("N");
break;
case 'b':
D_pos_abs(x_pos - (tr + tl) / 2, y_pos - 48.5);
D_text("N");
break;
case '2':
case '5':
case '6':
case '8':
break;
default:
G_fatal_error(_("Could not parse symbol"));
}
}
/* display the north arrow symbol */
line_color = G_malloc(sizeof(RGBA_Color));
fill_color = G_malloc(sizeof(RGBA_Color));
if (D_color_number_to_RGB(fg_color, &R, &G, &B) == 0)
/* fall back to black on failure */
G_str_to_color(DEFAULT_FG_COLOR, &R, &G, &B);
line_color->r = (unsigned char)R;
line_color->g = (unsigned char)G;
line_color->b = (unsigned char)B;
line_color->a = RGBA_COLOR_OPAQUE;
if (D_color_number_to_RGB(bg_color, &R, &G, &B) == 0)
/* fall back to black on failure */
G_str_to_color(DEFAULT_FG_COLOR, &R, &G, &B);
fill_color->r = (unsigned char)R;
fill_color->g = (unsigned char)G;
fill_color->b = (unsigned char)B;
fill_color->a = RGBA_COLOR_OPAQUE;
if (n_arrow_num[0] == '2' || n_arrow_num[0] == '9')
fill_color->a = RGBA_COLOR_TRANSPARENT;
/* sizes manually tuned */
switch (n_arrow_num[0]) {
case '1':
symbol_size = 35.;
break;
case '2':
symbol_size = 19.;
break;
case '3':
symbol_size = 20.;
break;
case '4':
symbol_size = 15.;
break;
case '5':
case '6':
symbol_size = 14.;
break;
case '7':
symbol_size = 23.;
break;
case '8':
case '9':
symbol_size = 17.;
break;
case 'b':
symbol_size = 80.;
break;
case 'f':
symbol_size = 100.;
break;
default:
G_fatal_error(_("Could not parse symbol"));
}
x0 = D_d_to_u_col(x_pos);
y0 = D_d_to_u_row(y_pos);
if (n_arrow_num[0] == 'b')
strcpy(icon, "n_arrows/basic_compass");
else if (n_arrow_num[0] == 'f')
strcpy(icon, "n_arrows/fancy_compass");
else {
strcpy(icon, "n_arrows/n_arrow");
strncat(icon, n_arrow_num, 32);
}
Symb = S_read(icon);
if(!Symb)
G_fatal_error(_("Could not read symbol \"%s\""), icon);
S_stroke(Symb, symbol_size, 0.0, 0);
D_symbol(Symb, x0, y0, line_color, fill_color);
if (line_width > 0)
D_line_width(0);
G_free(Symb);
G_free(line_color);
G_free(fill_color);
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 */
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *opt1, *opt2;
struct Flag *mapcoords;
int R, G, B, color = 0;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description =
_("Program for generating and displaying simple graphics on the "
"display monitor.");
opt1 = G_define_option();
opt1->key = "input";
opt1->type = TYPE_STRING;
opt1->required = NO;
opt1->description = _("Name of file containing graphics commands, "
"if not given reads from standard input");
opt1->gisprompt = "old_file,file,input";
opt2 = G_define_option();
opt2->key = "color";
opt2->type = TYPE_STRING;
opt2->required = NO;
opt2->description = _("Color to draw with, either a standard GRASS color "
"or R:G:B triplet");
opt2->answer = DEFAULT_FG_COLOR;
opt2->gisprompt = "old_color,color,color";
mapcoords = G_define_flag();
mapcoords->key = 'm';
mapcoords->description = _("Coordinates are given in map units");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* default font scaling: 5% of active frame */
hsize = vsize = 5.;
if (opt1->answer != NULL) {
if ((infile = fopen(opt1->answer, "r")) == NULL)
G_fatal_error(_("Graph file <%s> not found"), opt1->answer);
}
else
infile = stdin;
/* open graphics window */
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
/* Parse and select color */
if (opt2->answer != NULL) {
color = G_str_to_color(opt2->answer, &R, &G, &B);
if (color == 0)
G_fatal_error(_("[%s]: No such color"), opt2->answer);
if (color == 1) {
D_RGB_color(R, G, B);
set_last_color(R, G, B, RGBA_COLOR_OPAQUE);
}
else /* (color==2) is "none" */
set_last_color(0, 0, 0, RGBA_COLOR_NONE);
}
if (mapcoords->answer) {
mapunits = TRUE;
D_setup(0);
}
else {
D_setup2(0, 0, 100, 0, 0, 100);
mapunits = FALSE;
}
/* Do the graphics */
set_graph_stuff();
set_text_size();
graphics(infile);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int read_vpoints(char *name, char *mapset)
{
char fullname[100];
char buf[1024];
char *key, *data;
double width, size, scale, rotate;
int itmp, vec;
int r, g, b;
int ret;
struct Map_info Map;
vector_alloc(); /* allocate space */
sprintf(fullname, "%s in %s", name, mapset);
Vect_set_open_level(2);
Vect_set_fatal_error(GV_FATAL_PRINT);
if (2 > Vect_open_old(&Map, name, mapset)) {
error(fullname, "", "can't open vector map");
gobble_input();
return 0;
}
Vect_close(&Map);
vec = vector.count;
vector.layer[vec].type = VPOINTS;
vector.layer[vec].name = G_store(name);
vector.layer[vec].mapset = G_store(mapset);
vector.layer[vec].ltype = GV_POINT;
vector.layer[vec].masked = 0;
vector.layer[vec].field = 1;
vector.layer[vec].cats = NULL;
vector.layer[vec].where = NULL;
vector.layer[vec].width = 1.;
set_color(&(vector.layer[vec].color), 0, 0, 0);
set_color(&(vector.layer[vec].fcolor), 255, 0, 0);
vector.layer[vec].rgbcol = NULL;
vector.layer[vec].label = NULL;
vector.layer[vec].lpos = -1;
vector.layer[vec].symbol = G_store("basic/diamond");
vector.layer[vec].size = 6.0;
vector.layer[vec].sizecol = NULL;
vector.layer[vec].scale = 1.0;
vector.layer[vec].rotate = 0.0;
vector.layer[vec].rotcol = NULL;
vector.layer[vec].epstype = 0;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("masked")) {
vector.layer[vec].masked = yesno(key, data);
if (vector.layer[vec].masked)
PS.mask_needed = 1;
continue;
}
if (KEY("type")) {
G_strip(data);
vector.layer[vec].ltype = 0;
if (strstr(data, "point"))
vector.layer[vec].ltype |= GV_POINT;
if (strstr(data, "centroid"))
vector.layer[vec].ltype |= GV_CENTROID;
continue;
}
if (KEY("layer")) {
G_strip(data);
vector.layer[vec].field = atoi(data);
continue;
}
if (KEY("cats")) {
G_strip(data);
vector.layer[vec].cats = G_store(data);
continue;
}
if (KEY("where")) {
G_strip(data);
vector.layer[vec].where = G_store(data);
continue;
}
if (KEY("width")) {
width = -1.;
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width (vpoints)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].width = width;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].color), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].color));
else
error(key, data, "illegal color request");
continue;
}
if (KEY("fcolor")) { /* fill color */
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].fcolor), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].fcolor));
else
error(key, data, "illegal color request (vpoints)");
continue;
}
if (KEY("rgbcolumn")) {
G_strip(data);
vector.layer[vec].rgbcol = G_store(data);
continue;
}
if (KEY("label")) { /* map legend label */
G_strip(data);
vector.layer[vec].label = G_store(data);
continue;
}
if (KEY("lpos")) {
if (sscanf(data, "%d", &itmp) < 1 || itmp < 0) {
itmp = -1;
error(key, data, "illegal lpos");
continue;
}
vector.layer[vec].lpos = itmp;
continue;
}
if (KEY("symbol")) {
/* TODO: test here if isymbol exists */
vector.layer[vec].symbol = G_store(data);
continue;
}
if (KEY("eps")) {
char *cc;
G_chop(data);
vector.layer[vec].epspre = G_store(data);
/* epstype: 0 - no eps, 1 - common eps, 2 - eps for each category */
vector.layer[vec].epstype = 1;
/* find dynamic filename by cat number character */
/* pre is filename before the $, suf is filename after the $ */
cc = (char *)strchr(vector.layer[vec].epspre, '$');
if (cc != NULL) {
*cc = '\0';
vector.layer[vec].epssuf = G_store(cc + sizeof(char));
vector.layer[vec].epstype = 2;
G_debug(2, "epstype=%d, pre=[%s], suf=[%s]",
vector.layer[vec].epstype, vector.layer[vec].epspre,
vector.layer[vec].epssuf);
}
else {
G_debug(2, "epstype=%d, eps file=[%s]",
vector.layer[vec].epstype, vector.layer[vec].epspre);
}
continue;
}
if (KEY("size")) {
if (sscanf(data, "%lf", &size) != 1 || size <= 0.0) {
size = 1.0;
error(key, data, "illegal size request (vpoints)");
}
vector.layer[vec].size = size;
continue;
}
/*
GRASS 6.3: sizecol renamed to sizecolumn
remove sizecol test and the warning in GRASS7
*/
if (KEY("sizecol")) {
G_warning(_("The mapping instruction <%s> will be renamed to <%s> "
"in future versions of GRASS. Please use <%s> instead."),
"sizecol", "sizecolumn", "sizecolumn");
}
if (KEY("sizecol") || KEY("sizecolumn")) {
G_strip(data);
vector.layer[vec].sizecol = G_store(data);
continue;
}
if (KEY("scale")) {
if (sscanf(data, "%lf", &scale) != 1 || scale <= 0.0) {
scale = 1.0;
error(key, data, "illegal scale request (vpoints)");
}
vector.layer[vec].scale = scale;
continue;
}
if (KEY("rotate")) {
if (sscanf(data, "%lf", &rotate) != 1) {
rotate = 0.0;
error(key, data, "illegal rotation request (vpoints)");
}
vector.layer[vec].rotate = rotate;
continue;
}
if (KEY("rotatecolumn")) {
G_strip(data);
vector.layer[vec].rotcol = G_store(data);
continue;
}
error(key, "", "illegal request (vpoints)");
}
vector.count++;
return 1;
}
int read_border(void)
{
char buf[1024];
char *key, *data;
double width;
char ch;
int r, g, b;
double color_R, color_G, color_B;
int ret;
static char *help[] = {
"color name",
"width #",
""
};
G_debug(1, "Reading border settings ..");
width = 1.;
color_R = color_G = color_B = 0.;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1) {
color_R = r / 255.;
color_G = g / 255.;
color_B = b / 255.;
}
else if (ret == 2) /* i.e. "none" */
color_R = color_G = color_B = -1.;
else
error(key, data, "illegal border color request");
continue;
}
if (KEY("width")) {
ch = ' ';
if (sscanf(data, "%lf%c", &width, &ch) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal border width request");
}
/* if asked for in inches */
if (ch == 'i')
width = width * 72.;
continue;
}
error(key, data, "illegal border sub-request");
}
brd.R = color_R;
brd.G = color_G;
brd.B = color_B;
brd.width = width;
return 0;
}
int read_vlines(char *name, char *mapset)
{
char fullname[GNAME_MAX];
char buf[1024];
char *key, *data, *dp;
double width;
int itmp, vec;
int r, g, b;
int ret;
struct Map_info Map;
vector_alloc(); /* allocate space */
sprintf(fullname, "%s in %s", name, mapset);
Vect_set_open_level(2);
Vect_set_fatal_error(GV_FATAL_PRINT);
if (2 > Vect_open_old(&Map, name, mapset)) {
error(fullname, "", "can't open vector map");
gobble_input();
return 0;
}
Vect_close(&Map);
vec = vector.count;
vector.layer[vec].type = VLINES;
vector.layer[vec].name = G_store(name);
vector.layer[vec].mapset = G_store(mapset);
vector.layer[vec].ltype = GV_LINE;
vector.layer[vec].masked = 0;
vector.layer[vec].field = 1;
vector.layer[vec].cats = NULL;
vector.layer[vec].where = NULL;
vector.layer[vec].width = 1.;
vector.layer[vec].cwidth = 0.;
vector.layer[vec].offset = 0.;
vector.layer[vec].coffset = 0.;
set_color(&(vector.layer[vec].color), 0, 0, 0);
vector.layer[vec].rgbcol = NULL;
vector.layer[vec].linestyle = NULL;
vector.layer[vec].linecap = LINECAP_BUTT;
vector.layer[vec].ref = LINE_REF_CENTER;
vector.layer[vec].hwidth = 0.;
unset_color(&(vector.layer[vec].hcolor));
vector.layer[vec].label = NULL;
vector.layer[vec].lpos = -1;
vector.layer[vec].pwidth = 1.;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("masked")) {
vector.layer[vec].masked = yesno(key, data);
if (vector.layer[vec].masked)
PS.mask_needed = 1;
continue;
}
if (KEY("type")) {
G_strip(data);
vector.layer[vec].ltype = 0;
if (strstr(data, "line"))
vector.layer[vec].ltype |= GV_LINE;
if (strstr(data, "boundary"))
vector.layer[vec].ltype |= GV_BOUNDARY;
continue;
}
if (KEY("layer")) {
G_strip(data);
vector.layer[vec].field = atoi(data);
continue;
}
if (KEY("cats")) {
G_strip(data);
vector.layer[vec].cats = G_store(data);
continue;
}
if (KEY("where")) {
G_strip(data);
vector.layer[vec].where = G_store(data);
continue;
}
if (KEY("style")) {
G_strip(data);
if (strcmp(data, "solid") == 0) {
vector.layer[vec].linestyle = NULL;
continue;
}
else if (strcmp(data, "dashed") == 0) {
vector.layer[vec].linestyle = G_store("000000111");
continue;
}
else if (strcmp(data, "dotted") == 0) {
vector.layer[vec].linestyle = G_store("100000");
continue;
}
else if (strcmp(data, "dashdotted") == 0) {
vector.layer[vec].linestyle = G_store("000000111011111");
continue;
}
for (dp = data; *dp; dp++)
if (*dp < '0' || *dp > '9')
break;
if (*dp != 0 || dp == data) {
error(key, data, "illegal line style (vlines)");
continue;
}
vector.layer[vec].linestyle = G_store(data);
continue;
}
if (KEY("linecap")) {
G_strip(data);
if (strcmp(data, "butt") == 0) {
vector.layer[vec].linecap = LINECAP_BUTT;
continue;
}
else if (strcmp(data, "round") == 0) {
vector.layer[vec].linecap = LINECAP_ROUND;
continue;
}
else if (strcmp(data, "extended_butt") == 0) {
vector.layer[vec].linecap = LINECAP_EXTBUTT;
continue;
}
else
error(key, data, "illegal line cap (vlines)");
continue;
}
if (KEY("width")) {
width = -1.;
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].width = width;
continue;
}
if (KEY("cwidth")) {
width = -1.;
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal cwidth (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].cwidth = width;
continue;
}
if (KEY("offset")) {
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1) {
width = 0.;
error(key, data, "illegal offset (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].offset = width;
continue;
}
if (KEY("coffset")) {
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1) {
width = 0.;
error(key, data, "illegal coffset (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].coffset = width;
continue;
}
if (KEY("hwidth")) {
width = -1.;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 0.;
error(key, data, "illegal hwidth (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].hwidth = width;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].color), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].color));
else
error(key, data, "illegal color request (vlines)");
continue;
}
if (KEY("rgbcolumn")) {
G_strip(data);
vector.layer[vec].rgbcol = G_store(data);
continue;
}
if (KEY("hcolor")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].hcolor), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].hcolor));
else
error(key, data, "illegal hcolor request (vlines)");
continue;
}
if (KEY("label")) { /* map legend label */
G_strip(data);
vector.layer[vec].label = G_store(data);
continue;
}
if (KEY("lpos")) {
if (sscanf(data, "%d", &itmp) < 1 || itmp < 0) {
itmp = -1;
error(key, data, "illegal lpos (vlines)");
continue;
}
vector.layer[vec].lpos = itmp;
continue;
}
if (KEY("ref")) {
G_strip(data);
if (strcmp(data, "left") == 0) {
vector.layer[vec].ref = LINE_REF_LEFT;
continue;
}
if (strcmp(data, "right") == 0) {
vector.layer[vec].ref = LINE_REF_RIGHT;
continue;
}
error(key, data, "illegal ref request (vlines)");
continue;
}
if (KEY("scale")) {
G_strip(data);
vector.layer[vec].scale = atof(data);
continue;
}
error(key, "", "illegal request (vlines)");
}
vector.count++;
return 1;
}
int main(int argc, char **argv)
{
char *mapset;
int ret, level;
int i, stat = 0, type, display;
int chcat = 0;
int r, g, b;
int has_color, has_fcolor;
struct color_rgb color, fcolor;
double size;
int default_width;
double width_scale;
int verbose = FALSE;
double minreg, maxreg, reg;
char map_name[128];
struct GModule *module;
struct Option *map_opt;
struct Option *color_opt, *fcolor_opt, *rgbcol_opt, *zcol_opt;
struct Option *type_opt, *display_opt;
struct Option *icon_opt, *size_opt, *sizecolumn_opt, *rotcolumn_opt;
struct Option *where_opt;
struct Option *field_opt, *cat_opt, *lfield_opt;
struct Option *lcolor_opt, *bgcolor_opt, *bcolor_opt;
struct Option *lsize_opt, *font_opt, *xref_opt, *yref_opt;
struct Option *attrcol_opt, *maxreg_opt, *minreg_opt;
struct Option *width_opt, *wcolumn_opt, *wscale_opt;
struct Option *render_opt;
struct Flag *verbose_flag; /* please remove before GRASS 7 released */
struct Flag *id_flag, *table_acolors_flag, *cats_acolors_flag, *x_flag,
*zcol_flag;
struct cat_list *Clist;
int *cats, ncat;
LATTR lattr;
struct Map_info Map;
struct field_info *fi;
dbDriver *driver;
dbHandle handle;
struct Cell_head window;
BOUND_BOX box;
double overlap;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("display, vector");
module->description = _("Displays user-specified vector map "
"in the active graphics frame.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
display_opt = G_define_option();
display_opt->key = "display";
display_opt->type = TYPE_STRING;
display_opt->required = YES;
display_opt->multiple = YES;
display_opt->answer = "shape";
display_opt->options = "shape,cat,topo,dir,attr,zcoor";
display_opt->description = _("Display");
display_opt->descriptions = _("shape;Display geometry of features;"
"cat;Display category numbers of features;"
"topo;Display topology information (nodes, edges);"
"dir;Display direction of linear features;"
"attr;Display selected attribute based on 'attrcol';"
"zcoor;Display z-coordinate of features (only for 3D vector maps)");
/* Query */
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->answer = "point,line,boundary,centroid,area,face";
type_opt->options = "point,line,boundary,centroid,area,face";
type_opt->guisection = _("Selection");
field_opt = G_define_standard_option(G_OPT_V_FIELD);
field_opt->label =
_("Layer number (if -1, all layers are displayed)");
field_opt->gisprompt = "old_layer,layer,layer_all";
field_opt->guisection = _("Selection");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_WHERE);
where_opt->guisection = _("Selection");
/* Colors */
color_opt = G_define_option();
color_opt->key = "color";
color_opt->type = TYPE_STRING;
color_opt->answer = DEFAULT_FG_COLOR;
color_opt->label = _("Feature color");
color_opt->guisection = _("Colors");
color_opt->gisprompt = "old_color,color,color_none";
color_opt->description =
_("Either a standard GRASS color, R:G:B triplet, or \"none\"");
fcolor_opt = G_define_option();
fcolor_opt->key = "fcolor";
fcolor_opt->type = TYPE_STRING;
fcolor_opt->answer = "200:200:200";
fcolor_opt->label = _("Area fill color");
fcolor_opt->guisection = _("Colors");
fcolor_opt->gisprompt = "old_color,color,color_none";
fcolor_opt->description =
_("Either a standard GRASS color, R:G:B triplet, or \"none\"");
rgbcol_opt = G_define_standard_option(G_OPT_COLUMN);
rgbcol_opt->key = "rgb_column";
rgbcol_opt->guisection = _("Colors");
rgbcol_opt->description = _("Name of color definition column (for use with -a flag)");
rgbcol_opt->answer = "GRASSRGB";
zcol_opt = G_define_option();
zcol_opt->key = "zcolor";
zcol_opt->key_desc = "style";
zcol_opt->type = TYPE_STRING;
zcol_opt->required = NO;
zcol_opt->description = _("Type of color table (for use with -z flag)");
zcol_opt->answer = "terrain";
zcol_opt->guisection = _("Colors");
/* Lines */
width_opt = G_define_option();
width_opt->key = "width";
width_opt->type = TYPE_INTEGER;
width_opt->answer = "0";
width_opt->guisection = _("Lines");
width_opt->description = _("Line width");
wcolumn_opt = G_define_standard_option(G_OPT_COLUMN);
wcolumn_opt->key = "wcolumn";
wcolumn_opt->guisection = _("Lines");
wcolumn_opt->description =
_("Name of column for line widths (these values will be scaled by wscale)");
wscale_opt = G_define_option();
wscale_opt->key = "wscale";
wscale_opt->type = TYPE_DOUBLE;
wscale_opt->answer = "1";
wscale_opt->guisection = _("Lines");
wscale_opt->description = _("Scale factor for wcolumn");
/* Symbols */
icon_opt = G_define_option();
icon_opt->key = "icon";
icon_opt->type = TYPE_STRING;
icon_opt->required = NO;
icon_opt->multiple = NO;
icon_opt->guisection = _("Symbols");
icon_opt->answer = "basic/x";
/* This could also use ->gisprompt = "old,symbol,symbol" instead of ->options */
icon_opt->options = icon_files();
icon_opt->description = _("Point and centroid symbol");
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->answer = "5";
size_opt->guisection = _("Symbols");
size_opt->label = _("Symbol size");
size_opt->description =
_("When used with the size_column option this becomes the scale factor");
sizecolumn_opt = G_define_standard_option(G_OPT_COLUMN);
sizecolumn_opt->key = "size_column";
sizecolumn_opt->guisection = _("Symbols");
sizecolumn_opt->description =
_("Name of numeric column containing symbol size");
rotcolumn_opt = G_define_standard_option(G_OPT_COLUMN);
rotcolumn_opt->key = "rot_column";
rotcolumn_opt->guisection = _("Symbols");
rotcolumn_opt->label =
_("Name of numeric column containing symbol rotation angle");
rotcolumn_opt->description =
_("Measured in degrees CCW from east");
/* Labels */
lfield_opt = G_define_standard_option(G_OPT_V_FIELD);
lfield_opt->key = "llayer";
lfield_opt->guisection = _("Labels");
lfield_opt->description =
_("Layer number for labels (default: the given layer number)");
attrcol_opt = G_define_standard_option(G_OPT_COLUMN);
attrcol_opt->key = "attrcol";
attrcol_opt->multiple = NO; /* or fix attr.c, around line 102 */
attrcol_opt->guisection = _("Labels");
attrcol_opt->description = _("Name of column to be displayed");
lcolor_opt = G_define_option();
lcolor_opt->key = "lcolor";
lcolor_opt->type = TYPE_STRING;
lcolor_opt->answer = "red";
lcolor_opt->label = _("Label color");
lcolor_opt->guisection = _("Labels");
lcolor_opt->gisprompt = "old_color,color,color";
lcolor_opt->description = _("Either a standard color name or R:G:B triplet");
bgcolor_opt = G_define_option();
bgcolor_opt->key = "bgcolor";
bgcolor_opt->type = TYPE_STRING;
bgcolor_opt->answer = "none";
bgcolor_opt->guisection = _("Labels");
bgcolor_opt->label = _("Label background color");
bgcolor_opt->gisprompt = "old_color,color,color_none";
bgcolor_opt->description =
_("Either a standard GRASS color, R:G:B triplet, or \"none\"");
bcolor_opt = G_define_option();
bcolor_opt->key = "bcolor";
bcolor_opt->type = TYPE_STRING;
bcolor_opt->answer = "none";
bcolor_opt->guisection = _("Labels");
bcolor_opt->label = _("Label border color");
bcolor_opt->gisprompt = "old_color,color,color_none";
bcolor_opt->description =
_("Either a standard GRASS color, R:G:B triplet, or \"none\"");
lsize_opt = G_define_option();
lsize_opt->key = "lsize";
lsize_opt->type = TYPE_INTEGER;
lsize_opt->answer = "8";
lsize_opt->guisection = _("Labels");
lsize_opt->description = _("Label size (pixels)");
font_opt = G_define_option();
font_opt->key = "font";
font_opt->type = TYPE_STRING;
font_opt->guisection = _("Labels");
font_opt->description = _("Font name");
xref_opt = G_define_option();
xref_opt->key = "xref";
xref_opt->type = TYPE_STRING;
xref_opt->guisection = _("Labels");
xref_opt->answer = "left";
xref_opt->options = "left,center,right";
xref_opt->description = _("Label horizontal justification");
yref_opt = G_define_option();
yref_opt->key = "yref";
yref_opt->type = TYPE_STRING;
yref_opt->guisection = _("Labels");
yref_opt->answer = "center";
yref_opt->options = "top,center,bottom";
yref_opt->description = _("Label vertical justification");
minreg_opt = G_define_option();
minreg_opt->key = "minreg";
minreg_opt->type = TYPE_DOUBLE;
minreg_opt->required = NO;
minreg_opt->description =
_("Minimum region size (average from height and width) "
"when map is displayed");
maxreg_opt = G_define_option();
maxreg_opt->key = "maxreg";
maxreg_opt->type = TYPE_DOUBLE;
maxreg_opt->required = NO;
maxreg_opt->description =
_("Maximum region size (average from height and width) "
"when map is displayed");
render_opt = G_define_option();
render_opt->key = "render";
render_opt->type = TYPE_STRING;
render_opt->required = NO;
render_opt->multiple = NO;
render_opt->answer = "c";
render_opt->options = "g,r,d,c,l";
render_opt->description = _("Rendering method for filled polygons");
render_opt->descriptions =
_("g;use the libgis render functions (features: clipping);"
"r;use the raster graphics library functions (features: polylines);"
"d;use the display library basic functions (features: polylines);"
"c;use the display library clipping functions (features: clipping);"
"l;use the display library culling functions (features: culling, polylines)");
/* please remove before GRASS 7 released */
verbose_flag = G_define_flag();
verbose_flag->key = 'v';
verbose_flag->description = _("Run verbosely");
/* Colors */
table_acolors_flag = G_define_flag();
table_acolors_flag->key = 'a';
table_acolors_flag->guisection = _("Colors");
table_acolors_flag->description =
_("Get colors from map table column (of form RRR:GGG:BBB)");
cats_acolors_flag = G_define_flag();
cats_acolors_flag->key = 'c';
cats_acolors_flag->guisection = _("Colors");
cats_acolors_flag->description =
_("Random colors according to category number "
"(or layer number if 'layer=-1' is given)");
/* Query */
id_flag = G_define_flag();
id_flag->key = 'i';
id_flag->guisection = _("Selection");
id_flag->description = _("Use values from 'cats' option as feature id");
x_flag = G_define_flag();
x_flag->key = 'x';
x_flag->description =
_("Don't add to list of vectors and commands in monitor "
"(it won't be drawn if the monitor is refreshed)");
zcol_flag = G_define_flag();
zcol_flag->key = 'z';
zcol_flag->description = _("Colorize polygons according to z height");
zcol_flag->guisection = _("Colors");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (G_strcasecmp(render_opt->answer, "g") == 0)
render = RENDER_GPP;
else if (G_strcasecmp(render_opt->answer, "r") == 0)
render = RENDER_RPA;
else if (G_strcasecmp(render_opt->answer, "d") == 0)
render = RENDER_DP;
else if (G_strcasecmp(render_opt->answer, "c") == 0)
render = RENDER_DPC;
else if (G_strcasecmp(render_opt->answer, "l") == 0)
render = RENDER_DPL;
else
render = RENDER_GPP;
/* please remove -v flag before GRASS 7 released */
if (verbose_flag->answer) {
G_putenv("GRASS_VERBOSE", "3");
G_warning(_("The '-v' flag is superseded and will be removed "
"in future. Please use '--verbose' instead."));
}
/* but keep this */
if (G_verbose() > G_verbose_std())
verbose = TRUE;
G_get_set_window(&window);
if (R_open_driver() != 0)
G_fatal_error(_("No graphics device selected"));
/* Read map options */
/* Check min/max region */
reg = ((window.east - window.west) + (window.north - window.south)) / 2;
if (minreg_opt->answer) {
minreg = atof(minreg_opt->answer);
if (reg < minreg) {
G_message(_("Region size is lower than minreg, nothing displayed."));
D_add_to_list(G_recreate_command());
exit(EXIT_SUCCESS);
}
}
if (maxreg_opt->answer) {
maxreg = atof(maxreg_opt->answer);
if (reg > maxreg) {
G_message(_("Region size is greater than maxreg, nothing displayed."));
D_add_to_list(G_recreate_command());
exit(EXIT_SUCCESS);
}
}
G_strcpy(map_name, map_opt->answer);
default_width = atoi(width_opt->answer);
if (default_width < 0)
default_width = 0;
width_scale = atof(wscale_opt->answer);
if (table_acolors_flag->answer && cats_acolors_flag->answer) {
cats_acolors_flag->answer = '\0';
G_warning(_("The '-c' and '-a' flags cannot be used together, "
"the '-c' flag will be ignored!"));
}
color = G_standard_color_rgb(WHITE);
ret = G_str_to_color(color_opt->answer, &r, &g, &b);
if (ret == 1) {
has_color = 1;
color.r = r;
color.g = g;
color.b = b;
}
else if (ret == 2) { /* none */
has_color = 0;
}
else if (ret == 0) { /* error */
G_fatal_error(_("Unknown color: [%s]"), color_opt->answer);
}
fcolor = G_standard_color_rgb(WHITE);
ret = G_str_to_color(fcolor_opt->answer, &r, &g, &b);
if (ret == 1) {
has_fcolor = 1;
fcolor.r = r;
fcolor.g = g;
fcolor.b = b;
}
else if (ret == 2) { /* none */
has_fcolor = 0;
}
else if (ret == 0) { /* error */
G_fatal_error(_("Unknown color: '%s'"), fcolor_opt->answer);
}
size = atof(size_opt->answer);
/* Make sure map is available */
mapset = G_find_vector2(map_name, "");
if (mapset == NULL)
G_fatal_error(_("Vector map <%s> not found"), map_name);
/* if where_opt was specified select categories from db
* otherwise parse cat_opt */
Clist = Vect_new_cat_list();
Clist->field = atoi(field_opt->answer);
/* open vector */
level = Vect_open_old(&Map, map_name, mapset);
if (where_opt->answer) {
if (Clist->field < 1)
G_fatal_error(_("'layer' must be > 0 for 'where'."));
chcat = 1;
if ((fi = Vect_get_field(&Map, Clist->field)) == NULL)
G_fatal_error(_("Database connection not defined"));
if (fi != NULL) {
driver = db_start_driver(fi->driver);
if (driver == NULL)
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>"),
fi->database);
ncat =
db_select_int(driver, fi->table, fi->key, where_opt->answer,
&cats);
db_close_database(driver);
db_shutdown_driver(driver);
Vect_array_to_cat_list(cats, ncat, Clist);
}
}
else if (cat_opt->answer) {
if (Clist->field < 1)
G_fatal_error(_("'layer' must be > 0 for 'cats'."));
chcat = 1;
ret = Vect_str_to_cat_list(cat_opt->answer, Clist);
if (ret > 0)
G_warning(_("%d errors in cat option"), ret);
}
type = Vect_option_to_types(type_opt);
i = 0;
display = 0;
while (display_opt->answers[i]) {
switch (display_opt->answers[i][0]) {
case 's':
display |= DISP_SHAPE;
break;
case 'c':
display |= DISP_CAT;
break;
case 't':
display |= DISP_TOPO;
break;
case 'd':
display |= DISP_DIR;
break;
case 'a':
display |= DISP_ATTR;
break;
case 'z':
display |= DISP_ZCOOR;
break;
}
i++;
}
/* Read label options */
if (lfield_opt->answer != NULL)
lattr.field = atoi(lfield_opt->answer);
else
lattr.field = Clist->field;
lattr.color.R = lattr.color.G = lattr.color.B = 255;
if (G_str_to_color(lcolor_opt->answer, &r, &g, &b)) {
lattr.color.R = r;
lattr.color.G = g;
lattr.color.B = b;
}
lattr.has_bgcolor = 0;
if (G_str_to_color(bgcolor_opt->answer, &r, &g, &b) == 1) {
lattr.has_bgcolor = 1;
lattr.bgcolor.R = r;
lattr.bgcolor.G = g;
lattr.bgcolor.B = b;
}
lattr.has_bcolor = 0;
if (G_str_to_color(bcolor_opt->answer, &r, &g, &b) == 1) {
lattr.has_bcolor = 1;
lattr.bcolor.R = r;
lattr.bcolor.G = g;
lattr.bcolor.B = b;
}
lattr.size = atoi(lsize_opt->answer);
lattr.font = font_opt->answer;
switch (xref_opt->answer[0]) {
case 'l':
lattr.xref = LLEFT;
break;
case 'c':
lattr.xref = LCENTER;
break;
case 'r':
lattr.xref = LRIGHT;
break;
}
switch (yref_opt->answer[0]) {
case 't':
lattr.yref = LTOP;
break;
case 'c':
lattr.yref = LCENTER;
break;
case 'b':
lattr.yref = LBOTTOM;
break;
}
D_setup(0);
G_setup_plot(D_get_d_north(), D_get_d_south(),
D_get_d_west(), D_get_d_east(), D_move_abs, D_cont_abs);
if (verbose)
G_message(_("Plotting ..."));
if (level >= 2)
Vect_get_map_box(&Map, &box);
if (level >= 2 && (window.north < box.S || window.south > box.N ||
window.east < box.W ||
window.west > G_adjust_easting(box.E, &window))) {
G_message(_("The bounding box of the map is outside the current region, "
"nothing drawn."));
stat = 0;
}
else {
overlap =
G_window_percentage_overlap(&window, box.N, box.S, box.E, box.W);
G_debug(1, "overlap = %f \n", overlap);
if (overlap < 1)
Vect_set_constraint_region(&Map, window.north, window.south,
window.east, window.west,
PORT_DOUBLE_MAX, -PORT_DOUBLE_MAX);
/* default line width */
if (!wcolumn_opt->answer)
D_line_width(default_width);
if (type & GV_AREA) {
if (level >= 2) {
if (display & DISP_SHAPE) {
stat = darea(&Map, Clist,
has_color ? &color : NULL,
has_fcolor ? &fcolor : NULL, chcat,
(int)id_flag->answer,
table_acolors_flag->answer,
cats_acolors_flag->answer, &window,
rgbcol_opt->answer, default_width,
wcolumn_opt->answer, width_scale,
zcol_flag->answer, zcol_opt->answer);
}
if (wcolumn_opt->answer)
D_line_width(default_width);
}
else
G_warning(_("Unable to display areas, topology not available"));
}
if (display & DISP_SHAPE) {
if (id_flag->answer && level < 2) {
G_warning(_("Unable to display lines by id, topology not available"));
}
else {
stat = plot1(&Map, type, Clist,
has_color ? &color : NULL,
has_fcolor ? &fcolor : NULL, chcat, icon_opt->answer,
size, sizecolumn_opt->answer, rotcolumn_opt->answer,
(int)id_flag->answer, table_acolors_flag->answer,
cats_acolors_flag->answer, rgbcol_opt->answer,
default_width, wcolumn_opt->answer, width_scale,
zcol_flag->answer, zcol_opt->answer);
if (wcolumn_opt->answer)
D_line_width(default_width);
}
}
if (has_color) {
R_RGB_color(color.r, color.g, color.b);
if (display & DISP_DIR)
stat = dir(&Map, type, Clist, chcat, size);
}
/* reset line width: Do we need to get line width from display
* driver (not implemented)? It will help restore previous line
* width (not just 0) determined by another module (e.g.,
* d.linewidth). */
if (!wcolumn_opt->answer)
R_line_width(0);
if (display & DISP_CAT)
stat = label(&Map, type, Clist, &lattr, chcat);
if (display & DISP_ATTR)
stat =
attr(&Map, type, attrcol_opt->answer, Clist, &lattr, chcat);
if (display & DISP_ZCOOR)
stat = zcoor(&Map, type, &lattr);
if (display & DISP_TOPO) {
if (level >= 2)
stat = topo(&Map, type, &lattr);
else
G_warning(_("Unable to display topology, not available"));
}
}
if (!x_flag->answer) {
D_add_to_list(G_recreate_command());
D_set_dig_name(G_fully_qualified_name(map_name, mapset));
D_add_to_dig_list(G_fully_qualified_name(map_name, mapset));
}
R_close_driver();
if (verbose)
G_done_msg(" ");
Vect_close(&Map);
Vect_destroy_cat_list(Clist);
exit(stat);
}
