int main(int argc, char **argv)
{
struct Cell_head window;
RASTER_MAP_TYPE raster_type, mag_raster_type = -1;
int layer_fd;
void *raster_row, *ptr;
int nrows, ncols;
int aspect_c = -1;
float aspect_f = -1.0;
double scale;
int skip, no_arrow;
char *mag_map = NULL;
void *mag_raster_row = NULL, *mag_ptr = NULL;
double length = -1;
int mag_fd = -1;
struct FPRange range;
double mag_min, mag_max;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *opt5,
*opt6, *opt7, *opt8, *opt9;
struct Flag *align;
double t, b, l, r;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("raster"));
module->description =
_("Draws arrows representing cell aspect direction "
"for a raster map containing aspect data.");
opt1 = G_define_standard_option(G_OPT_R_MAP);
opt1->description = _("Name of raster aspect map to be displayed");
opt2 = G_define_option();
opt2->key = "type";
opt2->type = TYPE_STRING;
opt2->required = NO;
opt2->answer = "grass";
opt2->options = "grass,compass,agnps,answers";
opt2->description = _("Type of existing raster aspect map");
opt3 = G_define_option();
opt3->key = "arrow_color";
opt3->type = TYPE_STRING;
opt3->required = NO;
opt3->answer = "green";
opt3->gisprompt = "old_color,color,color";
opt3->description = _("Color for drawing arrows");
opt3->guisection = _("Colors");
opt4 = G_define_option();
opt4->key = "grid_color";
opt4->type = TYPE_STRING;
opt4->required = NO;
opt4->answer = "gray";
opt4->gisprompt = "old_color,color,color_none";
opt4->description = _("Color for drawing grid or \"none\"");
opt4->guisection = _("Colors");
opt5 = G_define_option();
opt5->key = "x_color";
opt5->type = TYPE_STRING;
opt5->required = NO;
opt5->answer = DEFAULT_FG_COLOR;
opt5->gisprompt = "old_color,color,color_none";
opt5->description = _("Color for drawing X's (null values)");
opt5->guisection = _("Colors");
opt6 = G_define_option();
opt6->key = "unknown_color";
opt6->type = TYPE_STRING;
opt6->required = NO;
opt6->answer = "red";
opt6->gisprompt = "old_color,color,color_none";
opt6->description = _("Color for showing unknown information");
opt6->guisection = _("Colors");
opt9 = G_define_option();
opt9->key = "skip";
opt9->type = TYPE_INTEGER;
opt9->required = NO;
opt9->answer = "1";
opt9->description = _("Draw arrow every Nth grid cell");
opt7 = G_define_option();
opt7->key = "magnitude_map";
opt7->type = TYPE_STRING;
opt7->required = NO;
opt7->multiple = NO;
opt7->gisprompt = "old,cell,raster";
opt7->description =
_("Raster map containing values used for arrow length");
opt8 = G_define_option();
opt8->key = "scale";
opt8->type = TYPE_DOUBLE;
opt8->required = NO;
opt8->answer = "1.0";
opt8->description = _("Scale factor for arrows (magnitude map)");
align = G_define_flag();
align->key = 'a';
align->description = _("Align grids with raster cells");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
layer_name = opt1->answer;
arrow_color = D_translate_color(opt3->answer);
x_color = D_translate_color(opt5->answer);
unknown_color = D_translate_color(opt6->answer);
if (strcmp("none", opt4->answer) == 0)
grid_color = -1;
else
grid_color = D_translate_color(opt4->answer);
if (strcmp("grass", opt2->answer) == 0)
map_type = 1;
else if (strcmp("agnps", opt2->answer) == 0)
map_type = 2;
else if (strcmp("answers", opt2->answer) == 0)
map_type = 3;
else if (strcmp("compass", opt2->answer) == 0)
map_type = 4;
scale = atof(opt8->answer);
if (scale <= 0.0)
G_fatal_error(_("Illegal value for scale factor"));
skip = atoi(opt9->answer);
if (skip <= 0)
G_fatal_error(_("Illegal value for skip factor"));
if (opt7->answer) {
if (map_type != 1 && map_type != 4)
G_fatal_error(_("Magnitude is only supported for GRASS and compass aspect maps."));
mag_map = opt7->answer;
}
else if (scale != 1.0)
G_warning(_("Scale option requires magnitude_map"));
/* Setup driver and check important information */
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
D_setup(0);
/* Read in the map window associated with window */
G_get_window(&window);
if (align->answer) {
struct Cell_head wind;
Rast_get_cellhd(layer_name, "", &wind);
/* expand window extent by one wind resolution */
wind.west += wind.ew_res * ((int)((window.west - wind.west) / wind.ew_res) - (window.west < wind.west));
wind.east += wind.ew_res * ((int)((window.east - wind.east) / wind.ew_res) + (window.east > wind.east));
wind.south += wind.ns_res * ((int)((window.south - wind.south) / wind.ns_res) - (window.south < wind.south));
wind.north += wind.ns_res * ((int)((window.north - wind.north) / wind.ns_res) + (window.north > wind.north));
wind.rows = (wind.north - wind.south) / wind.ns_res;
wind.cols = (wind.east - wind.west) / wind.ew_res;
Rast_set_window(&wind);
nrows = wind.rows;
ncols = wind.cols;
t = (wind.north - window.north) * nrows / (wind.north - wind.south);
b = t + (window.north - window.south) * nrows / (wind.north - wind.south);
l = (window.west - wind.west) * ncols / (wind.east - wind.west);
r = l + (window.east - window.west) * ncols / (wind.east - wind.west);
} else {
nrows = window.rows;
ncols = window.cols;
t = 0;
b = nrows;
l = 0;
r = ncols;
}
D_set_src(t, b, l, r);
D_update_conversions();
/* figure out arrow scaling if using a magnitude map */
if (opt7->answer) {
Rast_init_fp_range(&range); /* really needed? */
if (Rast_read_fp_range(mag_map, "", &range) != 1)
G_fatal_error(_("Problem reading range file"));
Rast_get_fp_range_min_max(&range, &mag_min, &mag_max);
scale *= 1.5 / fabs(mag_max);
G_debug(3, "scaling=%.2f rast_max=%.2f", scale, mag_max);
}
if (grid_color > 0) { /* ie not "none" */
/* Set color */
D_use_color(grid_color);
/* Draw vertical grids */
for (col = 0; col < ncols; col++)
D_line_abs(col, 0, col, nrows);
/* Draw horizontal grids */
for (row = 0; row < nrows; row++)
D_line_abs(0, row, ncols, row);
}
/* open the raster map */
layer_fd = Rast_open_old(layer_name, "");
raster_type = Rast_get_map_type(layer_fd);
/* allocate the cell array */
raster_row = Rast_allocate_buf(raster_type);
if (opt7->answer) {
/* open the magnitude raster map */
mag_fd = Rast_open_old(mag_map, "");
mag_raster_type = Rast_get_map_type(mag_fd);
/* allocate the cell array */
mag_raster_row = Rast_allocate_buf(mag_raster_type);
}
/* loop through cells, find value, determine direction (n,s,e,w,ne,se,sw,nw),
and call appropriate function to draw an arrow on the cell */
for (row = 0; row < nrows; row++) {
Rast_get_row(layer_fd, raster_row, row, raster_type);
ptr = raster_row;
if (opt7->answer) {
Rast_get_row(mag_fd, mag_raster_row, row, mag_raster_type);
mag_ptr = mag_raster_row;
}
for (col = 0; col < ncols; col++) {
if (row % skip != 0)
no_arrow = TRUE;
else
no_arrow = FALSE;
if (col % skip != 0)
no_arrow = TRUE;
/* find aspect direction based on cell value */
if (raster_type == CELL_TYPE)
aspect_f = *((CELL *) ptr);
else if (raster_type == FCELL_TYPE)
aspect_f = *((FCELL *) ptr);
else if (raster_type == DCELL_TYPE)
aspect_f = *((DCELL *) ptr);
if (opt7->answer) {
if (mag_raster_type == CELL_TYPE)
length = *((CELL *) mag_ptr);
else if (mag_raster_type == FCELL_TYPE)
length = *((FCELL *) mag_ptr);
else if (mag_raster_type == DCELL_TYPE)
length = *((DCELL *) mag_ptr);
length *= scale;
if (Rast_is_null_value(mag_ptr, mag_raster_type)) {
G_debug(5, "Invalid arrow length [NULL]. Skipping.");
no_arrow = TRUE;
}
else if (length <= 0.0) { /* use fabs() or theta+=180? */
G_debug(5, "Illegal arrow length [%.3f]. Skipping.",
length);
no_arrow = TRUE;
}
}
if (no_arrow) {
ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type));
if (opt7->answer)
mag_ptr =
G_incr_void_ptr(mag_ptr,
Rast_cell_size(mag_raster_type));
no_arrow = FALSE;
continue;
}
/* treat AGNPS and ANSWERS data like old zero-as-null CELL */
/* TODO: update models */
if (map_type == 2 || map_type == 3) {
if (Rast_is_null_value(ptr, raster_type))
aspect_c = 0;
else
aspect_c = (int)(aspect_f + 0.5);
}
/** Now draw the arrows **/
/* case switch for standard GRASS aspect map
measured in degrees counter-clockwise from east */
if (map_type == 1) {
D_use_color(arrow_color);
if (Rast_is_null_value(ptr, raster_type)) {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
else if (aspect_f >= 0.0 && aspect_f <= 360.0) {
if (opt7->answer)
arrow_mag(aspect_f, length);
else
arrow_360(aspect_f);
}
else {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
}
/* case switch for AGNPS type aspect map */
else if (map_type == 2) {
D_use_color(arrow_color);
switch (aspect_c) {
case 0:
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
break;
case 1:
arrow_n();
break;
case 2:
arrow_ne();
break;
case 3:
arrow_e();
break;
case 4:
arrow_se();
break;
case 5:
arrow_s();
break;
case 6:
arrow_sw();
break;
case 7:
arrow_w();
break;
case 8:
arrow_nw();
break;
default:
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
break;
}
}
/* case switch for ANSWERS type aspect map */
else if (map_type == 3) {
D_use_color(arrow_color);
if (aspect_c >= 15 && aspect_c <= 360) /* start at zero? */
arrow_360((double)aspect_c);
else if (aspect_c == 400) {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
else {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
}
/* case switch for compass type aspect map
measured in degrees clockwise from north */
else if (map_type == 4) {
D_use_color(arrow_color);
if (Rast_is_null_value(ptr, raster_type)) {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
else if (aspect_f >= 0.0 && aspect_f <= 360.0) {
if (opt7->answer)
arrow_mag(90 - aspect_f, length);
else
arrow_360(90 - aspect_f);
}
else {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
}
ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type));
if (opt7->answer)
mag_ptr =
G_incr_void_ptr(mag_ptr, Rast_cell_size(mag_raster_type));
}
}
Rast_close(layer_fd);
if (opt7->answer)
Rast_close(mag_fd);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct
{
struct Option *text;
struct Option *size;
struct Option *fgcolor;
struct Option *bgcolor;
struct Option *line;
struct Option *at;
struct Option *rotation;
struct Option *align;
struct Option *linespacing;
struct Option *font;
struct Option *path;
struct Option *charset;
struct Option *input;
} opt;
struct
{
struct Flag *p;
struct Flag *g;
struct Flag *b;
struct Flag *r;
struct Flag *s;
} flag;
/* options and flags */
char *text;
double size;
double x, y;
int line;
double rotation;
char align[3];
double linespacing;
char bold;
/* window info */
struct rectinfo win;
/* command file */
FILE *cmd_fp;
char buf[512];
int first_text;
int linefeed;
int set_l;
double orig_x, orig_y;
double prev_x, prev_y;
double set_x, set_y;
double east, north;
int do_background, fg_color, bg_color;
/* initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description =
_("Draws text in the active display frame on the graphics monitor using the current font.");
opt.text = G_define_option();
opt.text->key = "text";
opt.text->type = TYPE_STRING;
opt.text->required = NO;
opt.text->description = _("Text to display");
opt.text->guisection = _("Input");
opt.input = G_define_standard_option(G_OPT_F_INPUT);
opt.input->required = NO;
opt.input->description = _("Input file");
opt.input->guisection = _("Input");
opt.fgcolor = G_define_option();
opt.fgcolor->key = "color";
opt.fgcolor->type = TYPE_STRING;
opt.fgcolor->answer = DEFAULT_COLOR;
opt.fgcolor->required = NO;
opt.fgcolor->description =
_("Text color, either a standard GRASS color or R:G:B triplet");
opt.fgcolor->gisprompt = "old_color,color,color";
opt.fgcolor->guisection = _("Text");
opt.bgcolor = G_define_option();
opt.bgcolor->key = "bgcolor";
opt.bgcolor->type = TYPE_STRING;
opt.bgcolor->required = NO;
opt.bgcolor->description =
_("Text background color, either a standard GRASS color or R:G:B triplet");
opt.bgcolor->gisprompt = "old_color,color,color";
opt.bgcolor->guisection = _("Text");
opt.rotation = G_define_option();
opt.rotation->key = "rotation";
opt.rotation->type = TYPE_DOUBLE;
opt.rotation->required = NO;
opt.rotation->answer = "0";
opt.rotation->description =
_("Rotation angle in degrees (counter-clockwise)");
opt.rotation->guisection = _("Text");
opt.linespacing = G_define_option();
opt.linespacing->key = "linespacing";
opt.linespacing->type = TYPE_DOUBLE;
opt.linespacing->required = NO;
opt.linespacing->answer = "1.25";
opt.linespacing->description = _("Line spacing");
opt.linespacing->guisection = _("Text");
opt.at = G_define_option();
opt.at->key = "at";
opt.at->key_desc = "x,y";
opt.at->type = TYPE_DOUBLE;
opt.at->required = NO;
opt.at->description =
_("Screen position at which text will begin to be drawn (percentage, [0,0] is lower left)");
opt.at->guisection = _("Position");
opt.line = G_define_option();
opt.line->key = "line";
opt.line->required = NO;
opt.line->type = TYPE_INTEGER;
opt.line->options = "1-1000";
opt.line->description =
_("The screen line number on which text will begin to be drawn");
opt.line->guisection = _("Position");
opt.align = G_define_option();
opt.align->key = "align";
opt.align->type = TYPE_STRING;
opt.align->required = NO;
opt.align->answer = "ll";
opt.align->options = "ll,lc,lr,cl,cc,cr,ul,uc,ur";
opt.align->description = _("Text alignment");
opt.align->guisection = _("Position");
opt.font = G_define_option();
opt.font->key = "font";
opt.font->type = TYPE_STRING;
opt.font->required = NO;
opt.font->description = _("Font name");
opt.font->guisection = _("Font settings");
opt.size = G_define_option();
opt.size->key = "size";
opt.size->type = TYPE_DOUBLE;
opt.size->required = NO;
opt.size->answer = "5";
opt.size->options = "0-100";
opt.size->description =
_("Height of letters in percentage of available frame height");
opt.size->guisection = _("Font settings");
opt.path = G_define_standard_option(G_OPT_F_INPUT);
opt.path->key = "path";
opt.path->required = NO;
opt.path->description = _("Path to font file");
opt.path->gisprompt = "old,font,file";
opt.path->guisection = _("Font settings");
opt.charset = G_define_option();
opt.charset->key = "charset";
opt.charset->type = TYPE_STRING;
opt.charset->required = NO;
opt.charset->description =
_("Text encoding (only applicable to TrueType fonts)");
opt.charset->guisection = _("Font settings");
flag.p = G_define_flag();
flag.p->key = 'p';
flag.p->description = _("Screen position in pixels ([0,0] is top left)");
flag.p->guisection = _("Position");
flag.g = G_define_flag();
flag.g->key = 'g';
flag.g->description = _("Screen position in geographic coordinates");
flag.g->guisection = _("Position");
flag.b = G_define_flag();
flag.b->key = 'b';
flag.b->description = _("Use bold text");
flag.b->guisection = _("Text");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description = _("Use radians instead of degrees for rotation");
flag.r->guisection = _("Text");
flag.s = G_define_flag();
flag.s->key = 's';
flag.s->description = _("Font size is height in pixels");
flag.s->guisection = _("Font settings");
/* check command line */
if (G_parser(argc, argv))
exit(1);
/* parse and check options and flags */
if ((opt.line->answer && opt.at->answer) ||
(flag.p->answer && flag.g->answer))
G_fatal_error(_("Please choose only one placement method"));
text = opt.text->answer;
line = (opt.line->answer ? atoi(opt.line->answer) : 1);
/* calculate rotation angle in radian */
rotation = atof(opt.rotation->answer);
if (!flag.r->answer)
rotation *= M_PI / 180.0;
rotation = fmod(rotation, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
strncpy(align, opt.align->answer, 2);
linespacing = atof(opt.linespacing->answer);
bold = flag.b->answer;
D_open_driver();
if (opt.font->answer)
D_font(opt.font->answer);
else if (opt.path->answer)
D_font(opt.path->answer);
if (opt.charset->answer)
D_encoding(opt.charset->answer);
D_setup_unity(0);
/* figure out where to put text */
D_get_src(&win.t, &win.b, &win.l, &win.r);
if (flag.s->answer)
size = atof(opt.size->answer);
else
#ifdef BACKWARD_COMPATIBILITY
size = atof(opt.size->answer) / 100.0 * (win.b - win.t) / linespacing;
#else
size = atof(opt.size->answer) / 100.0 * (win.b - win.t);
#endif
fg_color = D_parse_color(opt.fgcolor->answer, TRUE);
if (opt.bgcolor->answer) {
do_background = 1;
bg_color = D_parse_color(opt.bgcolor->answer, TRUE);
if (bg_color == 0) /* ie color="none" */
do_background = 0;
} else
do_background = 0;
set_color(opt.fgcolor->answer);
orig_x = orig_y = 0;
if (opt.at->answer) {
if (get_coordinates(&x, &y, &east, &north,
win, opt.at->answers,
flag.p->answer, flag.g->answer))
G_fatal_error(_("Invalid coordinates"));
orig_x = x;
orig_y = y;
}
else {
x = win.l + (size * linespacing + 0.5) - size; /* d.text: +5 */
y = win.t + line * (size * linespacing + 0.5);
}
prev_x = x;
prev_y = y;
D_text_size(size, size);
D_text_rotation(rotation * 180.0 / M_PI);
if (text) {
double x2, y2;
x2 = x;
y2 = y;
if (text[0])
draw_text(text, &x2, &y2, size, align, rotation, bold, do_background, fg_color, bg_color);
/* reset */
D_text_size(5, 5);
D_text_rotation(0.0);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
if (!opt.input->answer || strcmp(opt.input->answer, "-") == 0)
cmd_fp = stdin;
else {
cmd_fp = fopen(opt.input->answer, "r");
if (!cmd_fp)
G_fatal_error(_("Unable to open input file <%s>"), opt.input->answer);
}
if (isatty(fileno(cmd_fp)))
fprintf(stderr,
_("\nPlease enter text instructions. Enter EOF (ctrl-d) on last line to quit\n"));
set_x = set_y = set_l = 0;
first_text = 1;
linefeed = 1;
/* do the plotting */
while (fgets(buf, sizeof(buf), cmd_fp)) {
int buf_len;
char *buf_ptr, *ptr;
buf_len = strlen(buf) - 1;
for (; buf[buf_len] == '\r' || buf[buf_len] == '\n'; buf_len--) ;
buf[buf_len + 1] = 0;
if (buf[0] == '.' && buf[1] != '.') {
int i;
double d;
G_squeeze(buf); /* added 6/91 DBS @ CWU */
for (buf_ptr = buf + 2; *buf_ptr == ' '; buf_ptr++) ;
buf_len = strlen(buf_ptr);
switch (buf[1] & 0x7f) {
case 'F':
/* font */
if ((ptr = strchr(buf_ptr, ':')))
*ptr = 0;
D_font(buf_ptr);
if (ptr)
D_encoding(ptr + 1);
break;
case 'C':
/* color */
set_color(buf_ptr);
fg_color = D_parse_color(buf_ptr, 1);
break;
case 'G':
/* background color */
bg_color = D_parse_color(buf_ptr, 1);
do_background = 1;
break;
case 'S':
/* size */
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] != 'p')
#ifdef BACKWARD_COMPATIBILITY
d *= (win.b - win.t) / 100.0 / linespacing;
#else
d *= (win.b - win.t) / 100.0;
#endif
size = d + (i ? size : 0);
D_text_size(size, size);
break;
case 'B':
/* bold */
bold = (atoi(buf_ptr) ? 1 : 0);
break;
case 'A':
/* align */
strncpy(align, buf_ptr, 2);
break;
case 'R':
/* rotation */
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] != 'r')
d *= M_PI / 180.0;
d += (i ? rotation : 0.0);
rotation = fmod(d, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
D_text_rotation(rotation * 180.0 / M_PI);
break;
case 'I':
/* linespacing */
linespacing = atof(buf_ptr);
break;
case 'X':
/* x */
set_l = 0;
set_x = 1;
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
/* percentage */
d *= (win.r - win.l) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
/* column */
d = (d - 1) * size * linespacing + 0.5;
x = prev_x = d + (i ? x : orig_x);
break;
case 'Y':
/* y */
set_l = 0;
set_y = 1;
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
/* percentage */
d = win.b - d * (win.b - win.t) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
/* row */
d *= size * linespacing + 0.5;
y = prev_y = d + (i ? y : orig_y);
break;
case 'L':
/* linefeed */
set_l = 1;
linefeed = (atoi(buf_ptr) ? 1 : 0);
break;
case 'E':
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
d *= (win.r - win.l) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
d = D_u_to_d_col(d);
x = prev_x = orig_x = d + (i ? orig_x : win.l);
break;
case 'N':
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
d *= (win.b - win.t) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
d = D_u_to_d_row(d);
y = prev_y = orig_y = d + (i ? orig_y : win.t);
break;
}
}
else {
buf_ptr = buf;
if (buf[0] == '.' && buf[1] == '.')
buf_ptr++;
if (!first_text && (linefeed || set_l)) {
/* if x is not given, increment x */
if (!set_x)
x = prev_x +
(size * linespacing + 0.5) * sin(rotation);
/* if y is not given, increment y */
if (!set_y)
y = prev_y +
(size * linespacing + 0.5) * cos(rotation);
prev_x = x;
prev_y = y;
}
set_x = set_y = set_l = first_text = 0;
draw_text(buf_ptr, &x, &y, size, align, rotation, bold, do_background, fg_color, bg_color);
}
}
if (cmd_fp != stdin)
fclose(cmd_fp);
/* reset */
D_text_size(5, 5);
D_text_rotation(0.0);
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *bg_color_opt, *fg_color_opt, *coords, *n_arrow, *fsize,
*width_opt, *rotation_opt, *lbl_opt;
struct Flag *no_text, *rotate_text, *rads;
double east, north;
double rotation;
double fontsize, line_width;
int rot_with_text;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description =
_("Displays a north arrow on the graphics monitor.");
n_arrow = G_define_option();
n_arrow->key = "style";
n_arrow->description = _("North arrow style");
n_arrow->options =
"1a,1b,2,3,4,5,6,7a,7b,8a,8b,9,fancy_compass,basic_compass,arrow1,arrow2,arrow3,star";
G_asprintf((char **)&(n_arrow->descriptions),
"1a;%s;" "1b;%s;" "2;%s;" "3;%s;" "4;%s;" "5;%s;" "6;%s;"
"7a;%s;" "7b;%s;" "8a;%s;" "8b;%s;" "9;%s;" "fancy_compass;%s;"
"basic_compass;%s;" "arrow1;%s;" "arrow2;%s;" "arrow3;%s;"
"star;%s;",
_("Two color arrowhead"),
_("Two color arrowhead with circle"),
_("Narrow with blending N"), _("Long with small arrowhead"),
_("Inverted narrow inside a circle"),
_("Triangle and N inside a circle"),
_("Arrowhead and N inside a circle"),
_("Tall half convex arrowhead"),
_("Tall half concave arrowhead"), _("Thin arrow in a circle"),
_("Fat arrow in a circle"), _("One color arrowhead"),
_("Fancy compass"), _("Basic compass"), _("Simple arrow"),
_("Thin arrow"), _("Fat arrow"), _("4-point star"));
n_arrow->answer = "1a";
n_arrow->guisection = _("Style");
n_arrow->gisprompt = "old,northarrow,northarrow";
coords = G_define_option();
coords->key = "at";
coords->key_desc = "x,y";
coords->type = TYPE_DOUBLE;
coords->answer = "85.0,15.0";
coords->options = "0-100";
coords->label =
_("Screen coordinates of the rectangle's top-left corner");
coords->description = _("(0,0) is lower-left of the display frame");
rotation_opt = G_define_option();
rotation_opt->key = "rotation";
rotation_opt->type = TYPE_DOUBLE;
rotation_opt->required = NO;
rotation_opt->answer = "0";
rotation_opt->description =
_("Rotation angle in degrees (counter-clockwise)");
lbl_opt = G_define_option();
lbl_opt->key = "label";
lbl_opt->required = NO;
lbl_opt->answer = "N";
lbl_opt->description =
_("Displayed letter on the top of arrow");
lbl_opt->guisection = _("Text");
fg_color_opt = G_define_standard_option(G_OPT_C);
fg_color_opt->label = _("Line color");
fg_color_opt->guisection = _("Colors");
bg_color_opt = G_define_standard_option(G_OPT_CN);
bg_color_opt->key = "fill_color";
bg_color_opt->label = _("Fill color");
bg_color_opt->answer = _("black");
bg_color_opt->guisection = _("Colors");
width_opt = G_define_option();
width_opt->key = "width";
width_opt->type = TYPE_DOUBLE;
width_opt->answer = "0";
width_opt->description = _("Line width");
fsize = G_define_option();
fsize->key = "fontsize";
fsize->type = TYPE_DOUBLE;
fsize->required = NO;
fsize->answer = "14";
fsize->options = "1-360";
fsize->description = _("Font size");
fsize->guisection = _("Text");
no_text = G_define_flag();
no_text->key = 't';
no_text->description = _("Draw the symbol without text");
no_text->guisection = _("Text");
rotate_text = G_define_flag();
rotate_text->key = 'w';
rotate_text->description = _("Do not rotate text with symbol");
rotate_text->guisection = _("Text");
rads = G_define_flag();
rads->key = 'r';
rads->description = _("Use radians instead of degrees for rotation");
/* TODO:
- add a -n flag to rotate to match true north instead of grid north.
Similar to 'g.region -n' but use the at=x,y coord for the convergence
angle calc. (assuming that's the center of the icon)
*/
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(coords->answers[0], "%lf", &east);
sscanf(coords->answers[1], "%lf", &north);
fontsize = atof(fsize->answer);
if (no_text->answer)
fontsize = -1;
rot_with_text = 0;
if (!rotate_text->answer)
rot_with_text = 1;
/* Convert to radians */
rotation = atof(rotation_opt->answer);
if (!rads->answer)
rotation *= M_PI / 180.0;
rotation = fmod(rotation, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
/* Parse and select foreground color */
fg_color = D_parse_color(fg_color_opt->answer, 0);
/* Parse and select background color */
bg_color = D_parse_color(bg_color_opt->answer, 1);
if (bg_color == 0)
do_background = FALSE;
line_width = atof(width_opt->answer);
if (line_width < 0)
line_width = 0;
else if (line_width > 72)
line_width = 72;
D_open_driver();
draw_n_arrow(east, north, rotation, lbl_opt->answer, rot_with_text,
fontsize, n_arrow->answer, line_width);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
char *name;
int overlay;
int invert, fp;
struct GModule *module;
struct Option *map;
struct Option *vallist;
struct Option *bg;
struct Flag *flag_n;
struct Flag *flag_i;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("raster"));
module->description = _("Displays user-specified raster map in the active "
"graphics frame.");
/* set up command line */
map = G_define_standard_option(G_OPT_R_MAP);
map->description = _("Name of raster map to be displayed");
vallist = G_define_option();
vallist->key = "values";
vallist->key_desc = "value[-value]";
vallist->type = TYPE_STRING;
vallist->required = NO;
vallist->multiple = YES;
vallist->description = _("List of categories or values to be displayed");
vallist->guisection = _("Selection");
bg = G_define_standard_option(G_OPT_C_BG);
bg->key_desc = "color";
bg->gisprompt = "old_color,color,color";
bg->label = _("Background color (for null)");
bg->description = _("Either a standard color name or R:G:B triplet");
bg->guisection = _("Null cells");
flag_n = G_define_flag();
flag_n->key = 'n';
flag_n->description = _("Make null cells opaque");
flag_n->guisection = _("Null cells");
flag_i = G_define_flag();
flag_i->key = 'i';
flag_i->description = _("Invert value list");
flag_i->guisection = _("Selection");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = map->answer;
overlay = !flag_n->answer;
invert = flag_i->answer;
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
fp = Rast_map_is_fp(name, "");
if (vallist->answer) {
if (fp)
parse_vallist(vallist->answers, &d_mask);
else
parse_catlist(vallist->answers, &mask);
}
/* use DCELL even if the map is FCELL */
display(name, overlay, bg->answer, fp ? DCELL_TYPE : CELL_TYPE, invert);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int text_height;
int text_width;
struct Categories cats;
struct Range range;
struct Colors pcolors;
char title[GNAME_MAX];
double tt, tb, tl, tr;
double t, b, l, r;
struct GModule *module;
struct Option *opt1;
struct Option *opt2, *bg_opt;
struct Option *opt4;
struct Option *opt5;
struct Flag *flag1;
struct Flag *flag2;
struct Flag *flag3;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("histogram"));
G_add_keyword(_("statistics"));
module->description =
_("Displays a histogram in the form of a pie or bar chart "
"for a user-specified raster map.");
opt1 = G_define_standard_option(G_OPT_R_MAP);
opt1->description = _("Raster map for which histogram will be displayed");
opt4 = G_define_option();
opt4->key = "style";
opt4->description = _("Indicate if a pie or bar chart is desired");
opt4->type = TYPE_STRING;
opt4->required = NO;
opt4->options = "pie,bar";
opt4->answer = "bar";
/* The color option specifies the color for the labels, tic-marks,
* and borders of the chart. */
opt2 = G_define_standard_option(G_OPT_C);
opt2->label = _("Color for text and axes");
bg_opt = G_define_standard_option(G_OPT_CN);
bg_opt->key = "bgcolor";
bg_opt->label = _("Background color");
bg_opt->answer = DEFAULT_BG_COLOR;
#ifdef CAN_DO_AREAS
opt3 = G_define_option();
opt3->key = "type";
opt3->description =
_("Indicate if cell counts or map areas should be displayed");
opt3->type = TYPE_STRING;
opt3->required = NO;
opt3->answer = "count";
opt3->options = "count,area";
#endif
opt5 = G_define_option();
opt5->key = "nsteps";
opt5->description =
_("Number of steps to divide the data range into (fp maps only)");
opt5->type = TYPE_INTEGER;
opt5->required = NO;
opt5->answer = "255";
flag1 = G_define_flag();
flag1->key = 'n';
flag1->description = _("Display information for null cells");
flag3 = G_define_flag();
flag3->key = 'c';
flag3->description =
_("Report for ranges defined in cats file (fp maps only)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
map_name = opt1->answer;
color = D_parse_color(opt2->answer, FALSE);
type = COUNT;
#ifdef CAN_DO_AREAS
if (strcmp(opt3->answer, "count") == 0)
type = COUNT;
else
type = AREA;
#endif
if (strcmp(opt4->answer, "bar") == 0)
style = BAR;
else
style = PIE;
if (sscanf(opt5->answer, "%d", &nsteps) != 1)
G_fatal_error(_("Invalid number of steps: %s"), opt5->answer);
cat_ranges = flag3->answer;
if (cat_ranges && nsteps != 255)
G_warning(_("When -C flag is set, the nsteps argument is ignored"));
nodata = flag1->answer;
if (Rast_read_colors(map_name, "", &pcolors) == -1)
G_fatal_error(_("Color file for <%s> not available"), map_name);
if (Rast_read_cats(map_name, "", &cats) == -1)
G_fatal_error(_("Category file for <%s> not available"), map_name);
if (Rast_read_range(map_name, "", &range) == -1)
G_fatal_error(_("Range information for <%s> not available"),
map_name);
/* get the distribution statistics */
get_stats(map_name, &dist_stats);
/* set up the graphics driver and initialize its color-table */
D_open_driver();
D_setup_unity(0); /* 0 = don't clear frame */
D_get_src(&t, &b, &l, &r);
/* clear the frame, if requested to do so */
if (strcmp(bg_opt->answer, "none") != 0)
D_erase(bg_opt->answer);
/* draw a title for */
sprintf(title, "%s", map_name);
text_height = (b - t) * 0.05;
text_width = (r - l) * 0.05 * 0.50;
D_text_size(text_width, text_height);
D_get_text_box(title, &tt, &tb, &tl, &tr);
D_pos_abs(l + (r - l) / 2 - (tr - tl) / 2,
t + (b - t) * 0.07);
D_use_color(color);
D_text(title);
/* plot the distributrion statistics */
if (style == PIE)
pie(&dist_stats, &pcolors);
else
bar(&dist_stats, &pcolors);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int ret, level;
int stat, type, display;
int chcat;
int has_color, has_fcolor;
struct color_rgb color, fcolor;
double size;
int default_width;
double width_scale;
double minreg, maxreg, reg;
char map_name[GNAME_MAX];
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, *enc_opt, *xref_opt, *yref_opt;
struct Option *attrcol_opt, *maxreg_opt, *minreg_opt;
struct Option *width_opt, *wcolumn_opt, *wscale_opt;
struct Option *leglab_opt;
struct Option *icon_line_opt, *icon_area_opt;
struct Flag *id_flag, *cats_acolors_flag, *sqrt_flag, *legend_flag;
char *desc;
struct cat_list *Clist;
LATTR lattr;
struct Map_info Map;
struct Cell_head window;
struct bound_box box;
double overlap;
stat = 0;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("graphics"));
G_add_keyword(_("vector"));
module->description = _("Displays user-specified vector map "
"in the active graphics frame.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
field_opt->answer = "1";
field_opt->guisection = _("Selection");
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,vert,dir,zcoor";
display_opt->description = _("Display");
desc = NULL;
G_asprintf(&desc,
"shape;%s;cat;%s;topo;%s;vert;%s;dir;%s;zcoor;%s",
_("Display geometry of features"),
_("Display category numbers of features"),
_("Display topology information (nodes, edges)"),
_("Display vertices of features"),
_("Display direction of linear features"),
_("Display z-coordinate of features (only for 3D vector maps)"));
display_opt->descriptions = desc;
/* Query */
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->answer = "point,line,area,face";
type_opt->options = "point,line,boundary,centroid,area,face";
type_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_DB_WHERE);
where_opt->guisection = _("Selection");
/* Colors */
color_opt = G_define_standard_option(G_OPT_CN);
color_opt->label = _("Feature color");
color_opt->guisection = _("Colors");
fcolor_opt = G_define_standard_option(G_OPT_CN);
fcolor_opt->key = "fill_color";
fcolor_opt->answer = "200:200:200";
fcolor_opt->label = _("Area fill color");
fcolor_opt->guisection = _("Colors");
rgbcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
rgbcol_opt->key = "rgb_column";
rgbcol_opt->guisection = _("Colors");
rgbcol_opt->label = _("Colorize features according color definition column");
rgbcol_opt->description = _("Color definition in R:G:B form");
zcol_opt = G_define_standard_option(G_OPT_M_COLR);
zcol_opt->key = "zcolor";
zcol_opt->description = _("Colorize point or area features according to z-coordinate");
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_DB_COLUMN);
wcolumn_opt->key = "width_column";
wcolumn_opt->guisection = _("Lines");
wcolumn_opt->label = _("Name of numeric column containing line width");
wcolumn_opt->description = _("These values will be scaled by width_scale");
wscale_opt = G_define_option();
wscale_opt->key = "width_scale";
wscale_opt->type = TYPE_DOUBLE;
wscale_opt->answer = "1";
wscale_opt->guisection = _("Lines");
wscale_opt->description = _("Scale factor for width_column");
/* 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_DB_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_DB_COLUMN);
rotcolumn_opt->key = "rotation_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");
icon_area_opt = G_define_option();
icon_area_opt->key = "icon_area";
icon_area_opt->type = TYPE_STRING;
icon_area_opt->required = NO;
icon_area_opt->multiple = NO;
icon_area_opt->guisection = _("Legend");
icon_area_opt->answer = "legend/area";
icon_area_opt->options = icon_files();
icon_area_opt->description = _("Area/boundary symbol for legend");
icon_line_opt = G_define_option();
icon_line_opt->key = "icon_line";
icon_line_opt->type = TYPE_STRING;
icon_line_opt->required = NO;
icon_line_opt->multiple = NO;
icon_line_opt->guisection = _("Legend");
icon_line_opt->answer = "legend/line";
icon_line_opt->options = icon_files();
icon_line_opt->description = _("Line symbol for legend");
leglab_opt = G_define_option();
leglab_opt->key = "legend_label";
leglab_opt->type = TYPE_STRING;
leglab_opt->guisection = _("Legend");
leglab_opt->description = _("Label to display after symbol in vector legend");
/* Labels */
lfield_opt = G_define_standard_option(G_OPT_V_FIELD);
lfield_opt->key = "label_layer";
lfield_opt->required = NO;
lfield_opt->guisection = _("Labels");
lfield_opt->label =
_("Layer number for labels (default: the given layer number)");
attrcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
attrcol_opt->key = "attribute_column";
attrcol_opt->multiple = NO; /* or fix attr.c, around line 102 */
attrcol_opt->guisection = _("Labels");
attrcol_opt->description = _("Name of column to be displayed as a label");
lcolor_opt = G_define_standard_option(G_OPT_C);
lcolor_opt->key = "label_color";
lcolor_opt->answer = "red";
lcolor_opt->label = _("Label color");
lcolor_opt->guisection = _("Labels");
bgcolor_opt = G_define_standard_option(G_OPT_CN);
bgcolor_opt->key = "label_bgcolor";
bgcolor_opt->answer = "none";
bgcolor_opt->guisection = _("Labels");
bgcolor_opt->label = _("Label background color");
bcolor_opt = G_define_standard_option(G_OPT_CN);
bcolor_opt->key = "label_bcolor";
bcolor_opt->type = TYPE_STRING;
bcolor_opt->answer = "none";
bcolor_opt->guisection = _("Labels");
bcolor_opt->label = _("Label border color");
lsize_opt = G_define_option();
lsize_opt->key = "label_size";
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");
enc_opt = G_define_option();
enc_opt->key = "encoding";
enc_opt->type = TYPE_STRING;
enc_opt->guisection = _("Labels");
enc_opt->description = _("Text encoding");
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");
/* Colors */
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");
sqrt_flag = G_define_flag();
sqrt_flag->key = 'r';
sqrt_flag->label = _("Use square root of the value of size_column");
sqrt_flag->description =
_("This makes circle areas proportionate to the size_column values "
"instead of circle radius");
sqrt_flag->guisection = _("Symbols");
legend_flag = G_define_flag();
legend_flag->key = 's';
legend_flag->label = _("Do not show this layer in vector legend");
legend_flag->guisection = _("Legend");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
D_open_driver();
G_get_set_window(&window);
/* 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_important_message(_("Region size is lower than minreg, nothing displayed"));
exit(EXIT_SUCCESS);
}
}
if (maxreg_opt->answer) {
maxreg = atof(maxreg_opt->answer);
if (reg > maxreg) {
G_important_message(_("Region size is greater than maxreg, nothing displayed"));
exit(EXIT_SUCCESS);
}
}
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 (cats_acolors_flag->answer && rgbcol_opt->answer) {
G_warning(_("The -%c flag and <%s> option cannot be used together, "
"the -%c flag will be ignored!"),
cats_acolors_flag->key, rgbcol_opt->key, cats_acolors_flag->key);
cats_acolors_flag->answer = FALSE;
}
color = G_standard_color_rgb(WHITE);
has_color = option_to_color(&color, color_opt->answer);
fcolor = G_standard_color_rgb(WHITE);
has_fcolor = option_to_color(&fcolor, fcolor_opt->answer);
size = atof(size_opt->answer);
/* 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_old2(&Map, map_name, "", field_opt->answer);
chcat = 0;
if (where_opt->answer) {
if (Clist->field < 1)
G_fatal_error(_("Option <%s> must be > 0"), field_opt->key);
chcat = 1;
option_to_where(&Map, Clist, where_opt->answer);
}
else if (cat_opt->answer) {
if (Clist->field < 1 && !id_flag->answer)
G_fatal_error(_("Option <%s> must be > 0"), field_opt->key);
chcat = 1;
ret = Vect_str_to_cat_list(cat_opt->answer, Clist);
if (ret > 0)
G_warning(n_("%d error in cat option", "%d errors in cat option", ret), ret);
}
type = Vect_option_to_types(type_opt);
display = option_to_display(display_opt);
/* labels */
options_to_lattr(&lattr, lfield_opt->answer,
lcolor_opt->answer, bgcolor_opt->answer, bcolor_opt->answer,
atoi(lsize_opt->answer), font_opt->answer, enc_opt->answer,
xref_opt->answer, yref_opt->answer);
D_setup(0);
D_set_reduction(1.0);
G_verbose_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_warning(_("The bounding box of the map is outside the current region, "
"nothing drawn"));
}
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 (display & DISP_SHAPE) {
stat += display_shape(&Map, type, Clist, &window,
has_color ? &color : NULL, has_fcolor ? &fcolor : NULL, chcat,
icon_opt->answer, size, sizecolumn_opt->answer,
sqrt_flag->answer ? TRUE : FALSE, rotcolumn_opt->answer,
id_flag->answer ? TRUE : FALSE,
cats_acolors_flag->answer ? TRUE : FALSE, rgbcol_opt->answer,
default_width, wcolumn_opt->answer, width_scale,
zcol_opt->answer);
if (wcolumn_opt->answer)
D_line_width(default_width);
}
if (has_color) {
D_RGB_color(color.r, color.g, color.b);
if (display & DISP_DIR)
stat += display_dir(&Map, type, Clist, chcat, size);
}
if (!legend_flag->answer) {
write_into_legfile(&Map, type, leglab_opt->answer, map_name,
icon_opt->answer, size_opt->answer,
color_opt->answer, fcolor_opt->answer,
width_opt->answer, icon_area_opt->answer,
icon_line_opt->answer, sizecolumn_opt->answer);
}
/* 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)
D_line_width(0);
if (display & DISP_CAT)
stat += display_label(&Map, type, Clist, &lattr, chcat);
if (attrcol_opt->answer)
stat += display_attr(&Map, type, attrcol_opt->answer, Clist, &lattr, chcat);
if (display & DISP_ZCOOR)
stat += display_zcoor(&Map, type, &lattr);
if (display & DISP_VERT)
stat += display_vert(&Map, type, &lattr, size);
if (display & DISP_TOPO)
stat += display_topo(&Map, type, &lattr, size);
}
D_save_command(G_recreate_command());
D_close_driver();
Vect_close(&Map);
Vect_destroy_cat_list(Clist);
if (stat != 0) {
G_fatal_error(_("Rendering failed"));
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct band B[3];
int row;
int next_row;
int overlay;
struct Cell_head window;
struct GModule *module;
struct Flag *flag_n;
int i;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("graphics"));
G_add_keyword(_("raster"));
G_add_keyword("RGB");
module->description =
_("Displays three user-specified raster maps "
"as red, green, and blue overlays in the active graphics frame.");
flag_n = G_define_flag();
flag_n->key = 'n';
flag_n->description = _("Make null cells opaque");
flag_n->guisection = _("Null cells");
for (i = 0; i < 3; i++) {
char buff[80];
sprintf(buff, _("Name of raster map to be used for <%s>"),
color_names[i]);
B[i].opt = G_define_standard_option(G_OPT_R_MAP);
B[i].opt->key = G_store(color_names[i]);
B[i].opt->description = G_store(buff);
}
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Do screen initializing stuff */
D_open_driver();
overlay = !flag_n->answer;
D_setup(0);
D_set_overlay_mode(overlay);
for (i = 0; i < 3; i++) {
/* Get name of layer to be used */
char *name = B[i].opt->answer;
/* Make sure map is available */
B[i].file = Rast_open_old(name, "");
B[i].type = Rast_get_map_type(B[i].file);
/* Reading color lookup table */
if (Rast_read_colors(name, "", &B[i].colors) == -1)
G_fatal_error(_("Color file for <%s> not available"), name);
B[i].array = Rast_allocate_buf(B[i].type);
}
/* read in current window */
G_get_window(&window);
D_raster_draw_begin();
next_row = 0;
for (row = 0; row < window.rows;) {
G_percent(row, window.rows, 5);
for (i = 0; i < 3; i++)
Rast_get_row(B[i].file, B[i].array, row, B[i].type);
if (row == next_row)
next_row = D_draw_raster_RGB(next_row,
B[0].array, B[1].array, B[2].array,
&B[0].colors, &B[1].colors,
&B[2].colors, B[0].type, B[1].type,
B[2].type);
else if (next_row > 0)
row = next_row;
else
break;
}
G_percent(window.rows, window.rows, 5);
D_raster_draw_end();
D_save_command(G_recreate_command());
D_close_driver();
/* Close the raster maps */
for (i = 0; i < 3; i++)
Rast_close(B[i].file);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int line_color;
int text_color;
double lon1, lat1, lon2, lat2;
char *deftcolor;
struct GModule *module;
struct
{
struct Option *lcolor, *tcolor, *coor;
} parm;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("distance"));
module->description =
_("Displays a geodesic line, tracing the shortest distance "
"between two geographic points along a great circle, in "
"a longitude/latitude data set.");
parm.coor = G_define_option();
parm.coor->key = "coor";
parm.coor->key_desc = "lon1,lat1,lon2,lat2";
parm.coor->type = TYPE_STRING;
parm.coor->required = YES;
parm.coor->description = _("Starting and ending coordinates");
parm.lcolor = G_define_option();
parm.lcolor->key = "lcolor";
parm.lcolor->type = TYPE_STRING;
parm.lcolor->required = NO;
parm.lcolor->description = _("Line color");
parm.lcolor->gisprompt = "old_color,color,color";
parm.lcolor->answer = DEFAULT_FG_COLOR;
parm.tcolor = G_define_option();
parm.tcolor->key = "tcolor";
parm.tcolor->type = TYPE_STRING;
parm.tcolor->required = NO;
parm.tcolor->description = _("Text color or \"none\"");
parm.tcolor->gisprompt = "old_color,color,color";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (G_projection() != PROJECTION_LL)
G_fatal_error(_("Location is not %s"), G__projection_name(PROJECTION_LL));
if (parm.coor->answers[0] == NULL)
G_fatal_error(_("No coordinates given"));
if (!G_scan_easting(parm.coor->answers[0], &lon1, G_projection()))
G_fatal_error(_("%s - illegal longitude"), parm.coor->answers[0]);
if (!G_scan_northing(parm.coor->answers[1], &lat1, G_projection()))
G_fatal_error(_("%s - illegal longitude"), parm.coor->answers[1]);
if (!G_scan_easting(parm.coor->answers[2], &lon2, G_projection()))
G_fatal_error(_("%s - illegal longitude"), parm.coor->answers[2]);
if (!G_scan_northing(parm.coor->answers[3], &lat2, G_projection()))
G_fatal_error(_("%s - illegal longitude"), parm.coor->answers[3]);
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
line_color = D_translate_color(parm.lcolor->answer);
if (!line_color)
line_color = D_translate_color(parm.lcolor->answer =
DEFAULT_FG_COLOR);
if (strcmp(parm.lcolor->answer, DEFAULT_FG_COLOR) == 0)
deftcolor = "red";
else
deftcolor = DEFAULT_FG_COLOR;
if (parm.tcolor->answer == NULL)
text_color = D_translate_color(deftcolor);
else if (strcmp(parm.tcolor->answer, "none") == 0)
text_color = -1;
else
text_color = D_translate_color(parm.tcolor->answer);
plot(lon1, lat1, lon2, lat2, line_color, text_color);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
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 main(int argc, char **argv)
{
struct GModule *module;
struct Option *bg_color_opt, *fg_color_opt, *coords, *fsize, *barstyle,
*text_placement, *length_opt, *segm_opt, *units_opt, *label_opt,
*width_scale_opt;
struct Flag *feet, *no_text, *n_symbol;
struct Cell_head W;
double east, north;
double fontsize;
int bar_style, text_position, units;
double length;
int segm;
char *label;
double width_scale;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description = _("Displays a barscale on the graphics monitor.");
feet = G_define_flag();
feet->key = 'f';
feet->description = _("Use feet/miles instead of meters");
no_text = G_define_flag();
no_text->key = 't';
no_text->description = _("Draw the scale bar without text");
no_text->guisection = _("Text");
n_symbol = G_define_flag();
n_symbol->key = 'n';
n_symbol->description = _("Display north-arrow symbol.");
n_symbol->guisection = _("Style");
barstyle = G_define_option();
barstyle->key = "style";
barstyle->description = _("Type of barscale to draw");
barstyle->options =
"classic,line,solid,hollow,full_checker,part_checker,mixed_checker,tail_checker,up_ticks,down_ticks,both_ticks,arrow_ends";
barstyle->answer = "classic";
barstyle->gisprompt = "old,barscale,barscale";
barstyle->guisection = _("Style");
G_asprintf((char **)&(barstyle->descriptions),
"classic;%s;"
"line;%s;"
"solid;%s;"
"hollow;%s;"
"full_checker;%s;"
"part_checker;%s;"
"mixed_checker;%s;"
"tail_checker;%s;"
"up_ticks;%s;"
"down_ticks;%s;"
"both_ticks;%s;"
"arrow_ends;%s",
_("Classic style"),
_("Line style"),
_("Solid style"),
_("Hollow style"),
_("Full checker style"),
_("Part checker style"),
_("Mixed checker style"),
_("Tail checker style"),
_("Up ticks style"),
_("Down ticks style"),
_("Both ticks style"), _("Arrow ends style"));
coords = G_define_option();
coords->key = "at";
coords->key_desc = "x,y";
coords->type = TYPE_DOUBLE;
coords->answer = "0.0,10.0";
coords->options = "0-100";
coords->label =
_("Screen coordinates of the rectangle's top-left corner");
coords->description = _("(0,0) is lower-left of the display frame");
length_opt = G_define_option();
length_opt->key = "length";
length_opt->key_desc = "integer";
length_opt->type = TYPE_INTEGER;
length_opt->answer = "0";
length_opt->options = "0-";
length_opt->label = _("Length of barscale in map units");
units_opt = G_define_option();
units_opt->key = "units";
units_opt->description = _("Barscale units to display");
units_opt->options = "meters, kilometers, feet, miles";
label_opt = G_define_option();
label_opt->key = "label";
label_opt->description = _("Custom label of unit");
label_opt->type = TYPE_STRING;
label_opt->guisection = _("Text");
segm_opt = G_define_option();
segm_opt->key = "segment";
segm_opt->type = TYPE_INTEGER;
segm_opt->answer = "10";
segm_opt->options = "1-100";
segm_opt->label = _("Number of segments");
segm_opt->guisection = _("Style");
fg_color_opt = G_define_standard_option(G_OPT_C);
fg_color_opt->label = _("Bar scale and text color");
fg_color_opt->guisection = _("Colors");
bg_color_opt = G_define_standard_option(G_OPT_CN);
bg_color_opt->key = "bgcolor";
bg_color_opt->answer = "white";
bg_color_opt->label = _("Background color (drawn behind the bar)");
bg_color_opt->guisection = _("Colors");
text_placement = G_define_option();
text_placement->key = "text_position";
text_placement->description = _("Text position");
text_placement->options = "under,over,left,right";
text_placement->answer = "right";
text_placement->guisection = _("Text");
width_scale_opt = G_define_option();
width_scale_opt->key = "width_scale";
width_scale_opt->type = TYPE_DOUBLE;
width_scale_opt->required = NO;
width_scale_opt->answer = "1";
width_scale_opt->options = "0.5-100";
width_scale_opt->description = _("Scale factor to change bar width");
fsize = G_define_option();
fsize->key = "fontsize";
fsize->type = TYPE_DOUBLE;
fsize->required = NO;
fsize->answer = "12";
fsize->options = "1-360";
fsize->description = _("Font size");
fsize->guisection = _("Text");
G_option_exclusive(feet, units_opt, NULL);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_window(&W);
if (W.proj == PROJECTION_LL)
G_fatal_error(_("%s does not work with a latitude-longitude location"),
argv[0]);
north_arrow = n_symbol->answer ? TRUE : FALSE;
switch (barstyle->answer[0]) {
case 'c':
bar_style = STYLE_CLASSIC_BAR;
break;
case 'p':
bar_style = STYLE_PART_CHECKER;
break;
case 'f':
bar_style = STYLE_FULL_CHECKER;
break;
case 'm':
bar_style = STYLE_MIXED_CHECKER;
break;
case 't':
bar_style = STYLE_TAIL_CHECKER;
break;
case 'l':
bar_style = STYLE_THIN_WITH_ENDS;
break;
case 's':
bar_style = STYLE_SOLID_BAR;
break;
case 'h':
bar_style = STYLE_HOLLOW_BAR;
break;
case 'u':
bar_style = STYLE_TICKS_UP;
break;
case 'd':
bar_style = STYLE_TICKS_DOWN;
break;
case 'b':
bar_style = STYLE_TICKS_BOTH;
break;
case 'a':
bar_style = STYLE_ARROW_ENDS;
break;
default:
G_fatal_error(_("Programmer error"));
}
switch (text_placement->answer[0]) {
case 'u':
text_position = TEXT_UNDER;
break;
case 'o':
text_position = TEXT_OVER;
break;
case 'l':
text_position = TEXT_LEFT;
break;
case 'r':
text_position = TEXT_RIGHT;
break;
default:
G_fatal_error(_("Programmer error"));
}
sscanf(coords->answers[0], "%lf", &east);
sscanf(coords->answers[1], "%lf", &north);
length = atof(length_opt->answer);
sscanf(segm_opt->answer, "%d", &segm);
if (feet->answer == 1){
use_feet = 1;
units = U_FEET;
label = "ft";
}
else {
if (!units_opt->answer)
units = G_database_unit();
else
units = G_units(units_opt->answer);
switch (units) {
case U_METERS:
label = "m";
break;
case U_KILOMETERS:
label = "km";
break;
case U_FEET:
use_feet = 1;
label = "ft";
break;
case U_USFEET:
use_feet = 1;
label = "ft";
break;
case U_MILES:
use_feet = 1;
label = "mi";
break;
default:
units = U_METERS;
label = "m";
}
}
if (label_opt->answer){
label = label_opt->answer;
}
fontsize = atof(fsize->answer);
if (no_text->answer)
fontsize = -1;
width_scale = atof(width_scale_opt->answer);
/* Parse and select foreground color */
fg_color = D_parse_color(fg_color_opt->answer, 0);
/* Parse and select background color */
bg_color = D_parse_color(bg_color_opt->answer, 1);
if (bg_color == 0)
do_background = FALSE;
D_open_driver();
D_setup(0);
draw_scale(east, north, length, segm, units, label, bar_style, text_position, width_scale, fontsize);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int colorg = 0;
int colorb = 0;
int colort = 0;
int colorbg = 0;
double size = 0., gsize = 0.; /* initialize to zero */
double east, north;
int do_text, fontsize, mark_type, line_width, dirn;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *fsize, *tcolor, *lwidth,
*direction, *bgcolor;
struct Flag *noborder, *notext, *geogrid, *nogrid, *wgs84, *cross,
*fiducial, *dot, *align;
struct pj_info info_in; /* Proj structures */
struct pj_info info_out; /* Proj structures */
struct Cell_head wind;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
G_add_keyword(_("graticule"));
module->description =
_("Overlays a user-specified grid "
"in the active display frame on the graphics monitor.");
opt2 = G_define_option();
opt2->key = "size";
opt2->key_desc = "value";
opt2->type = TYPE_STRING;
opt2->required = YES;
opt2->label = _("Size of grid to be drawn (in map units)");
opt2->description =
_("0 for north-south resolution of the current region. "
"In map units or DDD:MM:SS format. "
"Example: \"1000\" or \"0:10\"");
opt3 = G_define_standard_option(G_OPT_M_COORDS);
opt3->key = "origin";
opt3->answer = "0,0";
opt3->multiple = NO;
opt3->description = _("Lines of the grid pass through this coordinate");
direction = G_define_option();
direction->key = "direction";
direction->type = TYPE_STRING;
direction->required = NO;
direction->answer = "both";
direction->options = "both,east-west,north-south";
direction->description =
_("Draw only east-west lines, north-south lines, or both ");
direction->guisection = _("Disable");
lwidth = G_define_option();
lwidth->key = "width";
lwidth->type = TYPE_DOUBLE;
lwidth->required = NO;
lwidth->description = _("Grid line width");
opt1 = G_define_standard_option(G_OPT_C);
opt1->answer = "gray";
opt1->label = _("Grid color");
opt1->guisection = _("Color");
opt4 = G_define_standard_option(G_OPT_C);
opt4->key = "border_color";
opt4->label = _("Border color");
opt4->guisection = _("Color");
tcolor = G_define_standard_option(G_OPT_C);
tcolor->key = "text_color";
tcolor->answer = "gray";
tcolor->label = _("Text color");
tcolor->guisection = _("Color");
bgcolor = G_define_standard_option(G_OPT_CN);
bgcolor->key = "bgcolor";
bgcolor->answer = "none";
bgcolor->label = _("Background color");
bgcolor->guisection = _("Color");
fsize = G_define_option();
fsize->key = "fontsize";
fsize->type = TYPE_INTEGER;
fsize->required = NO;
fsize->answer = "9";
fsize->options = "1-72";
fsize->description = _("Font size for gridline coordinate labels");
align = G_define_flag();
align->key = 'a';
align->description =
_("Align the origin to the east-north corner of the current region");
geogrid = G_define_flag();
geogrid->key = 'g';
geogrid->description =
_("Draw geographic grid (referenced to current ellipsoid)");
geogrid->guisection = _("Draw");
wgs84 = G_define_flag();
wgs84->key = 'w';
wgs84->description =
_("Draw geographic grid (referenced to WGS84 ellipsoid)");
wgs84->guisection = _("Draw");
cross = G_define_flag();
cross->key = 'c';
cross->description = _("Draw '+' marks instead of grid lines");
cross->guisection = _("Draw");
dot = G_define_flag();
dot->key = 'd';
dot->description = _("Draw '.' marks instead of grid lines");
dot->guisection = _("Draw");
fiducial = G_define_flag();
fiducial->key = 'f';
fiducial->description = _("Draw fiducial marks instead of grid lines");
fiducial->guisection = _("Draw");
nogrid = G_define_flag();
nogrid->key = 'n';
nogrid->description = _("Disable grid drawing");
nogrid->guisection = _("Disable");
noborder = G_define_flag();
noborder->key = 'b';
noborder->description = _("Disable border drawing");
noborder->guisection = _("Disable");
notext = G_define_flag();
notext->key = 't';
notext->description = _("Disable text drawing");
notext->guisection = _("Disable");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* do some checking */
if (nogrid->answer && noborder->answer)
G_fatal_error(_("Both grid and border drawing are disabled"));
if (wgs84->answer)
geogrid->answer = 1; /* -w implies -g */
if (geogrid->answer && G_projection() == PROJECTION_LL)
G_fatal_error(_("Geo-grid option not available for LL projection, use without -g/-w"));
if (geogrid->answer && G_projection() == PROJECTION_XY)
G_fatal_error(_("Geo-grid option not available for XY projection, use without -g/-w"));
if (notext->answer)
do_text = FALSE;
else
do_text = TRUE;
if (lwidth->answer) {
line_width = atoi(lwidth->answer);
if (line_width < 0 || line_width > 1e3)
G_fatal_error("Invalid line width");
}
else
line_width = 0;
fontsize = atoi(fsize->answer);
mark_type = MARK_GRID;
if (cross->answer + fiducial->answer + dot->answer > 1)
G_fatal_error(_("Choose a single mark style"));
if (cross->answer)
mark_type = MARK_CROSS;
if (fiducial->answer)
mark_type = MARK_FIDUCIAL;
if (dot->answer)
mark_type = MARK_DOT;
if (G_strcasecmp(direction->answer, "both") == 0)
dirn = DIRN_BOTH;
else if (G_strcasecmp(direction->answer, "east-west") == 0)
dirn = DIRN_LAT;
else if (G_strcasecmp(direction->answer, "north-south") == 0)
dirn = DIRN_LON;
else
G_fatal_error("Invalid direction: %s", direction->answer);
if (align->answer || strcmp(opt2->answer, "0") == 0)
G_get_element_window(&wind, "", "WIND", G_mapset());
if (strcmp(opt2->answer, "0") == 0) {
if (geogrid->answer)
gsize = wind.ns_res;
else
size = wind.ns_res;
}
else {
/* get grid size */
if (geogrid->answer) {
if (!G_scan_resolution(opt2->answer, &gsize, PROJECTION_LL) ||
gsize <= 0.0)
G_fatal_error(_("Invalid geo-grid size <%s>"), opt2->answer);
}
else {
if (!G_scan_resolution(opt2->answer, &size, G_projection()) ||
size <= 0.0)
G_fatal_error(_("Invalid grid size <%s>"), opt2->answer);
}
}
if (align->answer) {
/* reduce accumulated errors when ew_res is not the same as ns_res. */
struct Cell_head w;
G_get_set_window(&w);
east =
wind.west +
(int)((w.west - wind.west) / wind.ew_res) * wind.ew_res;
north =
wind.south +
(int)((w.south - wind.south) / wind.ns_res) * wind.ns_res;
}
else {
/* get grid easting start */
if (!G_scan_easting(opt3->answers[0], &east, G_projection())) {
G_usage();
G_fatal_error(_("Illegal east coordinate <%s>"),
opt3->answers[0]);
}
/* get grid northing start */
if (!G_scan_northing(opt3->answers[1], &north, G_projection())) {
G_usage();
G_fatal_error(_("Illegal north coordinate <%s>"),
opt3->answers[1]);
}
}
/* Setup driver and check important information */
D_open_driver();
/* Parse and select grid color */
colorg = D_parse_color(opt1->answer, FALSE);
/* Parse and select border color */
colorb = D_parse_color(opt4->answer, FALSE);
/* Parse and select text color */
colort = D_parse_color(tcolor->answer, FALSE);
/* Parse and select background color */
colorbg = D_parse_color(bgcolor->answer, TRUE);
D_setup(0);
/* draw grid */
if (!nogrid->answer) {
if (geogrid->answer) {
/* initialzie proj stuff */
init_proj(&info_in, &info_out, wgs84->answer);
plot_geogrid(gsize, info_in, info_out, do_text, colorg, colort,
colorbg, fontsize, mark_type, line_width, dirn);
}
else {
/* Do the grid plotting */
plot_grid(size, east, north, do_text, colorg, colort, colorbg,
fontsize, mark_type, line_width, dirn);
}
}
/* Draw border */
if (!noborder->answer) {
/* Set border color */
D_use_color(colorb);
/* Do the border plotting */
plot_border(size, east, north, dirn);
}
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
char *map_name;
int color;
int lines;
int cols;
struct FPRange fp_range;
struct Colors colors;
double ratio;
DCELL dmin, dmax, dval;
int cats_num;
int cur_dot_row, cur_dot_col;
int dots_per_line, dots_per_col;
int atcat;
int white, black;
int atcol, atline;
int count, offset;
double t, b, l, r;
int fp, new_colr;
double x_box[5], y_box[5];
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4;
struct Flag *skip_null;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("raster"));
module->description =
_("Displays the color table associated with a raster map layer.");
opt1 = G_define_standard_option(G_OPT_R_MAP);
opt1->description =
_("Name of raster map whose color table is to be displayed");
opt2 = G_define_option();
opt2->key = "color";
opt2->type = TYPE_STRING;
opt2->answer = DEFAULT_BG_COLOR;
opt2->gisprompt = "old_color,color,color";
opt2->description =
_("Color of lines separating the colors of the color table");
opt3 = G_define_option();
opt3->key = "lines";
opt3->type = TYPE_INTEGER;
opt3->options = "1-1000";
opt3->description = _("Number of lines to appear in the color table");
opt4 = G_define_option();
opt4->key = "cols";
opt4->type = TYPE_INTEGER;
opt4->options = "1-1000";
opt4->description = _("Number of columns to appear in the color table");
skip_null = G_define_flag();
skip_null->key = 'n';
skip_null->description =
_("Don't draw a collar showing the NULL color in FP maps");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
map_name = opt1->answer;
fp = Rast_map_is_fp(map_name, "");
if (opt2->answer != NULL) {
new_colr = D_translate_color(opt2->answer);
color = new_colr;
}
if (fp)
lines = 1;
else
lines = 0;
if (opt3->answer != NULL) {
if (fp)
G_warning(_("<%s> is floating-point; "
"ignoring [lines] and drawing continuous color ramp"),
map_name);
else
sscanf(opt3->answer, "%d", &lines);
}
if (fp)
cols = 1;
else
cols = 0;
if (opt4->answer) {
if (fp)
G_warning(_("<%s> is floating-point; "
"ignoring [cols] and drawing continuous color ramp"),
map_name);
else
sscanf(opt4->answer, "%d", &cols);
}
/* Make sure map is available */
if (Rast_read_colors(map_name, "", &colors) == -1)
G_fatal_error(_("Color file for <%s> not available"), map_name);
if (Rast_read_fp_range(map_name, "", &fp_range) == -1)
G_fatal_error(_("Range file for <%s> not available"), map_name);
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
D_setup_unity(0);
D_get_src(&t, &b, &l, &r);
Rast_get_fp_range_min_max(&fp_range, &dmin, &dmax);
if (Rast_is_d_null_value(&dmin) || Rast_is_d_null_value(&dmax))
G_fatal_error(_("Data range is empty"));
cats_num = (int)dmax - (int)dmin + 1;
if (lines <= 0 && cols <= 0) {
double dx, dy;
dy = (double)(b - t);
dx = (double)(r - l);
ratio = dy / dx;
cols = 1 + sqrt((dmax - dmin + 1.) / ratio);
lines = 1 + cats_num / cols;
}
else if (lines > 0 && cols <= 0) {
cols = 1 + cats_num / lines;
}
else if (cols > 0 && lines <= 0) {
lines = 1 + cats_num / cols;
}
/* otherwise, accept without complaint what the user requests
* It is possible that the number of lines and cols is not
* sufficient for the number of categories.
*/
dots_per_line = (b - t) / lines;
dots_per_col = (r - l) / cols;
x_box[0] = 0; y_box[0] = 0;
x_box[1] = 0; y_box[1] = (6 - dots_per_line);
x_box[2] = (dots_per_col - 6); y_box[2] = 0;
x_box[3] = 0; y_box[3] = (dots_per_line - 6);
x_box[4] = (6 - dots_per_col); y_box[4] = 0;
white = D_translate_color("white");
black = D_translate_color("black");
Rast_set_c_null_value(&atcat, 1);
if (!fp) {
for (atcol = 0; atcol < cols; atcol++) {
cur_dot_row = t;
cur_dot_col = l + atcol * dots_per_col;
count = 0;
for (atline = 0; atline < lines; atline++) {
cur_dot_row += dots_per_line;
/* Draw outer border box */
D_use_color(color);
D_begin();
D_move_abs(cur_dot_col + 2, (cur_dot_row - 1));
D_cont_rel(0, (2 - dots_per_line));
D_cont_rel((dots_per_col - 2), 0);
D_cont_rel(0, (dots_per_line - 2));
D_cont_rel((2 - dots_per_col), 0);
D_end();
D_stroke();
/* Draw black box */
D_use_color(black);
D_begin();
D_move_abs(cur_dot_col + 3, (cur_dot_row - 2));
D_cont_rel(0, (4 - dots_per_line));
D_cont_rel((dots_per_col - 4), 0);
D_cont_rel(0, (dots_per_line - 4));
D_cont_rel((4 - dots_per_col), 0);
D_end();
D_stroke();
/* Color box */
D_color((CELL) atcat, &colors);
D_pos_abs(cur_dot_col + 4, (cur_dot_row - 3));
D_polygon_rel(x_box, y_box, 5);
count++;
/* first cat number is null value */
if (count == 1)
atcat = (int)dmin;
else if (++atcat > (int)dmax)
break;
}
if (atcat > (int)dmax)
break;
} /* col loop */
} /* int map */
else {
/*** draw continuous color ramp for fp map ***/
cur_dot_row = t + dots_per_line;
cur_dot_col = l;
/* Draw outer border box */
D_use_color(color);
D_begin();
D_move_abs(cur_dot_col + 1, (cur_dot_row - 1));
D_cont_rel(0, (2 - dots_per_line));
D_cont_rel((dots_per_col - 2), 0);
D_cont_rel(0, (dots_per_line - 2));
D_cont_rel((2 - dots_per_col), 0);
D_end();
D_stroke();
/* Draw black box */
D_use_color(black);
D_begin();
D_move_abs(cur_dot_col + 2, (cur_dot_row - 2));
D_cont_rel(0, (4 - dots_per_line));
D_cont_rel((dots_per_col - 4), 0);
D_cont_rel(0, (dots_per_line - 4));
D_cont_rel((4 - dots_per_col), 0);
D_end();
D_stroke();
/* Color ramp box */
/* get separate color for each pixel */
/* fisrt 5 pixels draw null color */
y_box[1] = -1;
y_box[3] = 1;
x_box[2] = (dots_per_col - 6);
x_box[4] = (6 - dots_per_col);
G_debug(1, "dots_per_line: %d dmin=%.2f dmax=%.2f",
dots_per_line, dmin, dmax);
if (skip_null->answer)
offset = 1;
else
offset = 4;
for (r = 0; r < dots_per_line - 6; r++) {
if ((r <= 4) && !skip_null->answer)
Rast_set_d_null_value(&dval, 1);
else
dval =
dmin + r*(dmax - dmin) / (dots_per_line - 6 - offset);
D_d_color(dval, &colors);
D_pos_abs(cur_dot_col + 3, (cur_dot_row - 3) - r);
D_polygon_rel(x_box, y_box, 5);
}
}
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
double xoffset; /* offset for x-axis */
double yoffset; /* offset for y-axis */
double text_height;
double text_width;
int i;
int j;
int c;
int tic_every;
int max_tics;
int title_color;
int num_y_files;
int tic_unit;
double t, b, l, r;
double tt, tb, tl, tr;
double prev_x, prev_y[11];
double new_x, new_y[11];
int line;
double x_line[3];
double y_line[3];
int err;
struct in_file
{
int num_pnts; /* number of lines in file */
int color; /* color to use for y lines */
float max; /* maximum value in file */
float min; /* minimum value in file */
float value; /* current value read in */
char name[1024]; /* name of file */
char full_name[1024]; /* path/name of file */
FILE *fp; /* pointer to file */
};
struct in_file in[12];
struct GModule *module;
float max_y;
float min_y;
float height, width;
float xscale;
float yscale;
char txt[1024], xlabel[512];
char tic_name[1024];
char *name;
char color_name[20];
FILE *fopen();
struct Option *dir_opt, *x_opt, *y_opt;
struct Option *y_color_opt;
struct Option *title[3];
struct Option *t_color_opt;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description =
_("Generates and displays simple line graphs in the active graphics monitor display frame.");
x_opt = G_define_option();
x_opt->key = "x_file";
x_opt->description = _("Name of data file for X axis of graph");
x_opt->type = TYPE_STRING;
x_opt->required = YES;
y_opt = G_define_option();
y_opt->key = "y_file";
y_opt->description = _("Name of data file(s) for Y axis of graph");
y_opt->type = TYPE_STRING;
y_opt->required = YES;
y_opt->multiple = YES;
dir_opt = G_define_option();
dir_opt->key = "directory";
dir_opt->description = _("Path to file location");
dir_opt->type = TYPE_STRING;
dir_opt->required = NO;
/* Remove answer because create problem with full path */
/* dir_opt->answer = "."; */
y_color_opt = G_define_option();
y_color_opt->key = "y_color";
y_color_opt->description = _("Color for Y data");
y_color_opt->type = TYPE_STRING;
y_color_opt->required = NO;
y_color_opt->multiple = YES;
y_color_opt->gisprompt = "old_color,color,color";
y_color_opt->answers = NULL;
t_color_opt = G_define_option();
t_color_opt->key = "title_color";
t_color_opt->description = _("Color for axis, tics, numbers, and title");
t_color_opt->type = TYPE_STRING;
t_color_opt->required = NO;
t_color_opt->gisprompt = "old_color,color,color";
t_color_opt->answer = DEFAULT_FG_COLOR;
title[0] = G_define_option();
title[0]->key = "x_title";
title[0]->description = _("Title for X data");
title[0]->type = TYPE_STRING;
title[0]->required = NO;
title[0]->answer = "";
title[1] = G_define_option();
title[1]->key = "y_title";
title[1]->description = _("Title for Y data");
title[1]->type = TYPE_STRING;
title[1]->required = NO;
title[1]->answer = "";
title[2] = G_define_option();
title[2]->key = "title";
title[2]->description = _("Title for Graph");
title[2]->type = TYPE_STRING;
title[2]->required = NO;
title[2]->answer = "";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
for (i = 0; i < 3; i++) {
for (j = 0; j < strlen(title[i]->answer); j++)
if (title[i]->answer[j] == '_')
title[i]->answer[j] = ' ';
}
/* build path to X data file and open for reading
notice that in[0] will be the X file, and in[1-10]
will be the Y file(s) */
if (dir_opt->answer != NULL) {
sprintf(in[0].full_name, "%s/%s", dir_opt->answer, x_opt->answer);
} else {
sprintf(in[0].full_name, "%s", x_opt->answer);
}
sprintf(in[0].name, "%s", x_opt->answer);
if ((in[0].fp = fopen(in[0].full_name, "r")) == NULL)
G_fatal_error(_("Unable to open input file <%s>"), in[0].full_name);
num_y_files = 0;
/* open all Y data files */
for (i = 0, j = 1; (name = y_opt->answers[i]); i++, j++) {
if (dir_opt->answer != NULL) {
sprintf(in[j].full_name, "%s/%s", dir_opt->answer, name);
} else {
sprintf(in[j].full_name, "%s", name);
}
sprintf(in[j].name, "%s", name);
if ((in[j].fp = fopen(in[j].full_name, "r")) == NULL)
G_fatal_error(_("Unable to open input file <%s>"),
in[j].full_name);
num_y_files++;
if (num_y_files > 10)
G_fatal_error(_("Maximum of 10 Y data files exceeded"));
}
/* set colors */
title_color = D_translate_color(t_color_opt->answer);
/* I had an argument with the parser, and couldn't get a neat list of
the input colors as I thought I should. I did a quick hack to get
my list from the answer var, which gives us the colors input
separated by commas. at least we know that they have been checked against
the list of possibles */
c = 0;
j = 1;
if (y_color_opt->answer != NULL) {
for (i = 0; i <= (strlen(y_color_opt->answer)); i++) {
if ((y_color_opt->answer[i] == ',') ||
(i == (strlen(y_color_opt->answer)))) {
color_name[c] = '\0';
in[j].color = D_translate_color(color_name);
j++;
c = 0;
}
else {
color_name[c++] = y_color_opt->answer[i];
}
}
/* this is lame. I could come up with a color or prompt for one or something */
if (j < num_y_files)
G_fatal_error(_("Only <%d> colors given for <%d> lines"), j,
num_y_files);
}
else
/* no colors given on command line, use default list */
{
for (i = 1; i <= num_y_files; i++) {
in[i].color = default_y_colors[i];
}
}
/* get coordinates of current screen window, in pixels */
D_open_driver();
D_setup_unity(0);
D_get_src(&t, &b, &l, &r);
/* create axis lines, to be drawn later */
height = b - t;
width = r - l;
x_line[0] = x_line[1] = l + (ORIGIN_X * width);
x_line[2] = l + (XAXIS_END * width);
y_line[0] = b - (YAXIS_END * height);
y_line[1] = y_line[2] = b - (ORIGIN_Y * height);
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH;
D_text_size(text_width, text_height);
/* read thru each data file in turn, find max and min values for
each, count lines, find x min and max, find overall y min and
max */
max_y = -99999.9;
min_y = 99999.9;
for (i = 0; i <= num_y_files; i++) {
in[i].min = 99999.9;
in[i].max = -99999.9;
in[i].value = 0.0;
in[i].num_pnts = 0;
while ((err = fscanf(in[i].fp, "%f", &in[i].value)) != EOF) {
in[i].num_pnts++;
in[i].max = MAX(in[i].max, in[i].value);
in[i].min = MIN(in[i].min, in[i].value);
if (i > 0) { /* if we have a y file */
min_y = MIN(min_y, in[i].value);
max_y = MAX(max_y, in[i].value);
}
}
if ((i > 0) && (in[0].num_pnts != in[i].num_pnts)) {
if (in[i].num_pnts < in[0].num_pnts) {
G_warning(_("Y input file <%s> contains fewer data points than the X input file"),
in[i].name);
}
else {
G_warning(_("Y input file <%s> contains more data points than the X input file"),
in[i].name);
}
if (in[i].num_pnts > in[0].num_pnts)
G_message(n_("The last point will be ignored",
"The last %d points will be ignored",
(in[i].num_pnts - in[0].num_pnts)),
(in[i].num_pnts - in[0].num_pnts));
}
}
/* close all files */
for (i = 0; i <= num_y_files; i++)
fclose(in[i].fp);
/* figure scaling factors and offsets */
xscale = ((double)(x_line[2] - x_line[1]) / (double)(in[0].num_pnts));
yscale = ((double)(y_line[1] - y_line[0]) / (max_y - min_y));
yoffset = (double)(y_line[1]);
xoffset = (double)(x_line[1]);
/* figure tic_every and tic_units for the x-axis of the bar-chart.
tic_every tells how often to place a tic-number. tic_unit tells
the unit to use in expressing tic-numbers. */
if (xscale < XTIC_DIST) {
max_tics = (x_line[2] - x_line[1]) / XTIC_DIST;
i = 1;
while (((in[0].max - in[0].min) / tics[i].every) > max_tics)
i++;
tic_every = tics[i].every;
tic_unit = tics[i].unit;
strcpy(tic_name, tics[i].name);
}
else {
tic_every = 1;
tic_unit = 1;
strcpy(tic_name, "");
}
/* open all the data files again */
for (i = 0; i <= num_y_files; i++) {
if ((in[i].fp = fopen(in[i].full_name, "r")) == NULL) {
D_close_driver();
G_fatal_error(_("Unable to open input file <%s>"), in[i].full_name);
}
}
/* loop through number of lines in x data file,
then loop thru for each y file, drawing a piece of each line and a
legend bar on each iteration evenly divisible, a tic-mark
on those evenly divisible by tic_unit, and a tic_mark
number on those evenly divisible by tic_every */
/* read the info from the inputs */
for (line = 0; line < in[0].num_pnts; line++) {
/* scan in an X value */
err = fscanf(in[0].fp, "%f", &in[0].value);
/* didn't find a number or hit EOF before our time */
if ((err != 1) || (err == EOF)) {
D_close_driver();
G_fatal_error(_("Problem reading X data file at line %d"), line);
}
/* for each Y data file, get a value and compute where to draw it */
for (i = 1; i <= num_y_files; i++) {
/* check to see that we do indeed have data for this point */
if (line < in[i].num_pnts) {
err = fscanf(in[i].fp, "%f", &in[i].value);
if ((in[i].num_pnts >= line) && (err != 1)) {
D_close_driver();
G_fatal_error(_("Problem reading <%s> data file at line %d"),
in[i].name, line);
}
/* in case the Y file has fewer lines than the X file, we will skip
trying to draw when we run out of data */
/* draw increment of each Y file's data */
D_use_color(in[i].color);
/* find out position of where Y should be drawn. */
/* if our minimum value of y is not negative, this is easy */
if (min_y >= 0)
new_y[i] =
(yoffset - yscale * (in[i].value - min_y));
/* if our minimum value of y is negative, then we have two
cases: our current value to plot is pos or neg */
else {
if (in[i].value < 0)
new_y[i] = (yoffset - yscale * (-1 *
(min_y -
in[i].value)));
else
new_y[i] = (yoffset - yscale * (in[i].value +
(min_y * -1)));
}
new_x = xoffset + (line * xscale);
if (line == 0) {
prev_x = xoffset;
prev_y[i] = yoffset;
}
D_line_abs(prev_x, prev_y[i], new_x, new_y[i]);
prev_y[i] = new_y[i];
}
}
prev_x = new_x;
/* draw x-axis tic-marks and numbers */
if (rem((long int)in[0].value, tic_every) == 0.0) {
/* draw a numbered tic-mark */
D_use_color(title_color);
D_begin();
D_move_abs(xoffset + line * xscale, b - ORIGIN_Y * (b - t));
D_cont_rel(0, BIG_TIC * (b - t));
D_end();
D_stroke();
if ((in[0].value >= 1) || (in[0].value <= -1) ||
(in[0].value == 0))
sprintf(txt, "%.0f", (in[0].value / tic_unit));
else
sprintf(txt, "%.2f", (in[0].value));
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH;
D_text_size(text_width, text_height);
D_get_text_box(txt, &tt, &tb, &tl, &tr);
while ((tr - tl) > XTIC_DIST) {
text_width *= 0.75;
text_height *= 0.75;
D_text_size(text_width, text_height);
D_get_text_box(txt, &tt, &tb, &tl, &tr);
}
D_pos_abs((xoffset + (line * xscale - (tr - tl) / 2)),
(b - XNUMS_Y * (b - t)));
D_text(txt);
}
else if (rem(line, tic_unit) == 0.0) {
/* draw a tic-mark */
D_use_color(title_color);
D_begin();
D_move_abs(xoffset + line * xscale,
b - ORIGIN_Y * (b - t));
D_cont_rel(0, SMALL_TIC * (b - t));
D_end();
D_stroke();
}
}
/* close all input files */
for (i = 0; i <= num_y_files; i++) {
fclose(in[i].fp);
}
/* draw the x-axis label */
if ((strcmp(title[0]->answer, "") == 0) && (strcmp(tic_name, "") == 0))
*xlabel = '\0';
else
sprintf(xlabel, "X: %s %s", title[0]->answer, tic_name);
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH * 1.5;
D_text_size(text_width, text_height);
D_get_text_box(xlabel, &tt, &tb, &tl, &tr);
D_pos_abs((l + (r - l) / 2 - (tr - tl) / 2),
(b - LABEL_1 * (b - t)));
D_use_color(title_color);
D_text(xlabel);
/* DRAW Y-AXIS TIC-MARKS AND NUMBERS
first, figure tic_every and tic_units for the x-axis of the bar-chart.
tic_every tells how often to place a tic-number. tic_unit tells
the unit to use in expressing tic-numbers. */
if (yscale < YTIC_DIST) {
max_tics = (y_line[1] - y_line[0]) / YTIC_DIST;
i = 1;
while (((max_y - min_y) / tics[i].every) > max_tics)
i++;
tic_every = tics[i].every;
tic_unit = tics[i].unit;
strcpy(tic_name, tics[i].name);
}
else {
tic_every = 1;
tic_unit = 1;
strcpy(tic_name, "");
}
/* Y-AXIS LOOP */
for (i = (int)min_y; i <= (int)max_y; i += tic_unit) {
if (rem(i, tic_every) == 0.0) {
/* draw a tic-mark */
D_begin();
D_move_abs(x_line[0], yoffset - yscale * (i - min_y));
D_cont_rel(-(r - l) * BIG_TIC, 0);
D_end();
D_stroke();
/* draw a tic-mark number */
sprintf(txt, "%d", (i / tic_unit));
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH;
D_text_size(text_width, text_height);
D_get_text_box(txt, &tt, &tb, &tl, &tr);
while ((tt - tb) > YTIC_DIST) {
text_width *= 0.75;
text_height *= 0.75;
D_text_size(text_width, text_height);
D_get_text_box(txt, &tt, &tb, &tl, &tr);
}
D_pos_abs(l + (r - l) * YNUMS_X - (tr - tl) / 2,
yoffset - (yscale * (i - min_y) + 0.5 * (tt - tb)));
D_text(txt);
}
else if (rem(i, tic_unit) == 0.0) {
/* draw a tic-mark */
D_begin();
D_move_abs(x_line[0], (yoffset - yscale * (i - min_y)));
D_cont_rel(-(r - l) * SMALL_TIC, 0);
D_end();
D_stroke();
}
}
/* draw the y-axis label */
if ((strcmp(title[1]->answer, "") == 0) && (strcmp(tic_name, "") == 0))
*xlabel = '\0';
else
sprintf(xlabel, "Y: %s %s", title[1]->answer, tic_name);
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH * 1.5;
D_text_size(text_width, text_height);
D_get_text_box(xlabel, &tt, &tb, &tl, &tr);
D_pos_abs(l + (r - l) / 2 - (tr - tl) / 2, b - LABEL_2 * (b - t));
D_use_color(title_color);
D_text(xlabel);
/* top label */
sprintf(xlabel, "%s", title[2]->answer);
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH * 2.0;
D_text_size(text_width, text_height);
D_get_text_box(xlabel, &tt, &tb, &tl, &tr);
/*
D_move_abs((int)(((r-l)/2)-(tr-tl)/2),
(int) (t+ (b-t)*.07) );
*/
D_pos_abs(l + (r - l) / 2 - (tr - tl) / 2, t + (b - t) * .07);
D_use_color(title_color);
D_text(xlabel);
/* draw x and y axis lines */
D_use_color(title_color);
D_polyline_abs(x_line, y_line, 3);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}