static void plot_axes(void)
{
char str[64];
double scale;
double t, b, l, r;
D_use_color(D_translate_color("red"));
D_begin();
D_move_abs(0, 1);
D_cont_abs(0, 0);
D_cont_abs(1, 0);
D_end();
D_stroke();
D_use_color(D_translate_color(DEFAULT_FG_COLOR));
/* set text size for y-axis labels */
scale = fabs(D_get_u_to_d_yconv());
D_text_size(scale * 0.04, scale * 0.05);
/* plot y-axis label (bottom) */
sprintf(str, "%.1f", min);
D_get_text_box(str, &t, &b, &l, &r);
D_pos_abs(-0.02 - (r - l), 0 - (t - b) / 2);
D_text(str);
/* plot y-axis label (top) */
sprintf(str, "%.1f", max);
D_get_text_box(str, &t, &b, &l, &r);
D_pos_abs(-0.02 - (r - l), 1 - (t - b) / 2);
D_text(str);
}
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);
}
int Init_graphics(void)
{
D_full_screen();
SCREEN_TOP = R_screen_top();
SCREEN_BOTTOM = R_screen_bot();
SCREEN_LEFT = R_screen_left();
SCREEN_RIGHT = R_screen_rite();
BLACK = D_translate_color("black");
BLUE = D_translate_color("blue");
BROWN = D_translate_color("brown");
GREEN = D_translate_color("green");
GREY = D_translate_color("grey");
ORANGE = D_translate_color("orange");
PURPLE = D_translate_color("purple");
RED = D_translate_color("red");
WHITE = D_translate_color("white");
YELLOW = D_translate_color("yellow");
R_standard_color(WHITE);
VIEW_TITLE1 = makeview(97.5, 100.0, 0.0, 50.0);
VIEW_TITLE2 = makeview(97.5, 100.0, 50.0, 100.0);
VIEW_MAP1 = makeview(51.0, 97.5, 0.0, 50.0);
VIEW_MAP2 = makeview(51.0, 97.5, 50.0, 100.0);
VIEW_TITLE1_ZOOM = makeview(47.5, 51.0, 0.0, 50.0);
VIEW_TITLE2_ZOOM = makeview(47.5, 51.0, 50.0, 100.0);
VIEW_MAP1_ZOOM = makeview(2.5, 47.5, 0.0, 50.0);
VIEW_MAP2_ZOOM = makeview(2.5, 47.5, 50.0, 100.0);
VIEW_MENU = makeview(0.0, 2.5, 0.0, 100.0);
Rast_init_colors(&VIEW_MAP1->cell.colors);
Rast_init_colors(&VIEW_MAP2->cell.colors);
return 0;
}
static void set_color(char *tcolor)
{
int r, g, b, color;
if (sscanf(tcolor, "%d:%d:%d", &r, &g, &b) == 3 ||
sscanf(tcolor, "0x%02x%02x%02x", &r, &g, &b) == 3) {
if (r >= 0 && r < 256 && g >= 0 && g < 256 && b >= 0 && b < 256) {
D_RGB_color(r, g, b);
}
}
else {
color = D_translate_color(tcolor);
if (!color) {
G_warning(_("[%s]: No such color. Use '%s'"), tcolor,
DEFAULT_COLOR);
color = D_translate_color(DEFAULT_COLOR);
}
D_use_color(color);
}
return;
}
int Init_graphics(void)
{
R_font("romans");
R_text_size(3 * NORMAL_TEXT_SIZE / 4, NORMAL_TEXT_SIZE);
D_full_screen();
SCREEN_TOP = R_screen_top();
SCREEN_BOTTOM = R_screen_bot();
SCREEN_LEFT = R_screen_left();
SCREEN_RIGHT = R_screen_rite();
BLACK = D_translate_color("black");
BLUE = D_translate_color("blue");
BROWN = D_translate_color("brown");
GREEN = D_translate_color("green");
GREY = D_translate_color("grey");
ORANGE = D_translate_color("orange");
PURPLE = D_translate_color("purple");
RED = D_translate_color("red");
WHITE = D_translate_color("white");
YELLOW = D_translate_color("yellow");
R_standard_color(BLACK);
VIEW_TITLE1 = makeview(97.5, 100.0, 50.0, 100.0);
VIEW_MAP1 = makeview(51.0, 97.5, 50.0, 100.0);
VIEW_TITLE1_ZOOM = makeview(48.5, 51.0, 50.0, 100.0);
VIEW_MAP1_ZOOM = makeview(2.5, 48.5, 50.0, 100.0);
VIEW_MASK1 = makeview(51.0, 97.5, 50.0, 100.0); /*same as map1 */
VIEW_MENU = makeview(0.0, 2.5, 0.0, 100.0);
VIEW_HISTO = makeview(2.5, 100.0, 0.0, 50.0);
return 0;
}
/* CALCULATE THE COORDINATES OF THE TOP LEFT CORNER OF THE SAMPLING UNITS */
static int calc_unit_loc(double radius, int top, int bot, int left, int right,
double ratio, int u_w, int u_l, int method,
double intv, int num, int h_d, int v_d, double *ux,
double *uy, int *sites, double startx, int starty,
int fmask, double nx, double x, double y)
{
char *sites_mapset, sites_file_name[GNAME_MAX], *cmd;
struct Map_info Map;
struct Cell_head region;
double D_u_to_a_col(), D_u_to_a_row();
int i, j, k, cnt = 0, w_w = right - left, w_l = bot - top, exp1, exp2,
dx = w_w, dy = w_l, l, t, left1 = left, top1 = top, n, tmp,
ulrow, ulcol, *row_buf, lap = 0;
static struct line_pnts *Points;
struct line_cats *Cats;
int ltype;
/* VARIABLES:
UNITS FOR ALL DIMENSION VARIABLES IN THIS ROUTINE ARE IN PIXELS
top = sampling frame top row in pixels
bot = sampling frame bottom row in pixels
left = sampling frame left in pixels
right = sampling frame right in pixels
left1 = col of left side of sampling frame or each stratum
top1 = row of top side of sampling frame or each stratum
l = random # cols to be added to left1
r = random # rows to be added to top1
ratio =
u_w = sampling unit width in pixels
u_l = sampling unit length in pixels
method = method of sampling unit distribution (1-5)
intv = interval between sampling units when method=3
num = number of sampling units
h_d = number of horizontal strata
v_d = number of vertical strata
ux =
uy =
sites =
startx = col of UL corner starting pt for strata
starty = row of UL corner starting pt for strata
dx = number of cols per stratum
dy = number of rows per stratum
w_w = width of sampling frame in cols
w_l = length of sampling frame in rows
*/
/* if user hits Ctrl+C, abort this
calculation */
setjmp(jmp);
if (tag) {
tag = 0;
return 0;
}
/* for syst. noncontig. distribution */
if (method == 3) {
u_w += intv;
u_l += intv;
}
/* for stratified random distribution */
if (method == 4) {
dx = (int)((double)(w_w - startx) / (double)(h_d));
dy = (int)((double)(w_l - starty) / (double)(v_d));
}
/* for syst. contig. and noncontig.
distribution */
else if (method == 2 || method == 3) {
if (nx >= num)
dx = (w_w - startx) - (num - 1) * u_w;
else {
dx = (w_w - startx) - (nx - 1) * u_w;
dy = (w_l - starty) - (num / nx - 1) * u_l;
}
}
if (10 > (exp1 = (int)pow(10.0, ceil(log10((double)(dx - u_w + 10))))))
exp1 = 10;
if (10 > (exp2 = (int)pow(10.0, ceil(log10((double)(dy - u_l + 10))))))
exp2 = 10;
/* for random nonoverlapping and stratified
random */
if (method == 1 || method == 4) {
fprintf(stderr,
"\n 'Ctrl+C' and choose fewer units if the requested number");
fprintf(stderr, " is not reached\n");
for (i = 0; i < num; i++) {
/* if Cntl+C */
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
signal(SIGINT, f);
/* for stratified random distribution */
if (method == 4) {
j = 0;
if (n = i % h_d)
left1 += dx;
else {
left1 = left + startx;
if (i < h_d)
top1 = top + starty;
else
top1 += dy;
}
get_rd(exp1, exp2, dx, dy, u_w, u_l, &l, &t);
}
/* for random nonoverlapping distribution */
if (method == 1) {
/* get random numbers */
back:
get_rd(exp1, exp2, dx, dy, u_w, u_l, &l, &t);
if (left1 + l + u_w > right || top1 + t + u_l > bot ||
left1 + l < left || top1 + t < top)
goto back;
/* if there is a mask, check to see that
the unit will be within the mask area */
if (fmask > 0) {
row_buf = Rast_allocate_c_buf();
Rast_get_c_row_nomask(fmask, row_buf, t + top1);
if (!
(*(row_buf + l + left1) &&
*(row_buf + l + left1 + u_w - 1)))
goto back;
Rast_zero_c_buf(row_buf);
Rast_get_c_row_nomask(fmask, row_buf, t + top1 + u_l - 1);
if (!
(*(row_buf + l + left1) &&
*(row_buf + l + left1 + u_w - 1)))
goto back;
G_free(row_buf);
}
/* check for sampling unit overlap */
lap = 0;
for (j = 0; j < cnt; j++) {
if (overlap
(l + left1, t + top1, (int)ux[j], (int)uy[j], u_w,
u_l))
lap = 1;
}
if (lap)
goto back;
cnt++;
}
/* fill the array of upper left coordinates
for the sampling units */
*(ux + i) = l + left1;
*(uy + i) = t + top1;
/* draw the sampling units on the
screen */
R_open_driver();
R_standard_color(D_translate_color("red"));
if (radius)
draw_circle((int)((double)(ux[i]) / x),
(int)((double)(uy[i]) / y),
(int)((double)(ux[i] + u_w) / x),
(int)((double)(uy[i] + u_l) / y), 3);
else
draw_box((int)((double)(ux[i]) / x),
(int)((double)(uy[i]) / y),
(int)((double)(ux[i] + u_w) / x),
(int)((double)(uy[i] + u_l) / y), 1);
R_close_driver();
fprintf(stderr, " Distributed unit %4d of %4d requested\r",
i + 1, num);
}
}
/* for syst. contig. & syst. noncontig. */
else if (method == 2 || method == 3) {
for (i = 0; i < num; i++) {
*(ux + i) =
left + startx + u_w * (i - nx * floor((double)i / nx));
*(uy + i) = top + starty + u_l * floor((double)i / nx);
}
}
/* for centered over sites */
else if (method == 5) {
sites_mapset =
G_ask_vector_old(" Enter name of vector points map",
sites_file_name);
if (sites_mapset == NULL) {
G_system("d.frame -e");
exit(0);
}
if (Vect_open_old(&Map, sites_file_name, sites_mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), sites_file_name);
/* fprintf(stderr, "\n Can't open vector points file %s\n", sites_file_name); */
*sites = 0;
i = 0;
n = 0;
Points = Vect_new_line_struct(); /* init line_pnts struct */
Cats = Vect_new_cats_struct();
while (1) {
ltype = Vect_read_next_line(&Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Cannot read vector"));
if (ltype == -2)
break; /* EOF */
/* point features only. (GV_POINTS is pts AND centroids, GV_POINT is just pts) */
if (!(ltype & GV_POINT))
continue;
ulcol = ((int)(D_u_to_a_col(Points->x[0]))) + 1 - u_w / 2;
ulrow = ((int)(D_u_to_a_row(Points->y[0]))) + 1 - u_l / 2;
if (ulcol <= left || ulrow <= top || ulcol + u_w - 1 > right ||
ulrow + u_l - 1 > bot) {
fprintf(stderr,
" No sampling unit over site %d at east=%8.1f north=%8.1f\n",
n + 1, Points->x[0], Points->y[0]);
fprintf(stderr,
" as it would extend outside the map\n");
}
else {
*(ux + i) = ulcol - 1;
*(uy + i) = ulrow - 1;
i++;
}
n++;
if (n > 250)
G_fatal_error
("There are more than the maximum of 250 sites\n");
}
fprintf(stderr, " Total sites with sampling units = %d\n", i);
*sites = i;
cmd = G_malloc(100);
sprintf(cmd, "d.vect %s color=black", sites_file_name);
G_system(cmd);
G_free(cmd);
Vect_close(&Map);
G_free(Points);
G_free(Cats);
}
return 1;
}
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);
}
/* DEFINE SAMPLING UNITS MANUALLY */
static void man_unit(int t, int b, int l, int r, char *n1, char *n2, char *n3,
double *mx, int fmask)
{
int i, j, dx, dy, w_w, w_l, u_w, u_l,
method, l0, t0, randflag = 0, unit_num, num = 0, scales,
h_d = 1, v_d = 1, itmp, thick, sites, *row_buf, fr, k,
count = 0, maxsize = 0, nx = 0, ny = 0, numx = 0, numy = 0,
al = 0, ar = 0, at = 0, ab = 0, au_w = 0, au_l = 0;
double *ux, *uy;
FILE *fp;
double dtmp, ratio, size, intv = 0.0, start[2], cnt = 0, radius = 0.0;
char *sites_mapset;
struct Cell_head wind;
/* VARIABLES:
COORDINATES IN THIS ROUTINE ARE IN CELLS
t = top row of sampling frame
b = bottom row of sampling frame
l = left col of sampling frame
r = right col of sampling frame
n1 =
n2 =
n3 =
start[0]= row of UL corner of starting pt for strata
start[1]= col of UL corner of starting pt for strata
mx[0] = cols of region/width of screen
mx[1] = rows of region/height of screen
*/
start[0] = 0.0;
start[1] = 0.0;
l = (int)((double)(l * mx[0]) + 0.5);
r = (int)((double)(r * mx[0]) + 0.5);
t = (int)((double)(t * mx[1]) + 0.5);
b = (int)((double)(b * mx[1]) + 0.5);
w_w = r - l;
w_l = b - t;
/* draw the sampling frame */
R_open_driver();
R_standard_color(D_translate_color("grey"));
draw_box((int)(l / mx[0] + 0.5), (int)(t / mx[1] + 0.5),
(int)(r / mx[0] + 0.5), (int)(b / mx[1] + 0.5), 1);
R_close_driver();
/* open the units file for output */
fp = fopen0("r.le.para/units", "w");
G_sleep_on_error(0);
/* get the number of scales */
do {
fprintf(stderr,
"\n How many different SCALES do you want (1-15)? ");
numtrap(1, &dtmp);
if (dtmp > 15 || dtmp < 1) {
fprintf(stderr,
"\n Too many (>15) or too few scales; try again");
}
}
while (dtmp < 1 || dtmp > 15);
fprintf(fp, "%10d # of scales\n", (scales = (int)dtmp));
/* for each scale */
for (i = 0; i < scales; i++) {
for (;;) {
G_system("clear");
radius = 0.0;
fprintf(stderr, "\n\n TYPE IN PARAMETERS FOR SCALE %d:\n",
i + 1);
/* get the distribution method */
fprintf(stderr,
"\n Choose method of sampling unit DISTRIBUTION \n");
fprintf(stderr, " Random nonoverlapping 1\n");
fprintf(stderr, " Systematic contiguous 2\n");
fprintf(stderr, " Systematic noncontiguous 3\n");
fprintf(stderr, " Stratified random 4\n");
fprintf(stderr, " Centered over sites 5\n");
fprintf(stderr, " Exit to setup option menu 6\n\n");
do {
fprintf(stderr, " Which Number? ");
numtrap(1, &dtmp);
if ((method = fabs(dtmp)) > 6 || method < 1) {
fprintf(stderr,
"\n Choice must between 1-5; try again");
}
}
while (method > 6 || method < 1);
if (method == 6)
return;
/* for stratified random distribution,
determine the number of strata */
if (method == 4) {
getstrata:
fprintf(stderr,
"\n Number of strata along the x-axis? (1-60) ");
numtrap(1, &dtmp);
h_d = fabs(dtmp);
fprintf(stderr,
"\n Number of strata along the y-axis? (1-60) ");
numtrap(1, &dtmp);
v_d = fabs(dtmp);
if (h_d < 1 || v_d < 1 || h_d > 60 || v_d > 60) {
fprintf(stderr,
"\n Number must be between 1-60; try again.");
goto getstrata;
}
}
/* for methods with strata */
if (method == 2 || method == 3 || method == 4) {
strata:
fprintf(stderr,
"\n Sampling frame row & col for upper left corner of");
fprintf(stderr,
" the strata?\n Rows are numbered down and columns");
fprintf(stderr,
" are numbered to the right\n Enter 1 1 to start in");
fprintf(stderr, " upper left corner of sampling frame: ");
numtrap(2, start);
start[0] = start[0] - 1.0;
start[1] = start[1] - 1.0;
if (start[0] > w_l || start[0] < 0 ||
start[1] > w_w || start[1] < 0) {
fprintf(stderr,
"\n The starting row and col you entered are outside");
fprintf(stderr,
" the sampling frame\n Try again\n");
goto strata;
}
}
if (method == 4) {
/* call draw_grid with the left, top, width,
length, the number of horizontal and
vertical strata, and the starting row
and col for the strata */
draw_grid((int)(l / mx[0] + 0.5), (int)(t / mx[1] + 0.5),
(int)(w_w / mx[0] + 0.5), (int)(w_l / mx[1] + 0.5),
h_d, v_d, (int)(start[0] / mx[1] + 0.5),
(int)(start[1] / mx[0] + 0.5), mx[0], mx[1]);
if (!G_yes(" Are these strata OK? ", 1)) {
if (G_yes("\n\n Refresh the screen? ", 1)) {
paint_map(n1, n2, n3);
R_open_driver();
R_standard_color(D_translate_color("grey"));
draw_box((int)(l / mx[0] + 0.5),
(int)(t / mx[1] + 0.5),
(int)(r / mx[0] + 0.5),
(int)(b / mx[1] + 0.5), 1);
R_close_driver();
}
goto getstrata;
}
}
/* if sampling using circles */
fprintf(stderr, "\n Do you want to sample using rectangles");
if (!G_yes
("\n (including squares) (y) or circles (n)? ", 1)) {
getradius:
fprintf(stderr,
"\n What radius do you want for the circles? Radius");
fprintf(stderr,
"\n is in pixels; add 0.5 pixels, for the center");
fprintf(stderr,
"\n pixel, to the number of pixels outside the");
fprintf(stderr,
"\n center pixel. Type a real number with one");
fprintf(stderr,
"\n decimal place ending in .5 (e.g., 4.5): ");
numtrap(1, &radius);
if (radius > 100.0) {
fprintf(stderr,
"\n Are you sure that you want such a large");
if (!G_yes("\n radius (> 100 pixels)? ", 1))
goto getradius;
}
ratio = 1.0;
u_w = (int)(2 * radius);
u_l = (int)(2 * radius);
if (fmask > 0) {
count = 0;
row_buf = Rast_allocate_buf(CELL_TYPE);
fr = Rast_open_old(n1, G_mapset());
for (j = t; j < b; j++) {
Rast_zero_buf(row_buf, CELL_TYPE);
Rast_get_row(fr, row_buf, j, CELL_TYPE);
for (k = l; k < r; k++) {
if (*(row_buf + k))
count++;
}
}
G_free(row_buf);
Rast_close(fr);
cnt = (double)(count);
if (cnt)
cnt = sqrt(cnt);
else
cnt = 0;
}
else {
count = (w_l - (int)(start[0])) * (w_w - (int)(start[1]));
}
}
/* if sampling using rectangles/squares */
else {
/* get the width/length ratio */
getratio:
fprintf(stderr,
"\n Sampling unit SHAPE (aspect ratio, #cols/#rows) "
"expressed as real number"
"\n (e.g., 10 cols/5 rows = 2.0) for sampling units "
"of scale %d? ", i + 1);
numtrap(1, &ratio);
if (ratio < 0)
ratio = -ratio;
else if (ratio > 25.0)
if (!G_yes
("\n Are you sure you want such a large ratio? ",
1))
goto getratio;
/* determine the recommended maximum size
for sampling units */
getsize:
dtmp = (ratio > 1) ? 1 / ratio : ratio;
dtmp /= (h_d > v_d) ? h_d * h_d : v_d * v_d;
tryagain:
if (method == 1) {
if (fmask > 0) {
count = 0;
row_buf = Rast_allocate_buf(CELL_TYPE);
fr = Rast_open_old(n1, G_mapset());
for (j = t; j < b; j++) {
Rast_zero_buf(row_buf, CELL_TYPE);
Rast_get_row(fr, row_buf, j, CELL_TYPE);
for (k = l; k < r; k++) {
if (*(row_buf + k))
count++;
}
}
G_free(row_buf);
Rast_close(fr);
cnt = (double)(count);
if (cnt)
cnt = sqrt(cnt);
else
cnt = 0;
maxsize =
((cnt * dtmp / 2) * (cnt * dtmp / 2) >
1.0 / dtmp) ? (cnt * dtmp / 2) * (cnt * dtmp /
2) : 1.0 /
dtmp;
fprintf(stderr,
"\n Recommended maximum SIZE is %d in %d cell total",
maxsize, count);
fprintf(stderr, " area\n");
}
else {
fprintf(stderr, "\n Recommended maximum SIZE is");
fprintf(stderr, " %d in %d pixel total area\n",
(int)((w_l - (int)(start[0])) * (w_w -
(int)(start
[1])) *
dtmp / 2),
(w_l - (int)(start[0])) * (w_w -
(int)(start[1])));
count =
(w_l - (int)(start[0])) * (w_w - (int)(start[1]));
maxsize =
(int)((w_l - (int)(start[0])) * (w_w -
(int)(start[1]))
* dtmp / 2);
}
}
else if (method == 2 || method == 3 || method == 5) {
fprintf(stderr,
"\n Recommended maximum SIZE is %d in %d pixel total",
(int)((w_l - (int)(start[0])) * (w_w -
(int)(start[1]))
* dtmp / 2),
(w_l - (int)(start[0])) * (w_w -
(int)(start[1])));
fprintf(stderr, " area\n");
}
else if (method == 4) {
fprintf(stderr, "\n Recommended maximum SIZE is");
fprintf(stderr, " %d in %d pixel individual",
(int)(w_w * w_l * dtmp / 2),
((w_w - (int)(start[1])) / h_d) * ((w_l -
(int)(start
[0])) /
v_d));
fprintf(stderr, " stratum area\n");
}
/* get the unit size, display the calculated
size, and ask if it is OK */
fprintf(stderr,
" What size (in pixels) for each sampling unit of scale %d? ",
i + 1);
numtrap(1, &size);
thick = 1;
if (size < 15 || ratio < 0.2 || ratio > 5)
thick = 0;
u_w = sqrt(size * ratio);
u_l = sqrt(size / ratio);
fprintf(stderr,
"\n The nearest size is %d cells wide X %d cells high = %d",
u_w, u_l, u_w * u_l);
fprintf(stderr, " cells\n");
if (!u_w || !u_l) {
fprintf(stderr,
"\n 0 cells wide or high is not acceptable; try again");
goto tryagain;
}
if (!G_yes(" Is this SIZE OK? ", 1))
goto getsize;
}
/* for syst. noncontig. distribution, get
the interval between units */
if (method == 3) {
fprintf(stderr,
"\n The interval, in pixels, between the units of scale");
fprintf(stderr, " %d? ", i + 1);
numtrap(1, &intv);
}
/* if the unit dimension + the interval
is too large, print a warning and
try getting another size */
if (u_w + intv > w_w / h_d || u_l + intv > w_l / v_d) {
fprintf(stderr,
"\n Unit size too large for sampling frame; try again\n");
if (radius)
goto getradius;
else
goto getsize;
}
/* for stratified random distribution,
the number of units is the same as
the number of strata */
if (method == 4)
num = h_d * v_d;
/* for the other distributions, calculate the
maximum number of units, then get the
number of units */
else if (method == 1 || method == 2 || method == 3) {
if (method == 1) {
if (!
(unit_num =
calc_num(w_w, w_l, ratio, u_w, u_l, method, intv,
(int)(start[1]), (int)(start[0]), u_w * u_l,
count))) {
fprintf(stderr,
"\n Something wrong with sampling unit size, try again\n");
if (radius)
goto getradius;
else
goto getsize;
}
fprintf(stderr,
"\n Maximum NUMBER of units in scale %d is %d\n",
i + 1, unit_num);
fprintf(stderr,
" Usually 1/2 of this number can be successfully");
fprintf(stderr,
" distributed\n More than 1/2 can sometimes be");
fprintf(stderr, " distributed\n");
}
else if (method == 2 || method == 3) {
numx = floor((double)(w_w - start[1]) / (u_w + intv));
numy = floor((double)(w_l - start[0]) / (u_l + intv));
if (((w_w -
(int)(start[1])) % (numx * (u_w + (int)(intv)))) >=
u_w)
numx++;
if (((w_l -
(int)(start[0])) % (numy * (u_l + (int)(intv)))) >=
u_l)
numy++;
unit_num = numx * numy;
fprintf(stderr,
"\n Maximum NUMBER of units in scale %d is %d as %d",
i + 1, unit_num, numy);
fprintf(stderr, " rows with %d units per row", numx);
}
do {
fprintf(stderr,
"\n What NUMBER of sampling units do you want to try");
fprintf(stderr, " to use? ");
numtrap(1, &dtmp);
if ((num = dtmp) > unit_num || num < 1) {
fprintf(stderr,
"\n %d is greater than the maximum number of",
num);
fprintf(stderr, " sampling units; try again\n");
}
else if (method == 2 || method == 3) {
fprintf(stderr,
"\n How many sampling units do you want per row? ");
numtrap(1, &dtmp);
if ((nx = dtmp) > num) {
fprintf(stderr,
"\n Number in each row > number requested; try");
fprintf(stderr, " again\n");
}
else {
if (nx > numx) {
fprintf(stderr,
"\n Can't fit %d units in each row, try",
nx);
fprintf(stderr, " again\n");
}
else {
if (num % nx)
ny = num / nx + 1;
else
ny = num / nx;
if (ny > numy) {
fprintf(stderr,
"\n Can't fit the needed %d rows, try",
ny);
fprintf(stderr, " again\n");
}
}
}
}
}
while (num > unit_num || num < 1 || nx > num || nx > numx ||
ny > numy);
}
/* dynamically allocate storage for arrays to
store the upper left corner of sampling
units */
if (method != 5) {
ux = G_calloc(num + 1, sizeof(double));
uy = G_calloc(num + 1, sizeof(double));
}
else {
ux = G_calloc(250, sizeof(double));
uy = G_calloc(250, sizeof(double));
}
/* calculate the upper left corner of sampling
units and store them in arrays ux and uy */
if (!calc_unit_loc
(radius, t, b, l, r, ratio, u_w, u_l, method, intv, num, h_d,
v_d, ux, uy, &sites, (int)(start[1]), (int)(start[0]), fmask,
nx, mx[0], mx[1]))
goto last;
signal(SIGINT, SIG_DFL);
if (method == 5)
num = sites;
/* draw the sampling units on the
screen */
if (method == 2 || method == 3 || method == 5) {
R_open_driver();
R_standard_color(D_translate_color("red"));
for (j = 0; j < num; j++) {
if (radius) {
draw_circle((int)((double)(ux[j]) / mx[0]),
(int)((double)(uy[j]) / mx[1]),
(int)((double)(ux[j] + u_w) / mx[0]),
(int)((double)(uy[j] + u_l) / mx[1]), 3);
}
else {
draw_box((int)((double)(ux[j]) / mx[0]),
(int)((double)(uy[j]) / mx[1]),
(int)((double)(ux[j] + u_w) / mx[0]),
(int)((double)(uy[j] + u_l) / mx[1]), 1);
}
}
R_close_driver();
}
if (G_yes("\n Is this set of sampling units OK? ", 1))
break;
last:
signal(SIGINT, SIG_DFL);
if (G_yes("\n Refresh the screen? ", 1)) {
paint_map(n1, n2, n3);
R_open_driver();
R_standard_color(D_translate_color("grey"));
draw_box((int)(l / mx[0]), (int)(t / mx[1]), (int)(r / mx[0]),
(int)(b / mx[1]), 1);
R_close_driver();
}
}
/* save the sampling unit parameters
in r.le.para/units file */
fprintf(fp, "%10d # of units of scale %d.\n", num, (i + 1));
fprintf(fp, "%10d%10d u_w, u_l of units in scale %d\n", u_w, u_l,
(i + 1));
fprintf(fp, "%10.1f radius of circles in scale %d\n",
radius, (i + 1));
for (j = 0; j < num; j++)
fprintf(fp, "%10d%10d left, top of unit[%d]\n", (int)ux[j],
(int)uy[j], j + 1);
if (i < scales - 1 && G_yes("\n\n Refresh the screen? ", 1)) {
paint_map(n1, n2, n3);
R_open_driver();
R_standard_color(D_translate_color("grey"));
draw_box((int)(l / mx[0]), (int)(t / mx[1]), (int)(r / mx[0]),
(int)(b / mx[1]), 1);
R_close_driver();
}
}
/* free dynamically allocated memory */
G_free(ux);
G_free(uy);
fclose(fp);
return;
}
/* FOR STRATIFIED RANDOM DISTRIBUTION, DRAW THE STRATA ON THE SCREEN */
static void draw_grid(int l, int t, int w_w, int w_l, int h_d, int v_d,
int starty, int startx, double colratio,
double rowratio)
{
int j, k, l0, t0, itmp, dx, dy, initl, tmp;
/* VARIABLES:
k = the remainder after dividing the screen width/height
by the number of strata
dx = how many screen cols per stratum
dy = how many screen rows per stratum
l0 = left side of screen + dx
t0 = top of screen + dy
w_w = width of screen
w_l = height of screen
h_d = number of horizontal strata
v_d = number of vertical strata
*/
R_open_driver();
R_standard_color(D_translate_color("orange"));
if (startx > 0) {
dx = (int)((double)((int)(colratio *
((int)
((double)(w_w - startx) /
(double)(h_d)))) / colratio + 0.5));
l0 = l + startx;
}
else {
dx = (int)((double)((int)(colratio *
((int)((double)(w_w) / (double)(h_d)))) /
colratio + 0.5));
l0 = l;
}
if (starty > 0) {
dy = (int)((double)((int)(rowratio *
((int)
((double)(w_l - starty) /
(double)(v_d)))) / rowratio + 0.5));
t0 = t + starty;
}
else {
dy = (int)((double)((int)(rowratio *
((int)((double)(w_l) / (double)(v_d)))) /
rowratio + 0.5));
t0 = t;
}
initl = l0;
/* draw the vertical strata */
for (j = 1; j <= h_d - 1; j++) {
l0 += dx;
R_move_abs(l0, t0);
R_cont_rel(0, w_l - starty);
}
/* draw the horizontal strata */
for (j = 1; j <= v_d - 1; j++) {
t0 += dy;
R_move_abs(initl, t0);
R_cont_rel(w_w - startx, 0);
}
R_close_driver();
return;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *input, *vect;
struct Cell_head window;
int bot, right, t0, b0, l0, r0, clear = 0;
double Rw_l, Rscr_wl;
char *map_name = NULL, *v_name = NULL, *s_name = NULL;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
/* must run in a term window */
G_putenv("GRASS_UI_TERM", "1");
module = G_define_module();
module->keywords = _("raster, landscape structure analysis, patch index");
module->description =
_("Interactive tool used to setup the sampling and analysis framework "
"that will be used by the other r.le programs.");
input = G_define_standard_option(G_OPT_R_MAP);
input->description = _("Raster map to use to setup sampling");
vect = G_define_standard_option(G_OPT_V_INPUT);
vect->key = "vect";
vect->description = _("Vector map to overlay");
vect->required = NO;
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
setbuf(stdout, NULL); /* unbuffered */
setbuf(stderr, NULL);
G_sleep_on_error(1); /* error messages get lost on clear screen */
map_name = input->answer;
v_name = vect->answer;
s_name = NULL; /* sites not used in GRASS 6 */
/* setup the r.le.para directory */
get_pwd();
/* query for the map to be setup */
if (R_open_driver() != 0)
G_fatal_error("No graphics device selected");
/* setup the current window for display & clear screen */
D_setup(1);
Rw_l = (double)G_window_cols() / G_window_rows();
/*R_open_driver(); */
/* R_font("romant"); */
G_get_set_window(&window);
t0 = R_screen_top();
b0 = R_screen_bot();
l0 = R_screen_left();
r0 = R_screen_rite();
Rscr_wl = (double)(r0 - l0) / (b0 - t0);
if (Rscr_wl > Rw_l) {
bot = b0;
right = l0 + (b0 - t0) * Rw_l;
}
else {
right = r0;
bot = t0 + (r0 - l0) / Rw_l;
}
D_new_window("a", t0, bot, l0, right);
D_set_cur_wind("a");
D_show_window(D_translate_color("green"));
D_setup(clear);
R_close_driver();
/* invoke the setup modules */
set_map(map_name, v_name, s_name, window, t0, bot, l0, right);
return (EXIT_SUCCESS);
}
static void graph_unit(int t, int b, int l, int r, char *n1, char *n2,
char *n3, double *mx, int fmask)
{
int x0 = 0, y0 = 0, xp, yp, ux[250], uy[250], u_w, u_l, btn = 0, k = 0,
w_w = 0, w_l = 0, *row_buf, at, ab, al, ar, circle = 0,
tmpw, tmpl, au_w, au_l, lap = 0, l0 = 0, r0 = 0, t0 = 0, b0 = 0;
FILE *fp;
double tmp, radius = 0.0;
register int i, j;
/* VARIABLES:
COORDINATES IN THIS ROUTINE ARE IN CELLS
t = top row of sampling frame
b = bottom row of sampling frame
l = left col of sampling frame
r = right col of sampling frame
n1 =
n2 =
n3 =
mx[0] = cols of region/width of screen
mx[1] = rows of region/height of screen
xp = mouse x location in screen coordinates (col)
yp = mouse y location in screen coordinates (row)
ar = mouse x location in map coordinates (col)
al = mouse y location in map coordinates (row)
*/
l0 = l;
r0 = r;
t0 = t;
b0 = b;
l = (int)((double)(l * mx[0]) + 0.5);
r = (int)((double)(r * mx[0]) + 0.5);
t = (int)((double)(t * mx[1]) + 0.5);
b = (int)((double)(b * mx[1]) + 0.5);
w_w = r - l;
w_l = b - t;
/* draw the sampling frame */
R_open_driver();
R_standard_color(D_translate_color("grey"));
draw_box((int)(l / mx[0]), (int)(t / mx[1]), (int)(r / mx[0]),
(int)(b / mx[1]), 1);
R_close_driver();
fp = fopen0("r.le.para/units", "w");
G_sleep_on_error(0);
/* get the number of scales */
do {
fprintf(stderr,
"\n How many different SCALES do you want? (1-15) ");
numtrap(1, &tmp);
if (tmp < 1 || tmp > 15)
fprintf(stderr,
" Too many (>15) or too few scales, try again.\n");
}
while (tmp < 1 || tmp > 15);
fprintf(fp, "%10d # of scales\n", (int)(tmp));
/* for each scale */
for (i = 0; i < tmp; i++) {
G_system("clear");
radius = 0.0;
circle = 0;
/* if sampling using circles */
fprintf(stderr, "\n SCALE %d\n", i + 1);
fprintf(stderr, "\n Do you want to sample using rectangles");
if (!G_yes("\n (including squares) (y) or circles (n)? ", 1)) {
circle = 1;
fprintf(stderr,
"\n Draw a rectangular area to contain a standard circular");
fprintf(stderr,
"\n sampling unit of scale %d. First select upper left",
i + 1);
fprintf(stderr, "\n corner, then lower right:\n");
fprintf(stderr, " Left button: Check unit size\n");
fprintf(stderr,
" Middle button: Upper left corner of area here\n");
fprintf(stderr,
" Right button: Lower right corner of area here\n");
}
else {
fprintf(stderr,
"\n Draw a standard rectangular unit of scale %d.",
i + 1);
fprintf(stderr,
"\n First select upper left corner, then lower right:\n");
fprintf(stderr, " Left button: Check unit size\n");
fprintf(stderr,
" Middle button: Upper left corner of unit here\n");
fprintf(stderr,
" Right button: Lower right corner of unit here\n");
}
R_open_driver();
do {
back1:
R_get_location_with_box(x0, y0, &xp, &yp, &btn);
/* convert the upper left screen coordinate
(x0, y0) and the mouse position (xp, yp)
on the screen to the nearest row and
column; do the same for the sampling
unit width (u_w) and height (u_l);
then convert back */
ar = (int)((double)(xp) * mx[0] + 0.5);
xp = (int)((double)(ar) / mx[0] + 0.5);
al = (int)((double)(x0) * mx[0] + 0.5);
x0 = (int)((double)(al) / mx[0] + 0.5);
au_w = ar - al;
u_w = (int)((double)(au_w) / mx[0] + 0.5);
ab = (int)((double)(yp) * mx[1] + 0.5);
yp = (int)((double)(ab) / mx[1] + 0.5);
at = (int)((double)(y0) * mx[1] + 0.5);
y0 = (int)((double)(at) / mx[1] + 0.5);
au_l = ab - at;
u_l = (int)((double)(au_l) / mx[1] + 0.5);
/* left button, check the size of the rubber
box in array system */
if (btn == 1) {
if (ar > r || ab > b || ar < l || ab < t) {
fprintf(stderr,
"\n This point is not in the sampling frame; try again\n");
goto back1;
}
if (x0 < l || y0 < t) {
fprintf(stderr,
"\n Use the middle button to first put the upper left");
fprintf(stderr,
"\n corner inside the sampling frame\n");
goto back1;
}
if (ar <= al || ab <= at) {
fprintf(stderr,
"\n Please put the lower right corner down and to");
fprintf(stderr,
"\n the right of the upper left corner\n");
goto back1;
}
else {
fprintf(stderr,
"\n Unit would be %d columns wide by %d rows long\n",
abs(au_w), abs(au_l));
fprintf(stderr,
" Width/length would be %5.2f and size %d pixels\n",
(double)abs((au_w)) / (double)abs((au_l)),
abs(au_w) * abs(au_l));
}
}
/* mid button, move the start point of the
rubber box */
else if (btn == 2) {
if (ar > r || ab > b || ar < l || ab < t) {
fprintf(stderr,
"\n Point is not in the sampling frame; try again\n");
goto back1;
}
else {
R_move_abs(xp, yp);
x0 = xp;
y0 = yp;
}
}
/* right button, outline the unit */
else if (btn == 3) {
if (circle) {
if (u_w > u_l) {
al = al + ((ar - al) - (ab - at)) / 2;
ar = al + (ab - at);
x0 = (int)((double)(al) / mx[0] + 0.5);
xp = (int)((double)(ar) / mx[0] + 0.5);
au_w = ar - al;
u_w = u_l = (int)((double)(au_w) / mx[0] + 0.5);
}
if (u_l > u_w) {
at = at + ((ab - at) - (ar - al)) / 2;
ab = at + (ar - al);
y0 = (int)((double)(at) / mx[1] + 0.5);
yp = (int)((double)(ab) / mx[1] + 0.5);
au_l = ab - at;
u_w = u_l = (int)((double)(au_l) / mx[1] + 0.5);
}
}
if (ar > r || ab > b || al < l || at < t) {
fprintf(stderr,
"\n The unit extends outside the sampling frame or map;");
fprintf(stderr, "\n try again\n");
goto back1;
}
if (au_w > w_w || au_l > w_l) {
fprintf(stderr,
"\n The unit is too big for the sampling frame; ");
fprintf(stderr, "try again\n");
goto back1;
}
/* if there is a mask, check to see that
the unit will be within the mask area,
by checking to see whether the four
corners of the unit are in the mask */
if (fmask > 0) {
row_buf = Rast_allocate_c_buf();
Rast_get_c_row_nomask(fmask, row_buf, at);
if (!(*(row_buf + al) && *(row_buf + ar - 1))) {
fprintf(stderr,
"\n The unit would be outside the mask; ");
fprintf(stderr, "try again\n");
G_free(row_buf);
goto back1;
}
Rast_zero_c_buf(row_buf);
Rast_get_c_row_nomask(fmask, row_buf, ab - 1);
if (!(*(row_buf + al) && *(row_buf + ar - 1))) {
fprintf(stderr,
"\n The unit would be outside the mask; ");
fprintf(stderr, "try again\n");
G_free(row_buf);
goto back1;
}
G_free(row_buf);
}
if (xp - x0 > 0 && yp - y0 > 0) {
R_standard_color(D_translate_color("red"));
if (circle)
draw_circle(x0, y0, xp, yp, 3);
else
draw_box(x0, y0, xp, yp, 1);
G_system("clear");
if (circle) {
fprintf(stderr,
"\n\n The standard circular sampling unit has:\n");
fprintf(stderr, " radius = %f pixels\n",
(double)(ar - al) / 2.0);
}
else {
fprintf(stderr,
"\n\n The standard sampling unit has:\n");
fprintf(stderr, " columns=%d rows=%d\n",
abs(ar - al), abs(ab - at));
fprintf(stderr, " width/length ratio=%5.2f\n",
(double)abs(ar - al) / (double)abs(ab - at));
fprintf(stderr, " size=%d pixels\n",
abs(ar - al) * abs(ab - at));
}
k = 0;
ux[0] = al;
uy[0] = at;
}
else if (xp - x0 == 0 || yp - y0 == 0) {
fprintf(stderr,
"\n Unit has 0 rows and/or 0 columns; try again\n");
goto back1;
}
else {
fprintf(stderr,
"\n You did not put the lower right corner below");
fprintf(stderr,
"\n and to the right of the upper left corner. Please try again");
goto back1;
}
}
}
while (btn != 3);
R_close_driver();
/* use the size and shape of the
standard unit to outline more units
in that scale */
fprintf(stderr, "\n Outline more sampling units of scale %d?\n",
i + 1);
fprintf(stderr, " Left button: Exit\n");
fprintf(stderr, " Middle button: Check unit position\n");
fprintf(stderr,
" Right button: Lower right corner of next unit here\n");
R_open_driver();
/* if not the left button (to exit) */
back2:
while (btn != 1) {
R_get_location_with_box(xp - u_w, yp - u_l, &xp, &yp, &btn);
/* convert the left (x0), right (y0),
top (y0), bottom (yp) coordinates in
screen pixels to the nearest row and
column; do the same for the sampling
unit width (u_w) and height (u_l);
then convert back */
ar = (int)((double)(xp) * mx[0] + 0.5);
ab = (int)((double)(yp) * mx[1] + 0.5);
xp = (int)((double)(ar) / mx[0] + 0.5);
yp = (int)((double)(ab) / mx[1] + 0.5);
al = (int)((double)(xp - u_w) * mx[0] + 0.5);
at = (int)((double)(yp - u_l) * mx[0] + 0.5);
x0 = (int)((double)(al) / mx[0] + 0.5);
y0 = (int)((double)(at) / mx[1] + 0.5);
/* if right button, outline the unit */
if (btn == 3) {
if (ar > r || ab > b || al < l || at < t) {
fprintf(stderr,
"\n The unit would be outside the map; try again");
goto back2;
}
/* if there is a mask, check to see that
the unit will be within the mask area */
if (fmask > 0) {
row_buf = Rast_allocate_c_buf();
Rast_get_c_row_nomask(fmask, row_buf, at);
if (!(*(row_buf + al) && *(row_buf + ar - 1))) {
fprintf(stderr,
"\n The unit would be outside the mask; ");
fprintf(stderr, "try again");
G_free(row_buf);
goto back2;
}
Rast_zero_c_buf(row_buf);
Rast_get_c_row_nomask(fmask, row_buf, ab - 1);
if (!(*(row_buf + al) && *(row_buf + ar - 1))) {
fprintf(stderr,
"\n The unit would be outside the mask; ");
fprintf(stderr, "try again");
G_free(row_buf);
goto back2;
}
G_free(row_buf);
}
/* check for sampling unit overlap */
lap = 0;
for (j = 0; j < k + 1; j++) {
if (overlap(al, at, ux[j], uy[j], au_w, au_l)) {
fprintf(stderr,
"\n The unit would overlap a previously drawn ");
fprintf(stderr, "unit; try again");
lap = 1;
}
}
if (lap)
goto back2;
k++;
fprintf(stderr, "\n %d sampling units have been placed",
(k + 1));
ux[k] = al;
uy[k] = at;
R_standard_color(D_translate_color("red"));
if (circle)
draw_circle(x0, y0, xp, yp, 3);
else
draw_box(x0, y0, xp, yp, 1);
}
}
R_close_driver();
/* save the sampling units in the
r.le.para/units file */
if (circle)
radius = (double)(ar - al) / 2.0;
else
radius = 0.0;
fprintf(fp, "%10d # of units of scale %d\n", k + 1, i + 1);
fprintf(fp, "%10d%10d u_w, u_l of units in scale %d\n",
(int)(u_w * mx[0]), (int)(u_l * mx[1]), i + 1);
fprintf(fp, "%10.1f radius of circles in scale %d\n",
radius, (i + 1));
for (j = 0; j < k + 1; j++)
fprintf(fp, "%10d%10d left, top of unit[%d]\n", ux[j], uy[j],
j + 1);
if (i < tmp - 1 && G_yes("\n Refresh the screen? ", 1)) {
paint_map(n1, n2, n3);
R_open_driver();
R_standard_color(D_translate_color("red"));
R_close_driver();
}
}
fclose(fp);
return;
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *map, *profile;
struct Flag *stored;
struct Cell_head window;
struct point *points = NULL;
int num_points, max_points = 0;
double length;
double t, b, l, r;
int fd;
int i;
double sx;
int last;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("profile"));
G_add_keyword(_("raster"));
module->description = _("Plots profile of a transect.");
/* set up command line */
map = G_define_standard_option(G_OPT_R_INPUT);
map->description = _("Raster map to be profiled");
profile = G_define_option();
profile->key = "profile";
profile->type = TYPE_DOUBLE;
profile->required = YES;
profile->multiple = YES;
profile->key_desc = "east,north";
profile->description = _("Profile coordinate pairs");
stored = G_define_flag();
stored->key = 'r';
stored->description = _("Use map's range recorded range");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
mapname = map->answer;
fd = Rast_open_old(mapname, "");
if (stored->answer)
get_map_range();
else
get_region_range(fd);
G_get_window(&window);
num_points = 0;
length = 0;
for (i = 0; profile->answers[i]; i += 2) {
struct point *p;
double x, y;
if (num_points >= max_points) {
max_points = num_points + 100;
points = G_realloc(points, max_points * sizeof(struct point));
}
p = &points[num_points];
G_scan_easting( profile->answers[i+0], &x, G_projection());
G_scan_northing(profile->answers[i+1], &y, G_projection());
p->x = Rast_easting_to_col (x, &window);
p->y = Rast_northing_to_row(y, &window);
if (num_points > 0) {
const struct point *prev = &points[num_points-1];
double dx = fabs(p->x - prev->x);
double dy = fabs(p->y - prev->y);
double d = sqrt(dx * dx + dy * dy);
length += d;
p->d = length;
}
num_points++;
}
points[0].d = 0;
if (num_points < 2)
G_fatal_error(_("At least two points are required"));
/* establish connection with graphics driver */
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
D_setup2(1, 0, 1.05, -0.05, -0.15, 1.05);
plot_axes();
D_use_color(D_translate_color(DEFAULT_FG_COLOR));
D_get_src(&t, &b, &l, &r);
t -= 0.1 * (t - b);
b += 0.1 * (t - b);
l += 0.1 * (r - l);
r -= 0.1 * (r - l);
D_begin();
i = 0;
last = 0;
for (sx = 0; sx < 1; sx += D_get_d_to_u_xconv()) {
double d = length * (sx - l);
const struct point *p, *next;
double k, sy, x, y;
DCELL v;
for (;;) {
p = &points[i];
next = &points[i + 1];
k = (d - p->d) / (next->d - p->d);
if (k < 1)
break;
i++;
}
x = p->x * (1 - k) + next->x * k;
y = p->y * (1 - k) + next->y * k;
if (!get_cell(&v, fd, x, y)) {
last = 0;
continue;
}
sy = (v - min) / (max - min);
if (last)
D_cont_abs(sx, sy);
else
D_move_abs(sx, sy);
last = 1;
}
D_end();
D_stroke();
D_close_driver();
exit(EXIT_SUCCESS);
}
int bar(struct stat_list *dist_stats, /* list of distribution statistics */
struct Colors *colors)
{
struct stat_node *ptr;
int draw = YES;
long int bar_height; /* height, in pixels, of a histogram bar */
CELL bar_color; /* color/category number of a histogram bar */
DCELL dmax, range_dmin, range_dmax, dmin, dval;
long int max_tics; /* maximum tics allowed on an axis */
long int xoffset; /* offset for x-axis */
long int yoffset; /* offset for y-axis */
long int stat_start;
long int stat_finis;
int text_height;
int text_width;
long int i, j;
long int num_cats = 0;
long int num_stats = 0;
long int tic_every; /* spacing, in units of category value, of tics */
long int tic_unit;
double t, b, l, r;
double tt, tb, tl, tr;
double x_line[3]; /* for border of histogram */
double y_line[3];
double x_box[5]; /* for histogram bar coordinates */
double y_box[5];
double height, width;
double xscale; /* scaling factors */
double yscale;
char xlabel[1024];
char ylabel[1024];
char txt[1024];
char tic_name[80];
/* get coordinates of current screen window */
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);
/* figure scaling factors and offsets */
num_cats = dist_stats->maxcat - dist_stats->mincat + 1;
if (nodata) {
num_cats++;
dist_stats->mincat--;
}
xscale = ((x_line[2] - x_line[1]) / ((double)num_cats));
yscale = ((y_line[1] - y_line[0])) / dist_stats->maxstat;
if (num_cats >= x_line[2] - x_line[1])
xoffset = (long int)x_line[1];
else
xoffset = (long int)x_line[0] + 0.5 * xscale; /* boxes need extra space */
yoffset = (double)(y_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;
if (nodata)
max_tics--;
i = 0;
if (is_fp) {
Rast_get_fp_range_min_max(&fp_range, &range_dmin, &range_dmax);
if (Rast_is_d_null_value(&range_dmin) ||
Rast_is_d_null_value(&range_dmax))
G_fatal_error("Floating point data range is empty");
if ((range_dmax - range_dmin) < 1.0)
tics[i].every = 5;
if ((range_dmax - range_dmin) < 110)
tics[i].every = 20; /* dirrty hack */
while ((range_dmax - range_dmin) / tics[i].every > max_tics)
i++;
}
else {
while ((num_cats / tics[i].every) > max_tics)
i++;
}
tic_every = tics[i].every;
tic_unit = tics[i].unit;
strcpy(tic_name, tics[i].name);
}
else {
if (is_fp && !cat_ranges) {
Rast_get_fp_range_min_max(&fp_range, &range_dmin, &range_dmax);
if (Rast_is_d_null_value(&range_dmin) ||
Rast_is_d_null_value(&range_dmax))
G_fatal_error("Floating point data range is empty");
}
tic_every = 1;
tic_unit = 1;
}
/* X-AXIS LOOP
*
* loop through category range, drawing a pie-slice 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
*
*/
ptr = dist_stats->ptr;
for (i = dist_stats->mincat; i <= dist_stats->maxcat; i++) {
if (!ptr)
break;
draw = NO;
/* figure bar color and height
*
* the cat number determines the color, the corresponding stat,
* determines the bar height. if a stat cannot be found for the
* cat, then it doesn't drow anything, before it used to draw the
* box of size 0 in black. Later when the option to provide the
* background color will be added , we might still draw a box in
* this color.
*/
if (nodata && i == dist_stats->mincat) {
if (dist_stats->null_stat == 0 && xscale > 1)
draw = NO;
else {
draw = YES;
Rast_set_c_null_value(&bar_color, 1);
bar_height =
(yoffset - yscale * (double)dist_stats->null_stat);
}
}
else if (ptr->cat == i) { /* AH-HA!! found the stat */
if (ptr->stat == 0 && xscale > 1)
draw = NO;
else {
draw = YES;
bar_color = ptr->cat;
bar_height = (yoffset - yscale * (double)ptr->stat);
}
if (ptr->next != NULL)
ptr = ptr->next;
}
else { /* we have to look for the stat */
/* loop until we find it, or pass where it should be */
while (ptr->cat < i && ptr->next != NULL)
ptr = ptr->next;
if (ptr->cat == i) { /* AH-HA!! found the stat */
if (ptr->stat == 0 && xscale > 1)
draw = NO;
else {
draw = YES;
bar_color = ptr->cat;
bar_height = (yoffset - yscale * (double)ptr->stat);
}
if (ptr->next != NULL)
ptr = ptr->next;
}
else { /* stat cannot be found */
if (xscale > 1) {
draw = NO;
#ifdef notdef
draw = YES;
bar_color = D_translate_color("black");
bar_height = yoffset; /* zero */
#endif
}
else
draw = NO;
}
}
/* draw the bar */
if (draw == YES) {
if (xscale != 1) {
/* draw the bar as a box */
if (!Rast_is_c_null_value(&bar_color) && is_fp) {
if (cat_ranges)
Rast_get_ith_d_cat(&cats, bar_color,
&dmin, &dmax);
else {
dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;
dmax = range_dmin + (i + 1) * (range_dmax - range_dmin) / nsteps;
}
if (dmin != dmax) {
for (j = 0; j < xscale; j++) {
dval = dmin + j * (dmax - dmin) / xscale;
D_d_color(dval, colors);
x_box[0] = x_box[1] =
xoffset + ((i - dist_stats->mincat) * xscale -
0.5 * xscale + j);
x_box[2] = x_box[3] =
xoffset + ((i - dist_stats->mincat) * xscale -
0.5 * xscale + j + 1);
y_box[0] = y_box[3] = yoffset;
y_box[1] = y_box[2] = bar_height;
D_polygon_abs(x_box, y_box, 4);
}
}
else { /* 1-color bar */
D_d_color(dmin, colors);
x_box[0] = x_box[1] =
xoffset + ((i - dist_stats->mincat) * xscale -
0.5 * xscale);
x_box[2] = x_box[3] =
xoffset + ((i - dist_stats->mincat) * xscale +
0.5 * xscale);
y_box[0] = y_box[3] = yoffset;
y_box[1] = y_box[2] = bar_height;
D_polygon_abs(x_box, y_box, 4);
}
} /* fp */
else { /* 1-color bar for int data or null */
D_color((CELL) bar_color, colors);
x_box[0] = x_box[1] =
xoffset + ((i - dist_stats->mincat) * xscale -
0.5 * xscale);
x_box[2] = x_box[3] =
xoffset + ((i - dist_stats->mincat) * xscale +
0.5 * xscale);
y_box[0] = y_box[3] = yoffset;
y_box[1] = y_box[2] = bar_height;
D_polygon_abs(x_box, y_box, 4);
}
}
else {
/* draw the bar as a line */
if (is_fp) {
if (cat_ranges)
Rast_get_ith_d_cat(&cats, bar_color,
&dmin, &dmax);
else {
dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;
dmax = range_dmin + (i + 1) * (range_dmax - range_dmin) / nsteps;
}
D_d_color(dmin, colors);
}
else
D_color((CELL) bar_color, colors);
x_box[0] = x_box[1] =
xoffset + (i - dist_stats->mincat) * xscale;
y_box[0] = yoffset;
y_box[1] = bar_height;
D_line_abs(x_box[0], y_box[0], x_box[1], y_box[1]);
}
}
/* draw x-axis tic-marks and numbers */
/* draw tick for null and for numbers at every tic step
except when there is null, don't draw tic for mincat+1 */
if (((rem((long int)i, tic_every) == 0L) ||
((i == dist_stats->mincat) && nodata))
&& !(nodata && i == dist_stats->mincat + 1)) {
/* draw a numbered tic-mark */
D_use_color(color);
D_begin();
D_move_abs(xoffset + (i - dist_stats->mincat) * xscale - 0.5 * xscale,
b - ORIGIN_Y * (b - t));
D_cont_rel(0, BIG_TIC * (b - t));
D_end();
D_stroke();
if (nodata && i == dist_stats->mincat)
sprintf(txt, "null");
else if (is_fp) {
dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;
if ((tic_every * (range_dmax - range_dmin) / nsteps) < 1.0)
sprintf(txt, "%.2f", dmin / (double)tic_unit);
else
sprintf(txt, "%d", (int)(dmin / (double)tic_unit));
}
else
sprintf(txt, "%d", (int)(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 ((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 + (i - dist_stats->mincat) * xscale - 0.5 * xscale - (tr - tl) / 2,
b - XNUMS_Y * (b - t));
D_text(txt);
}
else if (rem(i, tic_unit) == 0.0) {
/* draw a tic-mark */
D_use_color(color);
D_begin();
D_move_abs(xoffset + (i - dist_stats->mincat) * xscale - 0.5 * xscale,
b - ORIGIN_Y * (b - t));
D_cont_rel(0, SMALL_TIC * (b - t));
D_end();
D_stroke();
}
}
/* draw the x-axis label */
if (tic_unit != 1)
sprintf(xlabel, "X-AXIS: Cell Values %s", tic_name);
else
sprintf(xlabel, "X-AXIS: Cell Values");
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH;
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(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.
*/
max_tics = (long)((y_line[1] - y_line[0]) / YTIC_DIST);
if (dist_stats->maxstat == dist_stats->minstat)
dist_stats->minstat = 0; /* LOOKS FUNNY TO ME */
num_stats = dist_stats->maxstat - dist_stats->minstat;
i = 0;
while ((num_stats / tics[i].every) > max_tics)
i++;
tic_every = tics[i].every;
tic_unit = tics[i].unit;
strcpy(tic_name, tics[i].name);
stat_start = tic_unit * ((long)(dist_stats->minstat / tic_unit));
stat_finis = tic_unit * ((long)(dist_stats->maxstat / tic_unit));
/* Y-AXIS LOOP
*
*/
for (i = stat_start; i <= stat_finis; i += tic_unit) {
if (rem(i, tic_every) == (float)0) {
/* draw a tic-mark */
D_begin();
D_move_abs(x_line[0], yoffset - yscale * i);
D_cont_rel((-(r - l) * BIG_TIC), 0);
D_end();
D_stroke();
/* draw a tic-mark number */
sprintf(txt, "%d", (int)(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 + 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);
D_cont_rel(-(r - l) * SMALL_TIC, 0);
D_end();
D_stroke();
}
}
/* draw the y-axis label */
if (tic_unit != 1) {
if (type == COUNT)
sprintf(ylabel, "Y-AXIS: Number of cells %s", tic_name);
else
sprintf(ylabel, "Y-AXIS: Area %s sq. meters", tic_name);
}
else {
if (type == COUNT)
sprintf(ylabel, "Y-AXIS: Number of cells");
else
sprintf(ylabel, "Y-AXIS: Area");
}
text_height = (b - t) * TEXT_HEIGHT;
text_width = (r - l) * TEXT_WIDTH;
D_text_size(text_width, text_height);
D_get_text_box(ylabel, &tt, &tb, &tl, &tr);
D_pos_abs(l + (r - l) / 2 - (tr - tl) / 2,
b - LABEL_2 * (b - t));
D_use_color(color);
D_text(ylabel);
/* draw x and y axis lines */
D_use_color(color);
D_polyline_abs(x_line, y_line, 3);
return 0;
}
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)
{
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);
}
static void set_frame(double *msc, int *t, int *b, int *l, int *r)
{
int t0, b0, l0, r0, btn;
/* record the initial boundaries of the map */
t0 = *t;
b0 = *b;
l0 = *l;
r0 = *r;
/* if the total area to be sampled will be the
whole map */
G_system("clear");
if (G_yes
("\n Will the sampling frame (total area within which sampling\n units are distributed) be the whole map? ",
1)) {
R_open_driver();
R_standard_color(D_translate_color("grey"));
draw_box(*l, *t, *r, *b, 1);
R_close_driver();
fprintf(stderr, "\n Sampling frame set to whole map");
}
/* if the total area to be sampled is not the
whole map, then have the user draw the
area */
else {
back:
G_system("clear");
fprintf(stderr, " \n OUTLINE SAMPLING FRAME:\n");
R_open_driver();
fprintf(stderr,
"\n Please move cursor to the UPPER-LEFT corner of\n");
fprintf(stderr,
" the sampling frame and click any mouse button\n");
R_get_location_with_line(0, 0, l, t, &btn);
fprintf(stderr,
"\n Please move cursor to the LOWER-RIGHT corner of\n");
fprintf(stderr,
" the sampling frame and click any mouse button again\n");
back2:
R_get_location_with_box(*l, *t, r, b, &btn);
/* check that sampling frame is in map */
if (*l < l0 || *r > r0 || *t < t0 || *b > b0) {
fprintf(stderr,
"\n The cursor is outside of the map, try again\n");
goto back;
}
/* check that cursor is below & to right */
if (*r <= *l || *b <= *t) {
fprintf(stderr,
"\n Please put the lower right corner below and to the");
fprintf(stderr, "\n right of the upper left corner\n");
goto back2;
}
R_standard_color(D_translate_color("grey"));
*l = (int)((double)((int)(*l * msc[0] + 0.5)) / msc[0]);
*r = (int)((double)((int)(*r * msc[0] + 0.5)) / msc[0]);
*t = (int)((double)((int)(*t * msc[1] + 0.5)) / msc[1]);
*b = (int)((double)((int)(*b * msc[1] + 0.5)) / msc[1]);
draw_box(*l, *t, *r, *b, 1);
R_close_driver();
fprintf(stderr,
"\n Sampling frame is set to the area you just drew");
}
return;
}
static void change_draw(void)
{
int method;
double dtmp;
G_system("clear");
fprintf(stderr, "\n\n CHOOSE THE COLOR FOR DRAWING:\n\n");
fprintf(stderr, " Red 1\n");
fprintf(stderr, " Orange 2\n");
fprintf(stderr, " Yellow 3\n");
fprintf(stderr, " Green 4\n");
fprintf(stderr, " Blue 5\n");
fprintf(stderr, " Indigo 6\n");
fprintf(stderr, " White 7\n");
fprintf(stderr, " Black 8\n");
fprintf(stderr, " Brown 9\n");
fprintf(stderr, " Magenta 10\n");
fprintf(stderr, " Aqua 11\n");
fprintf(stderr, " Gray 12\n\n");
do {
fprintf(stderr, "\n Which Number? ");
numtrap(1, &dtmp);
if ((method = fabs(dtmp)) > 12 || method < 1) {
fprintf(stderr, "\n Choice must between 1-12; try again");
}
}
while (method > 12 || method < 1);
if (method == 1)
R_standard_color(D_translate_color("red"));
else if (method == 2)
R_standard_color(D_translate_color("orange"));
else if (method == 3)
R_standard_color(D_translate_color("yellow"));
else if (method == 4)
R_standard_color(D_translate_color("green"));
else if (method == 5)
R_standard_color(D_translate_color("blue"));
else if (method == 6)
R_standard_color(D_translate_color("indigo"));
else if (method == 7)
R_standard_color(D_translate_color("white"));
else if (method == 8)
R_standard_color(D_translate_color("black"));
else if (method == 9)
R_standard_color(D_translate_color("brown"));
else if (method == 10)
R_standard_color(D_translate_color("magenta"));
else if (method == 11)
R_standard_color(D_translate_color("aqua"));
else if (method == 12)
R_standard_color(D_translate_color("gray"));
return;
}
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);
}
