/*!
\brief ADD
\param gs surface (geosurf)
\return 1
\return 0
*/
int in_vregion(geosurf * gs, float *pt)
{
if (pt[X] >= 0.0 && pt[Y] <= gs->yrange) {
if (pt[X] <= VCOL2X(gs, VCOLS(gs))) {
return (pt[Y] >= VROW2Y(gs, VROWS(gs)));
}
}
return (0);
}
/*!
\brief Check if point is in region
Check for cancel every CHK_FREQ points
\param gs surface (geosurf)
\param pt point (array(X,Y,Z))
\param region region settings (array (top,bottom,left,right))
\return 0 point outside of region
\return 1 point inside region
*/
int gs_point_in_region(geosurf * gs, float *pt, float *region)
{
float top, bottom, left, right;
if (!region) {
top = gs->yrange;
bottom = VROW2Y(gs, VROWS(gs));
left = 0.0;
right = VCOL2X(gs, VCOLS(gs));
}
else {
top = region[0];
bottom = region[1];
left = region[2];
right = region[3];
}
return (pt[X] >= left && pt[X] <= right &&
pt[Y] >= bottom && pt[Y] <= top);
}
/*!
\brief Display fridge
\todo add elevation for bottom
add color option
add ruler grid lines
\param surf surface (geosurf)
\param clr
\param elev
\param where
*/
void gsd_display_fringe(geosurf * surf, unsigned long clr, float elev,
int where[4])
{
float bot, xres, yres; /* world size of view cell */
int ycnt, xcnt; /* number of view cells across */
float xmax, ymax;
xres = surf->x_mod * surf->xres;
yres = surf->y_mod * surf->yres;
xcnt = VCOLS(surf);
ycnt = VROWS(surf);
xmax = surf->xmax;
ymax = surf->ymax;
/*
bot = surf->zmin - ((surf->zrange/4.) * surf->z_exag);
*/
bot = elev - ((surf->zrange / 4.) * surf->z_exag);
gsd_linewidth(FRINGE_WIDTH);
gsd_colormode(CM_COLOR);
/* North fringe */
if (where[0] || where[1]) {
glNormal3fv(Nnorth);
gsd_color_func(clr);
gsd_zwritemask(0x0);
gsd_fringe_horiz_poly(bot, surf, 0, 0);
gsd_color_func(FRINGE_FORE); /* WHITE */
gsd_fringe_horiz_line(bot, surf, 0, 0);
gsd_zwritemask(0xffffffff);
/* wmpack (0); ??? glColorMask */
gsd_color_func(clr);
gsd_fringe_horiz_poly(bot, surf, 0, 0);
}
/* South fringe */
if (where[2] || where[3]) {
glNormal3fv(Nsouth);
gsd_color_func(clr);
gsd_zwritemask(0x0);
gsd_fringe_horiz_poly(bot, surf, ycnt - 2, 1);
gsd_color_func(FRINGE_FORE); /* WHITE */
gsd_fringe_horiz_line(bot, surf, ycnt - 2, 1);
gsd_zwritemask(0xffffffff);
/* wmpack (0); ??? glColorMask */
gsd_color_func(clr);
gsd_fringe_horiz_poly(bot, surf, ycnt - 2, 1);
}
/* West fringe */
if (where[0] || where[2]) {
glNormal3fv(Nwest);
gsd_color_func(clr);
gsd_zwritemask(0x0);
gsd_fringe_vert_poly(bot, surf, 0, 0);
gsd_color_func(FRINGE_FORE);
gsd_fringe_vert_line(bot, surf, 0, 0);
gsd_zwritemask(0xffffffff);
gsd_color_func(clr);
gsd_fringe_vert_poly(bot, surf, 0, 0);
}
/* East fringe */
if (where[1] || where[3]) {
glNormal3fv(Neast);
gsd_color_func(clr);
gsd_zwritemask(0x0);
gsd_fringe_vert_poly(bot, surf, xcnt - 2, 1);
gsd_color_func(FRINGE_FORE);
gsd_fringe_vert_line(bot, surf, xcnt - 2, 1);
gsd_zwritemask(0xffffffff);
gsd_color_func(clr);
gsd_fringe_vert_poly(bot, surf, xcnt - 2, 1);
}
return;
}
/*!
\brief ADD
\param bot
\param surf surface (geosurf)
\param col
\param side [unused]
*/
void gsd_fringe_vert_line(float bot, geosurf * surf, int col, int side)
{
int row;
int cnt;
float pt[4];
typbuff *buff;
long offset;
int ycnt;
GS_set_draw(GSD_FRONT);
gsd_pushmatrix();
gsd_do_scale(1);
gsd_translate(surf->x_trans, surf->y_trans, surf->z_trans);
buff = gs_get_att_typbuff(surf, ATT_TOPO, 0);
ycnt = VROWS(surf);
gsd_bgnline();
row = 0;
/* floor left */
pt[X] = col * (surf->x_mod * surf->xres);
pt[Y] =
((surf->rows - 1) * surf->yres) - (row * (surf->y_mod * surf->yres));
pt[Z] = bot;
gsd_vert_func(pt);
offset = (row * surf->y_mod * surf->cols) + (col * surf->x_mod);
GET_MAPATT(buff, offset, pt[Z]);
pt[Z] = pt[Z] * surf->z_exag;
gsd_vert_func(pt);
cnt = 1;
for (row = 0; row < ycnt - 1; row++) {
/* bottom right */
pt[X] = col * (surf->x_mod * surf->xres);
pt[Y] =
((surf->rows - 1) * surf->yres) -
(row * (surf->y_mod * surf->yres));
offset = (row * surf->y_mod * surf->cols) + (col * surf->x_mod);
GET_MAPATT(buff, offset, pt[Z]);
pt[Z] = pt[Z] * surf->z_exag;
gsd_vert_func(pt);
cnt++;
}
row--;
pt[X] = col * (surf->x_mod * surf->xres);
pt[Y] =
((surf->rows - 1) * surf->yres) - (row * (surf->y_mod * surf->yres));
pt[Z] = bot;
gsd_vert_func(pt);
row = 0;
pt[X] = col * (surf->x_mod * surf->xres);
pt[Y] =
((surf->rows - 1) * surf->yres) - (row * (surf->y_mod * surf->yres));
pt[Z] = bot;
gsd_vert_func(pt);
gsd_endline();
GS_done_draw();
gsd_popmatrix();
gsd_flush();
return;
}
/*!
\brief Check if point is masked
\param gs pointer to geosurf struct
\param pt point coordinates (X,Y,Z)
\return 1 masked
\return 0 not masked
*/
int gs_point_is_masked(geosurf * gs, float *pt)
{
int vrow, vcol, drow, dcol;
int retmask = 0, npts = 0;
float p2[2];
if (!gs->curmask) {
return (0);
}
vrow = Y2VROW(gs, pt[Y]);
vcol = X2VCOL(gs, pt[X]);
/* check right & bottom edges */
if (pt[X] == VCOL2X(gs, VCOLS(gs))) {
/* right edge */
vcol -= 1;
}
if (pt[Y] == VROW2Y(gs, VROWS(gs))) {
/* bottom edge */
vrow -= 1;
}
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_TL;
npts++;
}
dcol = VCOL2DCOL(gs, vcol + 1);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_TR;
npts++;
}
drow = VROW2DROW(gs, vrow + 1);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_BR;
npts++;
}
dcol = VCOL2DCOL(gs, vcol);
if (BM_get(gs->curmask, dcol, drow)) {
retmask |= MASK_BL;
npts++;
}
if (npts != 1) {
/* zero or masked */
return (retmask | npts);
}
p2[X] = VCOL2X(gs, vcol);
p2[Y] = VROW2Y(gs, vrow + 1);
switch (retmask) {
case MASK_TL:
if ((pt[X] - p2[X]) / VXRES(gs) > (pt[Y] - p2[Y]) / VYRES(gs)) {
/* lower triangle */
return (0);
}
return (retmask | npts);
case MASK_TR:
return (retmask | npts);
case MASK_BR:
if ((pt[X] - p2[X]) / VXRES(gs) <= (pt[Y] - p2[Y]) / VYRES(gs)) {
/* upper triangle */
return (0);
}
return (retmask | npts);
case MASK_BL:
return (retmask | npts);
}
/* Assume that if we get here it is an error */
return (0);
}
/*!
\brief Calculate normals
OPTIMIZED for constant dy & dx
The norm array is always the same size, but diff resolutions
force resampled data points to have their normals recalculated,
then only those norms are passed to n3f during drawing.
Norms are converted to a packed unsigned int for storage,
must be converted back at time of use.
\todo fix to correctly calculate norms when mapped to sphere!
Uses the previous and next cells (when available) for normal
calculations to produce smoother normals
\param gs surface (geosurf)
\return 1 on success
\return 0 on failure
*/
int gs_calc_normals(geosurf * gs)
{
int row, col;
int xcnt, ycnt;
int xmod, ymod;
if (!gs->norm_needupdate || !gs->norms) {
return (0);
}
gs->norm_needupdate = 0;
gs_update_curmask(gs);
xmod = gs->x_mod;
ymod = gs->y_mod;
xcnt = VCOLS(gs);
ycnt = VROWS(gs);
init_vars(gs);
G_debug(5, "gs_calc_normals(): id=%d", gs->gsurf_id);
/* first row - just use single cell */
/* first col - use bottom & right neighbors */
calc_norm(gs, 0, 0, NBR);
for (col = 1; col < xcnt; col++) {
/* turn off top neighbor for first row */
calc_norm(gs, 0, col * xmod, ~NTOP);
}
/* use bottom & left neighbors for last col */
calc_norm(gs, 0, col * xmod, NBL);
/* now use four neighboring points for rows 1 - (n-1) */
for (row = 1; row < ycnt; row++) {
if (!(row % 100))
G_debug(5, "gs_calc_normals(): row=%d", row);
/* turn off left neighbor for first col */
calc_norm(gs, row * ymod, 0, ~NLFT);
/* use all 4 neighbors until last col */
for (col = 1; col < xcnt; col++) {
calc_norm(gs, row * ymod, col * xmod, NALL);
}
/* turn off right neighbor for last col */
calc_norm(gs, row * ymod, col * xmod, ~NRGT);
}
/* last row */
/* use top & right neighbors for first col */
calc_norm(gs, row * ymod, 0, NTR);
for (col = 1; col < xcnt; col++) {
/* turn off bottom neighbor for last row */
calc_norm(gs, row * ymod, col * xmod, ~NBOT);
}
/* use top & left neighbors for last column */
calc_norm(gs, row * ymod, col * xmod, NTL);
return (1);
}
/*!
\brief Get horizontal intersects
\param gs surface (geosurf)
\param bgn begin point
\param end end point
\param dir
\return number of intersects
*/
int get_horz_intersects(geosurf * gs, float *bgn, float *end, float *dir)
{
int frow, lrow, incr, hits, num, offset, dcol1, dcol2;
float xl, yb, xr, yt, z1, z2, alpha;
float xres, yres, xi, yi;
int bgnrow, endrow, rows, cols;
xres = VXRES(gs);
yres = VYRES(gs);
cols = VCOLS(gs);
rows = VROWS(gs);
bgnrow = Y2VROW(gs, bgn[Y]);
endrow = Y2VROW(gs, end[Y]);
if (bgnrow == endrow) {
return 0;
}
if (bgnrow > rows && endrow > rows) {
return 0;
}
frow = dir[Y] > 0 ? bgnrow : bgnrow + 1;
lrow = dir[Y] > 0 ? endrow + 1 : endrow;
/* assuming only showing FULL rows */
incr = lrow - frow > 0 ? 1 : -1;
while (frow > rows || frow < 0) {
frow += incr;
}
while (lrow > rows || lrow < 0) {
lrow -= incr;
}
num = abs(lrow - frow) + 1;
xl = 0.0 - EPSILON;
xr = xres * cols + EPSILON;
for (hits = 0; hits < num; hits++) {
yb = yt = VROW2Y(gs, frow);
if (segs_intersect(bgn[X], bgn[Y], end[X], end[Y], xl, yt, xr, yb,
&xi, &yi)) {
Hi[hits][X] = xi;
Hi[hits][Y] = yi;
/* find data cols */
if (Flat) {
Hi[hits][Z] = gs->att[ATT_TOPO].constant;
}
else {
dcol1 = X2VCOL(gs, Hi[hits][X]) * gs->x_mod;
dcol2 = (1 + X2VCOL(gs, Hi[hits][X])) * gs->x_mod;
if (dcol2 >= gs->cols) {
dcol2 = gs->cols - 1; /* right edge */
}
alpha = (Hi[hits][X] - (dcol1 * gs->xres)) / xres;
offset = DRC2OFF(gs, frow * gs->y_mod, dcol1);
GET_MAPATT(Ebuf, offset, z1);
offset = DRC2OFF(gs, frow * gs->y_mod, dcol2);
GET_MAPATT(Ebuf, offset, z2);
Hi[hits][Z] = LERP(alpha, z1, z2);
}
}
/* if they don't intersect, something's wrong! */
/* should only happen on endpoint, so it will be added later */
else {
hits--;
num--;
}
frow += incr;
}
return (hits);
}
/*!
\brief ADD
\todo For consistancy, need to decide how last row & last column are
displayed - would it look funny to always draw last row/col with
finer resolution if necessary, or would it be better to only show
full rows/cols?
Colinear already eliminated
\param gs surface (geosurf)
\param bgn begin point
\param end end point
\param dir direction
\return
*/
int get_vert_intersects(geosurf * gs, float *bgn, float *end, float *dir)
{
int fcol, lcol, incr, hits, num, offset, drow1, drow2;
float xl, yb, xr, yt, z1, z2, alpha;
float xres, yres, xi, yi;
int bgncol, endcol, cols, rows;
xres = VXRES(gs);
yres = VYRES(gs);
cols = VCOLS(gs);
rows = VROWS(gs);
bgncol = X2VCOL(gs, bgn[X]);
endcol = X2VCOL(gs, end[X]);
if (bgncol > cols && endcol > cols) {
return 0;
}
if (bgncol == endcol) {
return 0;
}
fcol = dir[X] > 0 ? bgncol + 1 : bgncol;
lcol = dir[X] > 0 ? endcol : endcol + 1;
/* assuming only showing FULL cols */
incr = lcol - fcol > 0 ? 1 : -1;
while (fcol > cols || fcol < 0) {
fcol += incr;
}
while (lcol > cols || lcol < 0) {
lcol -= incr;
}
num = abs(lcol - fcol) + 1;
yb = gs->yrange - (yres * rows) - EPSILON;
yt = gs->yrange + EPSILON;
for (hits = 0; hits < num; hits++) {
xl = xr = VCOL2X(gs, fcol);
if (segs_intersect(bgn[X], bgn[Y], end[X], end[Y], xl, yt, xr, yb,
&xi, &yi)) {
Vi[hits][X] = xi;
Vi[hits][Y] = yi;
/* find data rows */
if (Flat) {
Vi[hits][Z] = gs->att[ATT_TOPO].constant;
}
else {
drow1 = Y2VROW(gs, Vi[hits][Y]) * gs->y_mod;
drow2 = (1 + Y2VROW(gs, Vi[hits][Y])) * gs->y_mod;
if (drow2 >= gs->rows) {
drow2 = gs->rows - 1; /*bottom edge */
}
alpha =
((gs->yrange - drow1 * gs->yres) - Vi[hits][Y]) / yres;
offset = DRC2OFF(gs, drow1, fcol * gs->x_mod);
GET_MAPATT(Ebuf, offset, z1);
offset = DRC2OFF(gs, drow2, fcol * gs->x_mod);
GET_MAPATT(Ebuf, offset, z2);
Vi[hits][Z] = LERP(alpha, z1, z2);
}
}
/* if they don't intersect, something's wrong! */
/* should only happen on endpoint, so it will be added later */
else {
hits--;
num--;
}
fcol += incr;
}
return (hits);
}
/*!
\brief ADD
In gsd_surf, tmesh draws polys like so:
<pre>
--------------
| /|
| / |
| / |
| / |
| / |
| / |
| / |
| / |
| / |
| / |
| / |
|/ |
--------------
</pre>
UNLESS the top right or bottom left point is masked, in which case a
single triangle with the opposite diagonal is drawn. This case is
not yet handled here & should only occur on edges.
pt has X & Y coordinates in it, we interpolate Z here
This could probably be much shorter, but not much faster.
\return 1 if point is in view region
\return otherwise 0 (if masked)
*/
int viewcell_tri_interp(geosurf * gs, typbuff * buf, Point3 pt,
int check_mask)
{
Point3 p1, p2, p3;
int offset, drow, dcol, vrow, vcol;
float xmax, ymin, ymax, alpha;
xmax = VCOL2X(gs, VCOLS(gs));
ymax = VROW2Y(gs, 0);
ymin = VROW2Y(gs, VROWS(gs));
if (check_mask) {
if (gs_point_is_masked(gs, pt)) {
return (0);
}
}
if (pt[X] < 0.0 || pt[Y] > ymax) {
/* outside on left or top */
return (0);
}
if (pt[Y] < ymin || pt[X] > xmax) {
/* outside on bottom or right */
return (0);
}
if (CONST_ATT == gs_get_att_src(gs, ATT_TOPO)) {
pt[Z] = gs->att[ATT_TOPO].constant;
return (1);
}
else if (MAP_ATT != gs_get_att_src(gs, ATT_TOPO)) {
return (0);
}
vrow = Y2VROW(gs, pt[Y]);
vcol = X2VCOL(gs, pt[X]);
if (vrow < VROWS(gs) && vcol < VCOLS(gs)) {
/*not on bottom or right edge */
if (pt[X] > 0.0 && pt[Y] < ymax) {
/* not on left or top edge */
p1[X] = VCOL2X(gs, vcol + 1);
p1[Y] = VROW2Y(gs, vrow);
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol + 1);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p1[Z]); /* top right */
p2[X] = VCOL2X(gs, vcol);
p2[Y] = VROW2Y(gs, vrow + 1);
drow = VROW2DROW(gs, vrow + 1);
dcol = VCOL2DCOL(gs, vcol);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p2[Z]); /* bottom left */
if ((pt[X] - p2[X]) / VXRES(gs) > (pt[Y] - p2[Y]) / VYRES(gs)) {
/* lower triangle */
p3[X] = VCOL2X(gs, vcol + 1);
p3[Y] = VROW2Y(gs, vrow + 1);
drow = VROW2DROW(gs, vrow + 1);
dcol = VCOL2DCOL(gs, vcol + 1);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p3[Z]); /* bottom right */
}
else {
/* upper triangle */
p3[X] = VCOL2X(gs, vcol);
p3[Y] = VROW2Y(gs, vrow);
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p3[Z]); /* top left */
}
return (Point_on_plane(p1, p2, p3, pt));
}
else if (pt[X] == 0.0) {
/* on left edge */
if (pt[Y] < ymax) {
vrow = Y2VROW(gs, pt[Y]);
drow = VROW2DROW(gs, vrow);
offset = DRC2OFF(gs, drow, 0);
GET_MAPATT(buf, offset, p1[Z]);
drow = VROW2DROW(gs, vrow + 1);
offset = DRC2OFF(gs, drow, 0);
GET_MAPATT(buf, offset, p2[Z]);
alpha = (VROW2Y(gs, vrow) - pt[Y]) / VYRES(gs);
pt[Z] = LERP(alpha, p1[Z], p2[Z]);
}
else {
/* top left corner */
GET_MAPATT(buf, 0, pt[Z]);
}
return (1);
}
else if (pt[Y] == gs->yrange) {
/* on top edge, not a corner */
vcol = X2VCOL(gs, pt[X]);
dcol = VCOL2DCOL(gs, vcol);
GET_MAPATT(buf, dcol, p1[Z]);
dcol = VCOL2DCOL(gs, vcol + 1);
GET_MAPATT(buf, dcol, p2[Z]);
alpha = (pt[X] - VCOL2X(gs, vcol)) / VXRES(gs);
pt[Z] = LERP(alpha, p1[Z], p2[Z]);
return (1);
}
}
else if (vrow == VROWS(gs)) {
/* on bottom edge */
drow = VROW2DROW(gs, VROWS(gs));
if (pt[X] > 0.0 && pt[X] < xmax) {
/* not a corner */
vcol = X2VCOL(gs, pt[X]);
dcol = VCOL2DCOL(gs, vcol);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p1[Z]);
dcol = VCOL2DCOL(gs, vcol + 1);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p2[Z]);
alpha = (pt[X] - VCOL2X(gs, vcol)) / VXRES(gs);
pt[Z] = LERP(alpha, p1[Z], p2[Z]);
return (1);
}
else if (pt[X] == 0.0) {
/* bottom left corner */
offset = DRC2OFF(gs, drow, 0);
GET_MAPATT(buf, offset, pt[Z]);
return (1);
}
else {
/* bottom right corner */
dcol = VCOL2DCOL(gs, VCOLS(gs));
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, pt[Z]);
return (1);
}
}
else {
/* on right edge, not bottom corner */
dcol = VCOL2DCOL(gs, VCOLS(gs));
if (pt[Y] < ymax) {
vrow = Y2VROW(gs, pt[Y]);
drow = VROW2DROW(gs, vrow);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p1[Z]);
drow = VROW2DROW(gs, vrow + 1);
offset = DRC2OFF(gs, drow, dcol);
GET_MAPATT(buf, offset, p2[Z]);
alpha = (VROW2Y(gs, vrow) - pt[Y]) / VYRES(gs);
pt[Z] = LERP(alpha, p1[Z], p2[Z]);
return (1);
}
else {
/* top right corner */
GET_MAPATT(buf, dcol, pt[Z]);
return (1);
}
}
return (0);
}
/*!
\brief Check if segment intersect vector region
Clipping performed:
- bgn and end are replaced so that both points are within viewregion
- if seg intersects
\param gs surface (geosurf)
\param bgn begin point
\param end end point
\return 0 if segment doesn't intersect the viewregion, or intersects only at corner
\return otherwise returns 1
*/
int seg_intersect_vregion(geosurf * gs, float *bgn, float *end)
{
float *replace, xl, yb, xr, yt, xi, yi;
int inside = 0;
xl = 0.0;
xr = VCOL2X(gs, VCOLS(gs));
yt = VROW2Y(gs, 0);
yb = VROW2Y(gs, VROWS(gs));
if (in_vregion(gs, bgn)) {
replace = end;
inside++;
}
if (in_vregion(gs, end)) {
replace = bgn;
inside++;
}
if (inside == 2) {
return (1);
}
else if (inside) {
/* one in & one out - replace gets first intersection */
if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xl, yb, xl, yt, &xi, &yi)) {
/* left */
}
else if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xr, yb, xr, yt, &xi, &yi)) {
/* right */
}
else if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xl, yb, xr, yb, &xi, &yi)) {
/* bottom */
}
else if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xl, yt, xr, yt, &xi, &yi)) {
/* top */
}
replace[X] = xi;
replace[Y] = yi;
}
else {
/* both out - find 2 intersects & replace both */
float pt1[2], pt2[2];
replace = pt1;
if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xl, yb, xl, yt, &xi, &yi)) {
replace[X] = xi;
replace[Y] = yi;
replace = pt2;
inside++;
}
if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xr, yb, xr, yt, &xi, &yi)) {
replace[X] = xi;
replace[Y] = yi;
replace = pt2;
inside++;
}
if (inside < 2) {
if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xl, yb, xr, yb, &xi, &yi)) {
replace[X] = xi;
replace[Y] = yi;
replace = pt2;
inside++;
}
}
if (inside < 2) {
if (segs_intersect
(bgn[X], bgn[Y], end[X], end[Y], xl, yt, xr, yt, &xi, &yi)) {
replace[X] = xi;
replace[Y] = yi;
inside++;
}
}
if (inside < 2) {
return (0); /* no intersect or only 1 point on corner */
}
/* compare dist of intersects to bgn - closest replaces bgn */
if (GS_P2distance(bgn, pt1) < GS_P2distance(bgn, pt2)) {
bgn[X] = pt1[X];
bgn[Y] = pt1[Y];
end[X] = pt2[X];
end[Y] = pt2[Y];
}
else {
bgn[X] = pt2[X];
bgn[Y] = pt2[Y];
end[X] = pt1[X];
end[Y] = pt1[Y];
}
}
return (1);
}
/*!
\brief Get diagonal intersects
Colinear already eliminated
\param gs surface (geosurf)
\param bgn begin point
\param end end point
\param dir ? (unused)
\return number of intersects
*/
int get_diag_intersects(geosurf * gs, float *bgn, float *end, float *dir)
{
int fdig, ldig, incr, hits, num, offset;
int vrow, vcol, drow1, drow2, dcol1, dcol2;
float xl, yb, xr, yt, z1, z2, alpha;
float xres, yres, xi, yi, dx, dy;
int diags, cols, rows, lower;
Point3 pt;
xres = VXRES(gs);
yres = VYRES(gs);
cols = VCOLS(gs);
rows = VROWS(gs);
diags = rows + cols; /* -1 ? */
/* determine upper/lower triangle for last */
vrow = Y2VROW(gs, end[Y]);
vcol = X2VCOL(gs, end[X]);
pt[X] = VCOL2X(gs, vcol);
pt[Y] = VROW2Y(gs, vrow + 1);
lower = ((end[X] - pt[X]) / xres > (end[Y] - pt[Y]) / yres);
ldig = lower ? vrow + vcol + 1 : vrow + vcol;
/* determine upper/lower triangle for first */
vrow = Y2VROW(gs, bgn[Y]);
vcol = X2VCOL(gs, bgn[X]);
pt[X] = VCOL2X(gs, vcol);
pt[Y] = VROW2Y(gs, vrow + 1);
lower = ((bgn[X] - pt[X]) / xres > (bgn[Y] - pt[Y]) / yres);
fdig = lower ? vrow + vcol + 1 : vrow + vcol;
/* adjust according to direction */
if (ldig > fdig) {
fdig++;
}
if (fdig > ldig) {
ldig++;
}
incr = ldig - fdig > 0 ? 1 : -1;
while (fdig > diags || fdig < 0) {
fdig += incr;
}
while (ldig > diags || ldig < 0) {
ldig -= incr;
}
num = abs(ldig - fdig) + 1;
for (hits = 0; hits < num; hits++) {
yb = gs->yrange - (yres * (fdig < rows ? fdig : rows)) - EPSILON;
xl = VCOL2X(gs, (fdig < rows ? 0 : fdig - rows)) - EPSILON;
yt = gs->yrange - (yres * (fdig < cols ? 0 : fdig - cols)) + EPSILON;
xr = VCOL2X(gs, (fdig < cols ? fdig : cols)) + EPSILON;
if (segs_intersect(bgn[X], bgn[Y], end[X], end[Y], xl, yb, xr, yt,
&xi, &yi)) {
Di[hits][X] = xi;
Di[hits][Y] = yi;
if (ISNODE(xi, xres)) {
/* then it's also a ynode */
num--;
hits--;
continue;
}
/* find data rows */
drow1 = Y2VROW(gs, Di[hits][Y]) * gs->y_mod;
drow2 = (1 + Y2VROW(gs, Di[hits][Y])) * gs->y_mod;
if (drow2 >= gs->rows) {
drow2 = gs->rows - 1; /* bottom edge */
}
/* find data cols */
if (Flat) {
Di[hits][Z] = gs->att[ATT_TOPO].constant;
}
else {
dcol1 = X2VCOL(gs, Di[hits][X]) * gs->x_mod;
dcol2 = (1 + X2VCOL(gs, Di[hits][X])) * gs->x_mod;
if (dcol2 >= gs->cols) {
dcol2 = gs->cols - 1; /* right edge */
}
dx = DCOL2X(gs, dcol2) - Di[hits][X];
dy = DROW2Y(gs, drow1) - Di[hits][Y];
alpha =
sqrt(dx * dx + dy * dy) / sqrt(xres * xres + yres * yres);
offset = DRC2OFF(gs, drow1, dcol2);
GET_MAPATT(Ebuf, offset, z1);
offset = DRC2OFF(gs, drow2, dcol1);
GET_MAPATT(Ebuf, offset, z2);
Di[hits][Z] = LERP(alpha, z1, z2);
}
}
/* if they don't intersect, something's wrong! */
/* should only happen on endpoint, so it will be added later */
else {
hits--;
num--;
}
fdig += incr;
}
return (hits);
}
