bool Rect::queryOnLine(point_t v1, point_t v2) {
//checks each edge of rect to see if line intersects
return (lineSegmentsIntersect({x,y},{x+w,y},v1,v2) ||
lineSegmentsIntersect({x,y},{x,y+h},v1,v2) ||
lineSegmentsIntersect({x,y+h},{x+w,y+h},v1,v2) ||
lineSegmentsIntersect({x+w,y},{x+w,y+h},v1,v2) ||
//checks if line contained within rect
queryContains(v1.getX(),v1.getY()));
}
point_t Rect::getContactPointOnLine(point_t v1, point_t v2) {
point_t closest;
float dist=std::numeric_limits<float>::max();
if (lineSegmentsIntersect({x,y},{x+w,y},v1,v2)) {
point_t trial = lineSegmentsIntersectCoord(v1,v2,{x,y},{x+w,y});
float dist_trial = (trial-v1).getMagnitude();
if (dist_trial<dist) {
closest=trial;
dist=dist_trial;
}
}
if (lineSegmentsIntersect({x,y},{x,y+h},v1,v2)) {
point_t trial = lineSegmentsIntersectCoord(v1,v2,{x,y},{x,y+h});
float dist_trial = (trial-v1).getMagnitude();
if (dist_trial<dist) {
closest=trial;
dist=dist_trial;
}
}
if (lineSegmentsIntersect({x,y+h},{x+w,y+h},v1,v2)) {
point_t trial = lineSegmentsIntersectCoord(v1,v2,{x,y+h},{x+w,y+h});
float dist_trial = (trial-v1).getMagnitude();
if (dist_trial<dist) {
closest=trial;
dist=dist_trial;
}
}
if (lineSegmentsIntersect({x+w,y},{x+w,y+h},v1,v2)) {
point_t trial = lineSegmentsIntersectCoord(v1,v2,{x+w,y},{x+w,y+h});
float dist_trial = (trial-v1).getMagnitude();
if (dist_trial<dist) {
closest=trial;
dist=dist_trial;
}
}
if (dist==std::numeric_limits<float>::max())
return v1;
return closest;
}
int polygon_overlap(Poly *p1, Poly *p2)
{
// loop over each pair of line segments, testing for intersection
int i, j;
for (i=0; i<p1->n-1; ++i) {
for (j=0; j<p2->n-1; ++j) {
if (lineSegmentsIntersect(
p1->x[i], p1->y[i], p1->x[i+1], p1->y[i+1],
p2->x[j], p2->y[j], p2->x[j+1], p2->y[j+1]))
{
return TRUE;
}
}
}
// test for containment: p2 in p1
int all_in=TRUE;
for (i=0; i<p2->n; ++i) {
if (!point_in_polygon(p1, p2->x[i], p2->y[i])) {
all_in=FALSE;
break;
}
}
if (all_in)
return TRUE;
// test for containment: p1 in p2
all_in = TRUE;
for (i=0; i<p1->n; ++i) {
if (!point_in_polygon(p2, p1->x[i], p1->y[i])) {
all_in=FALSE;
break;
}
}
if (all_in)
return TRUE;
// no overlap
return FALSE;
}
// return TRUE if there is any overlap between the two scenes
static int test_overlap(meta_parameters *meta1, meta_parameters *meta2)
{
if (!meta_is_valid_double(meta1->general->center_longitude)) {
int nl = meta1->general->line_count;
int ns = meta1->general->sample_count;
meta_get_latLon(meta1, nl/2, ns/2, 0,
&meta1->general->center_latitude,
&meta1->general->center_longitude);
}
if (!meta_is_valid_double(meta2->general->center_longitude)) {
int nl = meta2->general->line_count;
int ns = meta2->general->sample_count;
meta_get_latLon(meta2, nl/2, ns/2, 0,
&meta2->general->center_latitude,
&meta2->general->center_longitude);
}
int zone1 = utm_zone(meta1->general->center_longitude);
int zone2 = utm_zone(meta2->general->center_longitude);
// if zone1 & zone2 differ by more than 1, we can stop now
if (iabs(zone1-zone2) > 1) {
return FALSE;
}
// The Plan:
// Generate polygons for each metadata, then test of any pair of
// line segments between the polygons intersect.
// Other possibility: meta1 is completely contained within meta2,
// or the reverse.
// corners of meta1.
double xp_1[5], yp_1[5];
if (meta1->location) {
// use the location block if available
latLon2UTM_zone(meta1->location->lat_start_near_range,
meta1->location->lon_start_near_range, 0, zone1, &xp_1[0], &yp_1[0]);
latLon2UTM_zone(meta1->location->lat_start_far_range,
meta1->location->lon_start_far_range, 0, zone1, &xp_1[1], &yp_1[1]);
latLon2UTM_zone(meta1->location->lat_end_far_range,
meta1->location->lon_end_far_range, 0, zone1, &xp_1[2], &yp_1[2]);
latLon2UTM_zone(meta1->location->lat_end_near_range,
meta1->location->lon_end_near_range, 0, zone1, &xp_1[3], &yp_1[3]);
} else {
double lat, lon;
int nl1 = meta1->general->line_count;
int ns1 = meta1->general->sample_count;
// must call meta_get_latLon for each corner
meta_get_latLon(meta1, 0, 0, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_1[0], &yp_1[0]);
meta_get_latLon(meta1, nl1-1, 0, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_1[1], &yp_1[1]);
meta_get_latLon(meta1, nl1-1, ns1-1, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_1[2], &yp_1[2]);
meta_get_latLon(meta1, 0, ns1-1, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_1[3], &yp_1[3]);
}
// close the polygon
xp_1[4] = xp_1[0];
yp_1[4] = yp_1[0];
// corners of meta2.
double xp_2[5], yp_2[5];
if (meta2->location) {
// use the location block if available
latLon2UTM_zone(meta2->location->lat_start_near_range,
meta2->location->lon_start_near_range, 0, zone1, &xp_2[0], &yp_2[0]);
latLon2UTM_zone(meta2->location->lat_start_far_range,
meta2->location->lon_start_far_range, 0, zone1, &xp_2[1], &yp_2[1]);
latLon2UTM_zone(meta2->location->lat_end_far_range,
meta2->location->lon_end_far_range, 0, zone1, &xp_2[2], &yp_2[2]);
latLon2UTM_zone(meta2->location->lat_end_near_range,
meta2->location->lon_end_near_range, 0, zone1, &xp_2[3], &yp_2[3]);
} else {
double lat, lon;
int nl2 = meta2->general->line_count;
int ns2 = meta2->general->sample_count;
// must call meta_get_latLon for each corner
meta_get_latLon(meta2, 0, 0, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_2[0], &yp_2[0]);
meta_get_latLon(meta2, nl2-1, 0, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_2[1], &yp_2[1]);
meta_get_latLon(meta2, nl2-1, ns2-1, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_2[2], &yp_2[2]);
meta_get_latLon(meta2, 0, ns2-1, 0, &lat, &lon);
latLon2UTM_zone(lat, lon, 0, zone1, &xp_2[3], &yp_2[3]);
}
// close the polygon
xp_2[4] = xp_2[0];
yp_2[4] = yp_2[0];
// loop over each pair of line segments, testing for intersection
int i, j;
for (i = 0; i < 4; ++i) {
for (j = 0; j < 4; ++j) {
if (lineSegmentsIntersect(
xp_1[i], yp_1[i], xp_1[i+1], yp_1[i+1],
xp_2[j], yp_2[j], xp_2[j+1], yp_2[j+1]))
{
return TRUE;
}
}
}
// test for containment: meta2 in meta1
int all_in=TRUE;
for (i=0; i<4; ++i) {
if (!pnpoly(5, xp_1, yp_1, xp_2[i], yp_2[i])) {
all_in=FALSE;
break;
}
}
if (all_in)
return TRUE;
// test for containment: meta1 in meta2
all_in = TRUE;
for (i=0; i<4; ++i) {
if (!pnpoly(5, xp_2, yp_2, xp_1[i], yp_1[i])) {
all_in=FALSE;
break;
}
}
if (all_in)
return TRUE;
// no overlap
return FALSE;
}
