int Input_other(int (*function) (), char *type)
{
int stat;
char msg[1024];
sprintf(msg, "%s input required", type);
Menu_msg(msg);
stat = (*function) ();
if (active)
use_mouse_msg();
Menu_msg("");
return stat;
}
int error(const char *msg, int fatal)
{
char buf[200];
int x, y, button;
Curses_clear_window(PROMPT_WINDOW);
Curses_write_window(PROMPT_WINDOW, 1, 1, "LOCATION:\n");
Curses_write_window(PROMPT_WINDOW, 1, 12, G_location());
Curses_write_window(PROMPT_WINDOW, 2, 1, "MAPSET:\n");
Curses_write_window(PROMPT_WINDOW, 2, 12, G_location());
Beep();
if (fatal)
sprintf(buf, _("ERROR: %s"), msg);
else
sprintf(buf, _("WARNING: %s (click mouse to continue)"), msg);
Menu_msg(buf);
if (fatal)
quit(1);
Mouse_pointer(&x, &y, &button);
Curses_clear_window(PROMPT_WINDOW);
return 0;
}
static int to_printer(void)
{
FILE *fd;
cancel_which();
Menu_msg("Sending report to printer ...");
Curses_write_window(PROMPT_WINDOW, 1, 1, "Sending report to printer ...");
fd = popen("lp", "w");
do_report(fd);
pclose(fd);
return 0;
}
static int mouse(Objects * objects, int ax, int ay, int box)
{
int first;
int stat;
int x, y, button;
Objects *obj;
first = !active;
active = 1;
if (first)
use_mouse_msg();
if (box) {
x = ax + 20;
y = ay + 20;
}
stat = 0;
replot = 1;
while (stat == 0) {
if (replot) {
replot = 0;
draw_objects(objects);
}
if (box)
Mouse_box_anchored(ax, ay, &x, &y, &button);
else
Mouse_pointer(&x, &y, &button);
if (!(obj = find(objects, x, y)))
continue;
switch (obj->type) {
case MENU_OBJECT:
case OTHER_OBJECT:
stat = (*obj->handler) (x, y, button);
break;
case OPTION_OBJECT:
select_option(objects, obj);
draw_option_boxes(objects);
break;
}
}
/* if we are first call, mark not active
* indicate that objects above use must be replotted.
*/
if (first)
active = 0;
Menu_msg("");
return stat;
}
int ask_magnification(int *magnification)
{
static int use = 1;
int x, y;
int height;
int stat;
int width;
int top, bottom, left, right;
static Objects objects[] = {
OTHER(incr, &use),
{0}
};
Menu_msg("");
mag = *magnification;
if (mag < 1)
mag = 1;
height = VIEW_MENU->nrows;
R_text_size(height - 4, height - 4);
Get_mouse_xy(&x, &y);
top = y - height / 2;
if (top < SCREEN_TOP)
top = SCREEN_TOP;
bottom = top + 4 * height;
if (bottom >= VIEW_MENU->top) {
top -= bottom - (VIEW_MENU->top - 1);
bottom = VIEW_MENU->top - 1;
}
width = Text_width("MAGNIFICATION") + 4;
left = x - width / 2;
if (left < SCREEN_LEFT)
left = SCREEN_LEFT;
right = left + width;
if (right > SCREEN_RIGHT) {
left -= right - SCREEN_RIGHT;
right = SCREEN_RIGHT;
}
R_panel_save(tempfile1, top, bottom, left, right);
R_standard_color(WHITE);
R_box_abs(left, top, right, bottom);
R_standard_color(BLACK);
Outline_box(top, bottom, left, right);
plus.top = top + height;
plus.bottom = plus.top + height;
plus.left = left;
plus.right = plus.left + Text_width("++") + 4;
Outline_box(plus.top, plus.bottom, plus.left, plus.right);
minus.top = top + height;
minus.bottom = minus.top + height;
minus.right = right;
minus.left = minus.right - Text_width("--") - 4;
Outline_box(minus.top, minus.bottom, minus.left, minus.right);
value.top = top + height;
value.bottom = value.top + height;
value.left = plus.right;
value.right = minus.left;
Outline_box(value.top, value.bottom, value.left, value.right);
accept.top = value.bottom;
accept.bottom = accept.top + height;
accept.left = left;
accept.right = right;
Outline_box(accept.top, accept.bottom, accept.left, accept.right);
cancel.top = accept.bottom;
cancel.bottom = cancel.top + height;
cancel.left = left;
cancel.right = right;
Outline_box(cancel.top, cancel.bottom, cancel.left, cancel.right);
dotext("MAGNIFICATION", top, top + height, left, right, WHITE);
dotext("+", plus.top, plus.bottom, plus.left, plus.right, GREY);
dotext("-", minus.top, minus.bottom, minus.left, minus.right, GREY);
dotext("ACCEPT", accept.top, accept.bottom, accept.left, accept.right,
GREY);
dotext("CANCEL", cancel.top, cancel.bottom, cancel.left, cancel.right,
GREY);
draw_mag();
stat = Input_pointer(objects);
/* to respond to user */
R_standard_color(WHITE);
R_box_abs(left, top, right, bottom);
R_flush();
R_panel_restore(tempfile1);
R_panel_delete(tempfile1);
*magnification = mag;
return stat > 0;
}
static int zoom1(int x, int y)
{ /* called by Input_pointer */
int top, bottom, left, right;
int n, row, col;
int nrows, ncols;
struct Cell_head cellhd;
int mag;
double magnification();
double north, south, east, west;
if (In_view(pick_view = VIEW_MAP1, x, y)) {
main_view = VIEW_MAP1;
zoom_view = VIEW_MAP1_ZOOM;
target_flag = 0;
}
else if (In_view(pick_view = VIEW_MAP2, x, y)) {
if (!pick_view->cell.configured)
return 0; /* ignore the mouse event */
main_view = VIEW_MAP2;
zoom_view = VIEW_MAP2_ZOOM;
target_flag = 1;
}
else if (In_view(pick_view = VIEW_MAP1_ZOOM, x, y)) {
if (!pick_view->cell.configured)
return 0; /* ignore the mouse event */
main_view = VIEW_MAP1;
zoom_view = VIEW_MAP1_ZOOM;
target_flag = 0;
}
else if (In_view(pick_view = VIEW_MAP2_ZOOM, x, y)) {
if (!pick_view->cell.configured)
return 0; /* ignore the mouse event */
main_view = VIEW_MAP2;
zoom_view = VIEW_MAP2_ZOOM;
target_flag = 1;
}
else
return 0; /* ignore the mouse event */
if (!pick_view->cell.configured)
return 0; /* just to be sure */
/*
* make sure point is within edges of image as well
*/
if (x <= pick_view->cell.left)
return 0;
if (x >= pick_view->cell.right)
return 0;
if (y <= pick_view->cell.top)
return 0;
if (y >= pick_view->cell.bottom)
return 0;
/*
* ok, erase menu messages
*/
Menu_msg("");
/* determine magnification of zoom */
if (zoom_view->cell.configured) {
if (zoom_view == pick_view)
mag = floor(magnification(zoom_view) + 1.0) + .1;
else
mag = ceil(magnification(zoom_view)) + .1;
}
else {
mag = floor(magnification(main_view) + 1.0) + .1;
}
if (!ask_magnification(&mag))
return 1;
/*
* Determine the the zoom window (ie, cellhd)
*/
G_copy(&cellhd, &main_view->cell.head, sizeof(cellhd));
cellhd.ns_res = main_view->cell.ns_res / mag;
cellhd.ew_res = main_view->cell.ew_res / mag;
cellhd.cols = (cellhd.east - cellhd.west) / cellhd.ew_res;
cellhd.rows = (cellhd.north - cellhd.south) / cellhd.ns_res;
/* convert x,y to col,row */
col = view_to_col(pick_view, x);
east = col_to_easting(&pick_view->cell.head, col, 0.5);
col = easting_to_col(&cellhd, east);
row = view_to_row(pick_view, y);
north = row_to_northing(&pick_view->cell.head, row, 0.5);
row = northing_to_row(&cellhd, north);
ncols = zoom_view->ncols;
nrows = zoom_view->nrows;
n = cellhd.cols - col;
if (n > col)
n = col;
if (n + n + 1 >= ncols) {
n = ncols / 2;
if (n + n + 1 >= ncols)
n--;
}
left = col - n;
right = col + n;
n = cellhd.rows - row;
if (n > row)
n = row;
if (n + n + 1 >= nrows) {
n = nrows / 2;
if (n + n + 1 >= nrows)
n--;
}
top = row - n;
bottom = row + n;
north = row_to_northing(&cellhd, top, 0.0);
west = col_to_easting(&cellhd, left, 0.0);
south = row_to_northing(&cellhd, bottom, 1.0);
east = col_to_easting(&cellhd, right, 1.0);
cellhd.north = north;
cellhd.south = south;
cellhd.east = east;
cellhd.west = west;
cellhd.rows = (cellhd.north - cellhd.south) / cellhd.ns_res;
cellhd.cols = (cellhd.east - cellhd.west) / cellhd.ew_res;
/*
* Outline the zoom window on the main map
* Turn previous one to grey.
*/
if (zoom_view->cell.configured) {
R_standard_color(GREY);
Outline_cellhd(main_view, &zoom_view->cell.head);
}
R_standard_color(RED);
Outline_cellhd(main_view, &cellhd);
/*
* zoom
*/
if (target_flag)
select_target_env();
G_copy(&zoom_view->cell.head, &cellhd, sizeof(cellhd));
Configure_view(zoom_view, pick_view->cell.name, pick_view->cell.mapset,
pick_view->cell.ns_res, pick_view->cell.ew_res);
drawcell(zoom_view);
select_current_env();
display_points(1);
return 1; /* pop back */
}
static int drawvect(int zoomit, /* -1 = refresh, 0 = new image, 1 = zoom, 2 = warp */
View * zoom_view, double E[], double N[], int trans_order)
{ /* order of transformation if warping vectors */
int stat = 0;
int i;
char name[GNAME_MAX], mapset[GMAPSET_MAX];
struct Cell_head cellhd;
struct line_pnts *Points;
char msg[100], win_name[100];
int t, b, l, r;
int blank = 0;
View *active_view;
int left, top, nrows, ncols;
static int vectclr[VFILES];
/* if refresh screen or overlay & no displayed vector maps return */
if ((zoomit == DO_REFRESH || zoomit == DO_WARP) && !numfiles) {
if (zoomit == DO_REFRESH)
display_points(1);
return 0;
}
/* numfiles stays at 0 until the end of the first vector map init */
if (numfiles >= VFILES) {
G_warning
("Can't display another map; reached maximum number of files");
return 0;
}
select_target_env();
if (zoomit == DO_REFRESH || zoomit == DO_NEW) { /* New Map File or Refresh Screen */
if (zoomit == DO_NEW) { /* zoomit==0, Draw New Map File */
if (!choose_vectfile(name, mapset))
return 0;
strcpy(vect_file[numfiles], name);
strcpy(vect_mapset[numfiles], mapset);
get_vector_color(); /* ask line_color to draw map */
if (!numfiles) { /* first map: SET VECTOR WINDOW BY WIND */
G_get_window(&cellhd);
G_copy(&VIEW_MAP2->cell.head, &cellhd, sizeof(cellhd));
}
else /* not the first map */
G_copy(&cellhd, &VIEW_MAP2->cell.head,
sizeof(VIEW_MAP2->cell.head));
numfiles++;
}
else { /* zoomit=-1 Refresh Screen */
G_copy(&cellhd, &VIEW_MAP2->cell.head,
sizeof(VIEW_MAP2->cell.head));
if (!cellmap_present)
Erase_view(VIEW_MAP2_ZOOM);
VIEW_MAP2_ZOOM->cell.configured = 0;
blank = BLACK;
}
strcpy(win_name, "vect_map");
if (!view2on) {
t = VIEW_MAP2->top;
b = VIEW_MAP2->bottom;
l = VIEW_MAP2->left;
r = VIEW_MAP2->right;
D_new_window(win_name, t, b, l, r);
if (!cellmap_present)
blank = BLACK;
else
blank = 0; /* don't erase viewport */
view2on = 1;
}
active_view = VIEW_MAP2;
}
else { /* zoomit>0 Zoom or Warp */
G_copy(&cellhd, &zoom_view->cell.head, sizeof(zoom_view->cell.head));
if (!(zoom_view == VIEW_MAP1)) { /* target side */
VIEW_MAP2_ZOOM->cell.configured = 0;
strcpy(win_name, "zoom_map");
if (!view2zoomon) {
t = VIEW_MAP2_ZOOM->top;
b = VIEW_MAP2_ZOOM->bottom;
l = VIEW_MAP2_ZOOM->left;
r = VIEW_MAP2_ZOOM->right;
D_new_window(win_name, t, b, l, r);
view2zoomon = 1;
}
active_view = VIEW_MAP2_ZOOM;
blank = BLACK;
}
else {
strcpy(win_name, "warp_map"); /* defined in drawcell routine */
active_view = VIEW_MAP1;
blank = 0; /* don't erase viewport */
}
}
nrows = active_view->nrows;
ncols = active_view->ncols;
left = active_view->left;
top = active_view->top;
D_set_cur_wind(win_name);
R_standard_color(YELLOW);
Outline_box(top, top + nrows - 1, left, left + ncols - 1);
Points = Vect_new_line_struct();
if (zoomit != DO_WARP) {
Curses_clear_window(INFO_WINDOW);
Curses_write_window(INFO_WINDOW, 1, 13, "COORDINATES");
Curses_write_window(INFO_WINDOW, 3, 2, "MAIN WINDOW");
sprintf(msg, "N = %10.2f E = %10.2f", VIEW_MAP2->cell.head.north,
VIEW_MAP2->cell.head.east);
Curses_write_window(INFO_WINDOW, 5, 4, msg);
sprintf(msg, "S = %10.2f W = %10.2f", VIEW_MAP2->cell.head.south,
VIEW_MAP2->cell.head.west);
Curses_write_window(INFO_WINDOW, 6, 4, msg);
Curses_write_window(INFO_WINDOW, 9, 2, "ZOOM WINDOW");
sprintf(msg, "N = %10.2f E = %10.2f",
VIEW_MAP2_ZOOM->cell.head.north,
VIEW_MAP2_ZOOM->cell.head.east);
Curses_write_window(INFO_WINDOW, 11, 4, msg);
sprintf(msg, "S = %10.2f W = %10.2f",
VIEW_MAP2_ZOOM->cell.head.south,
VIEW_MAP2_ZOOM->cell.head.west);
Curses_write_window(INFO_WINDOW, 12, 4, msg);
}
if (zoomit) { /* ie ! DO_NEW */
dsp_setup(blank, &cellhd);
for (i = 0; i < numfiles; i++) {
sprintf(msg, "Displaying %s", vect_file[i]);
Menu_msg(msg);
R_standard_color(vectclr[i]);
if (zoomit != DO_WARP)
stat = plot(vect_file[i], vect_mapset[i], Points);
else
stat = plot_warp(vect_file[i], vect_mapset[i],
Points, E, N, trans_order);
}
}
else { /* ie DO_NEW */
if (numfiles == 1) { /* let first file set window */
G_copy(&VIEW_MAP2->cell.head, &cellhd, sizeof(cellhd));
cellhd.rows = VIEW_MAP2->nrows;
cellhd.cols = VIEW_MAP2->ncols;
cellhd.ns_res = (cellhd.north - cellhd.south) / cellhd.rows;
cellhd.ew_res = (cellhd.east - cellhd.west) / cellhd.cols;
if (cellhd.ns_res > cellhd.ew_res)
cellhd.ew_res = cellhd.ns_res;
else
cellhd.ns_res = cellhd.ew_res;
VIEW_MAP2->cell.ns_res = cellhd.ns_res;
VIEW_MAP2->cell.ew_res = cellhd.ew_res;
G_copy(&VIEW_MAP2->cell.head, &cellhd, sizeof(cellhd));
G_adjust_window_to_box(&cellhd, &VIEW_MAP2->cell.head,
VIEW_MAP2->nrows, VIEW_MAP2->ncols);
if (!cellmap_present) {
Configure_view(VIEW_MAP2, vect_file[numfiles - 1],
vect_mapset[numfiles - 1], cellhd.ns_res,
cellhd.ew_res);
}
Curses_write_window(INFO_WINDOW, 15, 2,
"WHERE CURSOR-> Mid Button");
}
dsp_setup(blank, &cellhd);
R_standard_color(YELLOW);
Outline_box(top, top + nrows - 1, left, left + ncols - 1);
sprintf(msg, "Displaying %s", vect_file[numfiles - 1]);
Menu_msg(msg);
R_standard_color(line_color);
vectclr[numfiles - 1] = line_color;
get_clr_name(vect_color[numfiles - 1], line_color);
stat =
plot(vect_file[numfiles - 1], vect_mapset[numfiles - 1], Points);
}
display_points(1);
R_standard_color(WHITE);
Outline_box(top, top + nrows - 1, left, left + ncols - 1);
Menu_msg("");
Vect_destroy_line_struct(Points);
/* VIEW_MAP2->cell.configured = 1; XXX */
select_current_env();
if (from_screen < 0) {
from_flag = 1;
from_screen = 0;
if (from_keyboard < 0) {
from_keyboard = 0;
from_screen = 1;
}
}
if (numfiles) {
Curses_clear_window(MENU_WINDOW);
Curses_write_window(MENU_WINDOW, 1, 5, "COLOR MAP FILE");
for (i = 0; i < numfiles; i++) {
sprintf(msg, "%7s %s", vect_color[i], vect_file[i]);
Curses_write_window(MENU_WINDOW, i + 3, 3, msg);
}
}
return 0;
}
int ask_line_color(char *colors, int len1, char *xname, int position)
{
static int use = 1;
int pick();
static Objects objects[] = {
OTHER(pick, &use),
{0}
};
char msg[100];
int width;
int len2 = 0, len;
long offset;
long *page_offset;
int col, nlist;
int line;
int stat;
char buf[100];
int top, bottom, left, right, center;
int topx, bottomx, leftx, rightx, widthx;
char name[100], mapset[100], cur_mapset[100];
int new_mapset;
Menu_msg("");
sprintf(msg, "Double click on color to assign to vector layer");
/*
* build a popup window at center of the screen.
* 35% the height and wide enough to hold 2 columms of file names
*
* the window is for choosing file names and will be laid out in 2 columns
*
* ------------------------------------------
* | CANCEL | (MORE) | (LESS) |
* ------------------------------------------
* | mapset |
* ------------------------------------------
* | name1 | name2 |
* ------------------------------------------
* | name3 | name4 |
* ------------------------------------------
* | name5 | name6 |
* | . |
* | . |
* | . |
* ------------------------------------------
*/
/* height of 1 line, based on NLINES taking up 35% vertical space */
height = (.35 * (SCREEN_BOTTOM - SCREEN_TOP)) / NLINES + 1;
/* size of text, 80% of line height */
text_size = .8 * height;
size = text_size - 1; /* fudge for computing pixels width of text */
/* indent for the text */
edge = .1 * height + 1;
/* this is a fudge to determine the length of the largest text */
len1 = 2 * len1; /* name in 2 columns */
len2 += strlen("mapset ");
len = (len1 > len2 ? len1 : len2);
/* width is for max chars plus sidecar for more/less */
width = len * size + height;
widthx = strlen(msg) * size;
if (widthx < width)
widthx = width;
/* define the window */
top = (SCREEN_TOP + SCREEN_BOTTOM - height * NLINES) / 2;
bottom = top + height * NLINES;
center = (SCREEN_LEFT + SCREEN_RIGHT) / 2;
if (position > 0) {
right = (center + SCREEN_RIGHT + width) / 2;
if (right >= SCREEN_RIGHT)
right = SCREEN_RIGHT - 1;
left = right - width;
}
else if (position < 0) {
left = (center + SCREEN_LEFT - width) / 2;
if (left <= SCREEN_LEFT)
left = SCREEN_LEFT + 1;
right = left + width;
}
else {
left = center + width / 2;
right = left + width;
}
topx = top - 3 * height;
bottomx = topx + 2 * height;
leftx = (left + right - widthx) / 2;
if (leftx < SCREEN_LEFT)
leftx = SCREEN_LEFT;
rightx = leftx + widthx;
/* save what is under these areas, so they can be restored */
R_panel_save(tempfile1, top, bottom, left, right);
R_panel_save(tempfile2, topx, bottomx, leftx, rightx);
/* fill it top with GREY, pick area with white */
R_standard_color(WHITE);
R_box_abs(left, top, right, bottom);
R_standard_color(GREY);
R_box_abs(leftx, topx, rightx, bottomx);
R_standard_color(BLACK);
Outline_box(top, bottom, left, right);
right -= height; /* reduce it to exclude sidecar */
Outline_box(top, bottom, left, right);
/* print messages above the files */
dotext(msg, topx, topx + height, leftx, rightx, 1);
dotext("Double click here to cancel", topx + height, bottomx, leftx,
rightx, 1);
cancel.top = topx;
cancel.bottom = bottomx;
cancel.left = leftx;
cancel.right = rightx;
/* start the mouse in the cancel box */
Set_mouse_xy((leftx + rightx) / 2, (topx + bottomx) / 2);
dobox(&less, "", WHITE, top, right, right + height, 0);
dobox(&more, "", WHITE, bottom - height, right, right + height, 0);
/* as we read the file of names, keep track of pages so we can
* page backward
*/
page = 0;
page_offset = (long *)G_calloc(npages = 1, sizeof(long));
*page_offset = ftell(fd);
nlist = sizeof(list) / sizeof(list[0]);
for (stat = -1; stat < 0;) {
line = 0;
count = 0;
*cur_mapset = 0;
col = 0;
while (1) {
/*
offset = ftell (fd);
if (fgets (buf, sizeof buf, fd) == NULL
|| sscanf (buf, "%s %s", name, mapset) != 2)
break;
if(new_mapset = (strcmp (cur_mapset,mapset) != 0))
{
if(line) line++;
if (col) line++;
col = 0;
}
if (count >= nlist || line+new_mapset >= NLINES)
{
if (page+1 == npages)
{
npages++;
page_offset = (long *) G_realloc (page_offset, npages * sizeof (long));
page_offset[npages-1] = offset;
}
break;
}
if (new_mapset)
{
struct box dummy;
char label[100];
strcpy (cur_mapset, mapset);
sprintf (label, "Mapset %s", mapset);
dobox (&dummy, label, WHITE, top+line*height, left, right, 0);
line++;
}
if (col)
{
dobox (&list[count].box, name, GREY, top+line*height, left+width/2, right, 0);
line++;
col = 0;
}
else
{
dobox (&list[count].box, name, GREY, top+line*height, left, left+width/2, 0);
col = 1;
}
strcpy (list[count].name, name);
strcpy (list[count].mapset, mapset);
count++;
}
downarrow (&more, page+1 < npages ? BLACK : WHITE);
uparrow (&less, page > 0 ? BLACK : WHITE);
which = -1;
switch(Input_pointer(objects))
{
case -1: /* more or less */
break;
case -2: /* cancel */
stat = 0;
continue;
default: /* file picked */
strcpy(xname, list[which].name);
stat = 1;
continue;
}
fseek(fd, page_offset[page], 0);
R_standard_color(WHITE);
R_box_abs(left + 1, top + 1, right - 1, bottom - 1);
}
/* all done. restore what was under the window */
right += height; /* move it back over the sidecar */
R_standard_color(WHITE);
R_box_abs(left, top, right, bottom);
R_panel_restore(tempfile1);
R_panel_restore(tempfile2);
R_panel_delete(tempfile1);
R_panel_delete(tempfile2);
R_flush();
G_free(page_offset);
return stat;
}
int analyze(void)
{
static int use = 1;
static Objects objects[] = {
MENU("DONE", done, &use),
MENU("PRINT", to_printer, &use),
MENU("FILE", to_file, &use),
MENU("OVERLAY", do_warp, &use),
MENU(delete_msg, delete_mark, &use),
INFO("Transform->", &use),
MENU(order_msg, get_order, &use),
INFO(pick_msg, &use),
OTHER(pick, &use),
{0}
};
int color;
int tsize;
int cury;
int len;
int line;
int top, bottom, left, right, width, middle, nums;
/* to give user a response of some sort */
Menu_msg("Preparing analysis ...");
/*
* build a popup window at center of the screen.
* 35% the height and wide enough to hold the report
*
*/
/* height of 1 line, based on NLINES taking up 35% vertical space */
height = (.35 * (SCREEN_BOTTOM - SCREEN_TOP)) / NLINES + 1;
/* size of text, 80% of line height */
tsize = .8 * height;
size = tsize - 2; /* fudge for computing pixels width of text */
/* indent for the text */
edge = .1 * height + 1;
/* determine the length, in chars, of printed line */
FMT0(buf, 0);
nums = strlen(buf) * size;
FMT1(buf, 0.0, 0.0, 0.0);
len = strlen(buf);
middle = len * size;
FMT2(buf, 0.0, 0.0, 0.0, 0.0);
len += strlen(buf);
/* width is for max chars plus sidecar for more/less */
width = len * size + nums + 2 * height;
if ((SCREEN_RIGHT - SCREEN_LEFT) < width)
width = SCREEN_RIGHT - SCREEN_LEFT;
/* define the window */
bottom = VIEW_MENU->top - 1;
top = bottom - height * NLINES;
left = SCREEN_LEFT;
right = left + width;
middle += left + nums;
nums += left;
/* save what is under this area, so it can be restored */
R_panel_save(tempfile1, top, bottom + 1, left, right + 1);
/* fill it with white */
R_standard_color(BACKGROUND);
R_box_abs(left, top, right, bottom);
right -= 2 * height; /* reduce it to exclude sidecar */
/* print messages in message area */
R_text_size(tsize, tsize);
/* setup the more/less boxes in the sidecar */
R_standard_color(BLACK);
less.top = top;
less.bottom = top + 2 * height;
less.left = right;
less.right = right + 2 * height;
Outline_box(less.top, less.bottom, less.left, less.right);
more.top = bottom - 2 * height;
more.bottom = bottom;
more.left = right;
more.right = right + 2 * height;
Outline_box(more.top, more.bottom, more.left, more.right);
/*
* top two lines are for column labels
* last two line is for overall rms error.
*/
nlines = NLINES - 3;
first_point = 0;
/* allocate predicted values */
xres = (double *)G_calloc(group.points.count, sizeof(double));
yres = (double *)G_calloc(group.points.count, sizeof(double));
gnd = (double *)G_calloc(group.points.count, sizeof(double));
/* compute transformation for the first time */
compute_transformation();
/* put head on the report */
cury = top;
dotext(LHEAD1, cury, cury + height, left, middle, 0, BLACK);
dotext(RHEAD1, cury, cury + height, middle, right - 1, 0, BLACK);
cury += height;
dotext(LHEAD2, cury, cury + height, left, middle, 0, BLACK);
dotext(RHEAD2, cury, cury + height, middle, right - 1, 0, BLACK);
cury += height;
R_move_abs(left, cury - 1);
R_cont_abs(right, cury - 1);
/* isolate the sidecar */
R_move_abs(right, top);
R_cont_abs(right, bottom);
/* define report box */
report.top = cury;
report.left = left;
report.right = right;
/* lets do it */
pager = 1;
while (1) {
R_text_size(tsize, tsize);
line = 0;
curp = first_point;
cury = top + 2 * height;
while (1) {
if (line >= nlines || curp >= group.points.count)
break;
line++;
if (!delete_mode)
color = BLACK;
else
color = BLUE;
if (group.equation_stat > 0 && group.points.status[curp] > 0) {
/* color = BLACK; */
FMT1(buf, xres[curp], yres[curp], gnd[curp]);
if (curp == xmax || curp == ymax || curp == gmax)
color = RED;
dotext(buf, cury, cury + height, nums, middle, 0, color);
}
else if (group.points.status[curp] > 0)
dotext("?", cury, cury + height, nums, middle, 1, color);
else
dotext("not used", cury, cury + height, nums, middle, 1,
color);
if (pager) {
FMT0(buf, curp + 1);
dotext(buf, cury, cury + height, left, nums, 0, color);
FMT2(buf,
group.points.e1[curp],
group.points.n1[curp],
group.points.e2[curp], group.points.n2[curp]);
dotext(buf, cury, cury + height, middle, right - 1, 0, color);
}
cury += height;
curp++;
}
report.bottom = cury;
downarrow(&more, curp < group.points.count ? color : BACKGROUND);
uparrow(&less, first_point > 0 ? color : BACKGROUND);
R_standard_color(BACKGROUND);
R_box_abs(left, cury, right - 1, bottom);
if (group.equation_stat < 0) {
if (group.equation_stat == -1) {
color = RED;
strcpy(buf, "Poorly placed control points");
}
else {
if (group.equation_stat == -2)
G_fatal_error("NOT ENOUGH MEMORY");
else
G_fatal_error("PARAMETER ERROR");
}
}
else if (group.equation_stat == 0) {
color = RED;
strcpy(buf, "No active control points");
}
else {
color = BLACK;
sprintf(buf, "Overall rms error: %.2f", rms);
}
dotext(buf, bottom - height, bottom, left, right - 1, 0, color);
R_standard_color(BLACK);
R_move_abs(left, bottom - height);
R_cont_abs(right - 1, bottom - height);
pager = 0;
which = -1;
if (Input_pointer(objects) < 0)
break;
display_points(1);
}
/* all done. restore what was under the window */
right += 2 * height; /* move it back over the sidecar */
R_standard_color(BACKGROUND);
R_box_abs(left, top, right, bottom);
R_panel_restore(tempfile1);
R_panel_delete(tempfile1);
R_flush();
G_free(xres);
G_free(yres);
G_free(gnd);
I_put_control_points(group.name, &group.points);
display_points(1);
return 0; /* return but don't QUIT */
}
static int compute_transformation(void)
{ /* returns 0 on success, 1 on fail */
int n, count;
double d, d1, d2, sum;
double e1, e2, n1, n2;
double xval, yval, gval;
static int order_pnts[3] = { 3, 6, 10 };
char msg[40];
xmax = ymax = gmax = 0;
xval = yval = gval = 0.0;
CRS_Compute_equation(trans_order);
if (group.equation_stat <= 0) {
if (group.equation_stat == 0) {
sprintf(msg, "Not Enough Points -- %d are required.",
order_pnts[trans_order - 1]);
Menu_msg(msg);
G_sleep(2);
}
return 1;
}
/* compute the row,col error plus ground error
* keep track of largest and second largest error
*/
sum = 0.0;
rms = 0.0;
count = 0;
for (n = 0; n < group.points.count; n++) {
if (group.points.status[n] <= 0)
continue;
count++;
CRS_georef(group.points.e2[n], group.points.n2[n], &e1, &n1,
group.E21, group.N21, trans_order);
CRS_georef(group.points.e1[n], group.points.n1[n], &e2, &n2,
group.E12, group.N12, trans_order);
if ((d = xres[n] = e1 - group.points.e1[n]) < 0)
d = -d;
if (d > xval) {
xmax = n;
xval = d;
}
if ((d = yres[n] = n1 - group.points.n1[n]) < 0)
d = -d;
if (d > yval) {
ymax = n;
yval = d;
}
/* compute ground error (ie along diagonal) */
d1 = e2 - group.points.e2[n];
d2 = n2 - group.points.n2[n];
d = d1 * d1 + d2 * d2;
sum += d; /* add it to rms sum, before taking sqrt */
d = sqrt(d);
gnd[n] = d;
if (d > gval) { /* is this one the max? */
gmax = n;
gval = d;
}
}
/* compute overall rms error */
if (count)
rms = sqrt(sum / count);
return 0;
}
static int zoom2(int x, int y)
{
int top, bottom, left, right;
int row, col;
struct Cell_head cellhd;
x2 = x;
y2 = y;
/*
* user has completed the zoom window.
* must be in same view as first corner
*/
if (x1 == x2 || y1 == y2)
return 0; /* ignore event */
if (!In_view(pick_view, x2, y2))
return 0;
/*
* ok, erase menu messages
*/
Menu_msg("");
/*
* assign window coordinates to top,bottom,left,right
*/
if (x1 < x2) {
left = x1;
right = x2;
}
else {
left = x2;
right = x1;
}
if (y1 < y2) {
top = y1;
bottom = y2;
}
else {
top = y2;
bottom = y1;
}
/*
* Determine the the zoom window (ie, cellhd)
* must copy the current view cellhd first, to preserve header info
* (such as projection, zone, and other items.)
* compute zoom window northings,eastings, rows, cols, and resolution
*/
G_copy(&cellhd, &pick_view->cell.head, sizeof(cellhd));
/* convert top to northing at top edge of cell
* left to easting at left edge
*/
col = view_to_col(pick_view, left);
row = view_to_row(pick_view, top);
cellhd.north = row_to_northing(&pick_view->cell.head, row, 0.0);
cellhd.west = col_to_easting(&pick_view->cell.head, col, 0.0);
/* convert bottom to northing at bottom edge of cell
* right to easting at right edge
*/
col = view_to_col(pick_view, right);
row = view_to_row(pick_view, bottom);
cellhd.south = row_to_northing(&pick_view->cell.head, row, 1.0);
cellhd.east = col_to_easting(&pick_view->cell.head, col, 1.0);
cellhd.rows = bottom - top + 1;
cellhd.cols = right - left + 1;
cellhd.ns_res = (cellhd.north - cellhd.south) / cellhd.rows;
cellhd.ew_res = (cellhd.east - cellhd.west) / cellhd.cols;
/*
* Outline the zoom window on the main map
* Turn previous one to grey.
*/
if (zoom_view->cell.configured) {
R_standard_color(GREY);
Outline_cellhd(main_view, &zoom_view->cell.head);
}
R_standard_color(RED);
Outline_cellhd(main_view, &cellhd);
/*
* zoom
*/
if (target_flag)
select_target_env();
G_adjust_window_to_box(&cellhd, &zoom_view->cell.head, zoom_view->nrows,
zoom_view->ncols);
Configure_view(zoom_view, pick_view->cell.name, pick_view->cell.mapset,
pick_view->cell.ns_res, pick_view->cell.ew_res);
drawcell(zoom_view);
select_current_env();
display_ref_points(1);
return 1; /* pop back */
}
