int main()
{
int n;
int r0, r1, r2, r3;
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
scanf("%d", &n);
while (n-- > 0)
{
scanf("%d %d %d %d %d %d %d %d",
&p0.x, &p0.y, &p1.x, &p1.y,
&r0, &r1, &r2, &r3);
rect[0].x = rect[1].x = MIN(r0, r2);
rect[0].y = rect[3].y = MIN(r1, r3);
rect[2].x = rect[3].x = MAX(r0, r2);
rect[1].y = rect[2].y = MAX(r1, r3);
if (IS_IN_RECT(rect[0].x, rect[2].x, rect[0].y, rect[2].y, p0.x, p0.y)
|| IS_IN_RECT(rect[0].x, rect[2].x, rect[0].y, rect[2].y, p1.x, p1.y))
{
SET_INTERSECTION_TRUE;
}
else
{
if (segments_intersect(rect[0], rect[1], p0, p1) == 1)
SET_INTERSECTION_TRUE;
if (segments_intersect(rect[1], rect[2], p0, p1) == 1)
SET_INTERSECTION_TRUE;
if (segments_intersect(rect[2], rect[3], p0, p1) == 1)
SET_INTERSECTION_TRUE;
if (segments_intersect(rect[0], rect[3], p0, p1) == 1)
SET_INTERSECTION_TRUE;
}
SET_INTERSECTION_FALSE;
}
#ifndef ONLINE_JUDGE
system("pause");
#endif
return 0;
}
bool path_intersects_path(PathIterator& p1, PathIterator& p2)
{
typedef agg::conv_curve<PathIterator> curve_t;
if (p1.total_vertices() < 2 || p2.total_vertices() < 2)
return false;
curve_t c1(p1);
curve_t c2(p2);
double x11, y11, x12, y12;
double x21, y21, x22, y22;
c1.vertex(&x11, &y11);
while (c1.vertex(&x12, &y12) != agg::path_cmd_stop)
{
c2.rewind(0);
c2.vertex(&x21, &y21);
while (c2.vertex(&x22, &y22) != agg::path_cmd_stop)
{
if (segments_intersect(x11, y11, x12, y12, x21, y21, x22, y22))
return true;
x21 = x22;
y21 = y22;
}
x11 = x12;
y11 = y12;
}
return false;
}
bool
path_intersects_path(PathIterator& p1, PathIterator& p2)
{
typedef PathNanRemover<PathIterator> no_nans_t;
typedef agg::conv_curve<no_nans_t> curve_t;
if (p1.total_vertices() < 2 || p2.total_vertices() < 2)
{
return false;
}
no_nans_t n1(p1, true, p1.has_curves());
no_nans_t n2(p2, true, p2.has_curves());
curve_t c1(n1);
curve_t c2(n2);
double x11, y11, x12, y12;
double x21, y21, x22, y22;
c1.vertex(&x11, &y11);
while (c1.vertex(&x12, &y12) != agg::path_cmd_stop)
{
c2.rewind(0);
c2.vertex(&x21, &y21);
while (c2.vertex(&x22, &y22) != agg::path_cmd_stop)
{
if (segments_intersect(x11, y11, x12, y12, x21, y21, x22, y22))
{
return true;
}
x21 = x22;
y21 = y22;
}
x11 = x12;
y11 = y12;
}
return false;
}
// Greedily compute a set of nonintersecting edges in a point cloud for testing purposes
// Warning: Takes O(n^3) time.
static Array<Vector<int,2>> greedy_nonintersecting_edges(RawArray<const Vector<real,2>> X, const int limit) {
const auto E = amap(quantizer(bounding_box(X)),X).copy();
const int n = E.size();
Array<Vector<int,2>> edges;
IntervalScope scope;
for (const int i : range(n*n)) {
const int pi = int(random_permute(n*n,key+14,i));
const int a = pi/n,
b = pi-n*a;
if (a < b) {
const auto Ea = Perturbed2(a,E[a]),
Eb = Perturbed2(b,E[b]);
for (const auto e : edges)
if (!e.contains(a) && !e.contains(b) && segments_intersect(Ea,Eb,Perturbed2(e.x,E[e.x]),Perturbed2(e.y,E[e.y])))
goto skip;
edges.append(vec(a,b));
if (edges.size()==limit || edges.size()==3*n-6)
break;
skip:;
}
}
return edges;
}
/* Check the polygon for self-intersection */
static int
Poly_check_is_simple(polypaths_planar_overridePolygonObject *self)
{
polypaths_planar_override_vec2_t **points, **p, *v;
polypaths_planar_override_vec2_t **open = NULL;
polypaths_planar_override_vec2_t **o, **next_open;
const Py_ssize_t size = Py_SIZE(self);
const Py_ssize_t last_index = size - 1;
int result = 1;
points = (polypaths_planar_override_vec2_t **)PyMem_Malloc(
sizeof(polypaths_planar_override_vec2_t *) * size);
if (points == NULL) {
PyErr_NoMemory();
result = 0;
goto finish;
}
DUP_FIRST_VERT(self);
p = points;
for (v = self->vert; v < self->vert + size; ++v) {
*(p++) = v;
}
qsort(points, size, sizeof(polypaths_planar_override_vec2_t *), compare_vec_lexi);
open = (polypaths_planar_override_vec2_t **)PyMem_Malloc(
sizeof(polypaths_planar_override_vec2_t *) * (size + 1));
if (open == NULL) {
PyErr_NoMemory();
result = 0;
goto finish;
}
next_open = open;
for (p = points; p < points + size; ++p) {
for (o = open; o < next_open; ++o) {
if ((*p == (*o)+1) | (*o - *p == last_index)) {
/* Segment end point */
--next_open;
if (o < next_open && *o != *next_open) {
*o = *next_open;
--o;
}
} else if (abs(*p - *o) > 1 && abs(*p - *o) < last_index
/* ignore adjacent edges */
&& segments_intersect(*p, (*p)+1, *o, (*o)+1)) {
self->flags |= POLY_SIMPLE_KNOWN_FLAG;
self->flags &= ~POLY_SIMPLE_FLAG;
goto finish;
}
}
*(next_open++) = *p;
}
self->flags |= POLY_SIMPLE_KNOWN_FLAG | POLY_SIMPLE_FLAG;
finish:
if (open != NULL) {
PyMem_Free(open);
}
if (points != NULL) {
PyMem_Free(points);
}
return result;
}
main()
{
point p1,p2,q1,q2,i;
line l1,l2;
segment s1,s2,s3,s4;
while ( scanf("%lf %lf",&p1[X],&p1[Y]) != EOF ) {
scanf("%lf %lf",&p2[X],&p2[Y]);
scanf("%lf %lf",&q1[X],&q1[Y]);
scanf("%lf %lf",&q2[X],&q2[Y]);
/*
print_point(p1);
print_point(p2);
print_point(q1);
print_point(q2);
*/
points_to_segment(p1,p2,&s1);
points_to_segment(q1,q2,&s2);
points_to_line(p1,p2,&l1);
points_to_line(q1,q2,&l2);
print_segment(s1);
print_segment(s2);
/*
printf("slope and line tests\n");
point_and_slope_to_line(p1,-l1.a,&l3);
print_line(l3);
point_and_slope_to_line(p2,-l1.a,&l3);
print_line(l3);
point_and_slope_to_line(q1,-l2.a,&l3);
print_line(l3);
point_and_slope_to_line(q2,-l2.a,&l3);
print_line(l3);
*/
printf("segments_intersect test\n");
printf("%d\n", segments_intersect(s1,s2));
printf("intersection point\n");
intersection_point(l1,l2,i);
print_point(i);
/*
printf("closest point\n");
closest_point(p1,l1,i);
print_point(i);
closest_point(p2,l1,i);
print_point(i);
closest_point(q1,l1,i);
print_point(i);
closest_point(q2,l1,i);
print_point(i);
closest_point(p1,l2,i);
print_point(i);
closest_point(p2,l2,i);
print_point(i);
closest_point(q1,l2,i);
print_point(i);
closest_point(q2,l2,i);
print_point(i);
*/
printf("--------------------------------\n");
}
}
int main(void) {
int i, j, k;
while(scanf("%d %d %d %d %d", &inicio.x, &inicio.y, &fim.x, &fim.y, &num_obstaculos)) {
if(inicio.x == 0 && inicio.y == 0 && fim.x == 0 && fim.y == 0 && num_obstaculos == 0) break;
/* init */
n = num_obstaculos*2 + 2;
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
w[i][j] = -1;
/* input */
for(i = 0; i < num_obstaculos; i++)
scanf("%d %d %d %d", &obsa[i].x, &obsa[i].y, &obsb[i].x, &obsb[i].y);
/* processa/modela o grafo */
/* adjacencia inicio-fim */
w[INICIO][FIM] = w[FIM][INICIO] = dist(inicio, fim);
for(i = 0; i < num_obstaculos; i++) {
if(segments_intersect(inicio, fim, obsa[i], obsb[i])) {
w[INICIO][FIM] = w[FIM][INICIO] = -1;
break;
}
}
/* adjacencias inicio-obs */
for(i = 0; i < num_obstaculos; i++) {
/* obsa */
w[INICIO][PONTOA(i)] = w[PONTOA(i)][INICIO] = dist(inicio, obsa[i]);
for(j = 0; j < num_obstaculos; j++) {
if(j != i && segments_intersect(inicio, obsa[i], obsa[j], obsb[j])) {
w[INICIO][PONTOA(i)] = w[PONTOA(i)][INICIO] = -1;
break;
}
}
/* obsb */
w[INICIO][PONTOB(i)] = w[PONTOB(i)][INICIO] = dist(inicio, obsb[i]);
for(j = 0; j < num_obstaculos; j++) {
if(j != i && segments_intersect(inicio, obsb[i], obsa[j], obsb[j])) {
w[INICIO][PONTOB(i)] = w[PONTOB(i)][INICIO] = -1;
break;
}
}
}
/* adjacencias obs-fim */
for(i = 0; i < num_obstaculos; i++) {
/* obsa */
w[FIM][PONTOA(i)] = w[PONTOA(i)][FIM] = dist(fim, obsa[i]);
for(j = 0; j < num_obstaculos; j++) {
if(j != i && segments_intersect(fim, obsa[i], obsa[j], obsb[j])) {
w[FIM][PONTOA(i)] = w[PONTOA(i)][FIM] = -1;
break;
}
}
/* obsb */
w[FIM][PONTOB(i)] = w[PONTOB(i)][FIM] = dist(fim, obsb[i]);
for(j = 0; j < num_obstaculos; j++) {
if(j != i && segments_intersect(fim, obsb[i], obsa[j], obsb[j])) {
w[FIM][PONTOB(i)] = w[PONTOB(i)][FIM] = -1;
break;
}
}
}
/* adjacencias obs-obs */
for(i = 0; i < num_obstaculos; i++) {
for(j = 0; j < num_obstaculos; j++) {
/* a-a */
if(i == j) continue;
w[PONTOA(i)][PONTOA(j)] = w[PONTOA(j)][PONTOA(i)] = dist(obsa[i], obsa[j]);
for(k = 0; k < num_obstaculos; k++) {
if(k != i && k != j && segments_intersect(obsa[i], obsa[j], obsa[k], obsb[k])) {
w[PONTOA(i)][PONTOA(j)] = w[PONTOA(j)][PONTOA(i)] = -1;
break;
}
}
/* b-b */
w[PONTOB(i)][PONTOB(j)] = w[PONTOB(j)][PONTOB(i)] = dist(obsb[i], obsb[j]);
for(k = 0; k < num_obstaculos; k++) {
if(k != i && k != j && segments_intersect(obsb[i], obsb[j], obsa[k], obsb[k])) {
w[PONTOB(i)][PONTOB(j)] = w[PONTOB(j)][PONTOB(i)] = -1;
break;
}
}
/* a-b */
w[PONTOA(i)][PONTOB(j)] = w[PONTOB(j)][PONTOA(i)] = dist(obsa[i], obsb[j]);
for(k = 0; k < num_obstaculos; k++) {
if(k != i && k != j && segments_intersect(obsa[i], obsb[j], obsa[k], obsb[k])) {
w[PONTOA(i)][PONTOB(j)] = w[PONTOB(j)][PONTOA(i)] = -1;
break;
}
}
/* b-a */
w[PONTOB(i)][PONTOA(j)] = w[PONTOA(j)][PONTOB(i)] = dist(obsb[i], obsa[j]);
for(k = 0; k < num_obstaculos; k++) {
if(k != i && k != j && segments_intersect(obsb[i], obsa[j], obsa[k], obsb[k])) {
w[PONTOB(i)][PONTOA(j)] = w[PONTOA(j)][PONTOB(i)] = -1;
break;
}
}
}
}
/* output */
printf("%.2lf\n", dijkstra(INICIO, FIM));
}
return 0;
}
