Fixed incorrect rotation in Arc object.

[architektonas] / src / geometry.cpp

// geometry.cpp: Algebraic geometry helper functions
//
// Part of the Architektonas Project
// (C) 2011 Underground Software
// See the README and GPLv3 files for licensing and warranty information
//
// JLH = James Hammons <jlhamm@acm.org>
//
// WHO  WHEN        WHAT
// ---  ----------  ------------------------------------------------------------
// JLH  08/31/2011  Created this file
//
// NOTE: All methods in this class are static.
//

#include "geometry.h"
#include <math.h>
#include "circle.h"
#include "dimension.h"
#include "line.h"


Point Geometry::IntersectionOfLineAndLine(Point p1, Point p2, Point p3, Point p4)
{
        // Find the intersection of the lines by formula:
        // px = (x1y2 - y1x2)(x3 - x4) - (x1 - x2)(x3y4 - y3x4)
        // py = (x1y2 - y1x2)(y3 - y4) - (y1 - y2)(x3y4 - y3x4)
        // d = (x1 - x2)(y3 - y4) - (y1 - y2)(x3 - x4) = 0 if lines are parallel
        // Intersection is (px / d, py / d)

        double d = ((p1.x - p2.x) * (p3.y - p4.y)) - ((p1.y - p2.y) * (p3.x - p4.x));

        // Check for parallel lines, and return sentinel if so
        if (d == 0)
                return Point(0, 0, -1);

        double px = (((p1.x * p2.y) - (p1.y * p2.x)) * (p3.x - p4.x))
                - ((p1.x - p2.x) * ((p3.x * p4.y) - (p3.y * p4.x)));
        double py = (((p1.x * p2.y) - (p1.y * p2.x)) * (p3.y - p4.y))
                - ((p1.y - p2.y) * ((p3.x * p4.y) - (p3.y * p4.x)));

        return Point(px / d, py / d, 0);
}


// Returns the parameter of a point in space to this vector. If the parameter
// is between 0 and 1, the normal of the vector to the point is on the vector.
// Note: lp1 is the tail, lp2 is the head of the line (vector).
double Geometry::ParameterOfLineAndPoint(Point tail, Point head, Point point)
{
        // Geometric interpretation:
        // The parameterized point on the vector lineSegment is where the normal of
        // the lineSegment to the point intersects lineSegment. If the pp < 0, then
        // the perpendicular lies beyond the 1st endpoint. If pp > 1, then the
        // perpendicular lies beyond the 2nd endpoint.

        Vector lineSegment = head - tail;
        double magnitude = lineSegment.Magnitude();
        Vector pointSegment = point - tail;
        double t = lineSegment.Dot(pointSegment) / (magnitude * magnitude);
        return t;
}


Point Geometry::MirrorPointAroundLine(Point point, Point tail, Point head)
{
        // Get the vector of the intersection of the line and the normal on the
        // line to the point in question.
        double t = ParameterOfLineAndPoint(tail, head, point);
        Vector v = Vector(tail, head) * t;

        // Get the point normal to point to the line passed in
        Point normalOnLine = tail + v;

        // Make our mirrored vector (head - tail)
        Vector mirror = -(point - normalOnLine);

        // Find the mirrored point
        Point mirroredPoint = normalOnLine + mirror;

        return mirroredPoint;
}


Point Geometry::RotatePointAroundPoint(Point point, Point rotationPoint, double angle)
{
        Vector v = Vector(point, rotationPoint);
//      Vector v = Vector(rotationPoint, point);
        double px = (v.x * cos(angle)) - (v.y * sin(angle));
        double py = (v.x * sin(angle)) + (v.y * cos(angle));

        return Vector(rotationPoint.x + px, rotationPoint.y + py, 0);
}


double Geometry::Determinant(Point p1, Point p2)
{
        return (p1.x * p2.y) - (p2.x * p1.y);
}


/*
Intersecting line segments:
An easier way:
Segment L1 has edges A=(a1,a2), A'=(a1',a2').
Segment L2 has edges B=(b1,b2), B'=(b1',b2').
Segment L1 is the set of points tA'+(1-t)A, where 0<=t<=1.
Segment L2 is the set of points sB'+(1-s)B, where 0<=s<=1.
Segment L1 meet segment L2 if and only if for some t and s we have
tA'+(1-t)A=sB'+(1-s)B
The solution of this with respect to t and s is

t=((-b?'a?+b?'b?+b?a?+a?b?'-a?b?-b?b?')/(b?'a?'-b?'a?-b?a?'+b?a?-a?'b?'+a?'b?+a?b?'-a?b?))

s=((-a?b?+a?'b?-a?a?'+b?a?+a?'a?-b?a?')/(b?'a?'-b?'a?-b?a?'+b?a?-a?'b??+a?'b?+a?b?'-a?b?))

So check if the above two numbers are both >=0 and <=1.
*/


#if 0
// Finds the intesection between two objects (if any)
bool Geometry::Intersects(Object * obj1, Object * obj2, double * t, double * s)
{
}
#endif

// Finds the intersection between two lines (if any)
int Geometry::Intersects(Line * l1, Line * l2, double * tp/*= 0*/, double * up/*= 0*/)
{
        Vector r(l1->position, l1->endpoint);
        Vector s(l2->position, l2->endpoint);
        Vector v1 = l2->position - l1->position;        // q - p
//      Vector v2 = l1->position - l2->position;        // p - q
//printf("l1: (%lf, %lf) (%lf, %lf), l2: (%lf, %lf) (%lf, %lf)\n", l1->position.x, l1->position.y, l1->endpoint.x, l1->endpoint.y, l2->position.x, l2->position.y, l2->endpoint.x, l2->endpoint.y);
        double rxs = (r.x * s.y) - (s.x * r.y);
        double t, u;

        if (rxs == 0)
        {
                double qpxr = (v1.x * r.y) - (r.x * v1.y);

//printf("  --> R x S = 0! (q - p) x r = %lf\n", qpxr);
//printf("  -->(q - p) . r = %lf, r . r = %lf\n", v1.Dot(r), r.Dot(r));
//printf("  -->(p - q) . s = %lf, s . s = %lf\n", v2.Dot(s), s.Dot(s));
//printf("  -->(q - p) . s = %lf, (p - q) . r = %lf\n", v1.Dot(s), v2.Dot(r));

                // Lines are parallel, so no intersection...
                if (qpxr != 0)
                        return 0;

#if 0
//this works IFF the vectors are pointing in the same direction. everything else
//is fucked!
                // If (q - p) . r == r . r, t = 1, u = 0
                if (v1.Dot(r) == r.Dot(r))
                        t = 1.0, u = 0;
                // If (p - q) . s == s . s, t = 0, u = 1
                else if (v2.Dot(s) == s.Dot(s))
                        t = 0, u = 1.0;
                else
                        return 0;
#else
                // Check to see which endpoints are connected... Four possibilities:
                if (l1->position == l2->position)
                        t = 0, u = 0;
                else if (l1->position == l2->endpoint)
                        t = 0, u = 1.0;
                else if (l1->endpoint == l2->position)
                        t = 1.0, u = 0;
                else if (l1->endpoint == l2->endpoint)
                        t = 1.0, u = 1.0;
                else
                        return 0;
#endif
        }
        else
        {
                t = ((v1.x * s.y) - (s.x * v1.y)) / rxs;
                u = ((v1.x * r.y) - (r.x * v1.y)) / rxs;
        }
/*
Now there are five cases (NOTE: only valid if vectors face the same way!):

1. If r × s = 0 and (q − p) × r = 0, then the two lines are collinear. If in addition, either 0 ≤ (q − p) · r ≤ r · r or 0 ≤ (p − q) · s ≤ s · s, then the two lines are overlapping.

2. If r × s = 0 and (q − p) × r = 0, but neither 0 ≤ (q − p) · r ≤ r · r nor 0 ≤ (p − q) · s ≤ s · s, then the two lines are collinear but disjoint.

3. If r × s = 0 and (q − p) × r ≠ 0, then the two lines are parallel and non-intersecting.

4. If r × s ≠ 0 and 0 ≤ t ≤ 1 and 0 ≤ u ≤ 1, the two line segments meet at the point p + t r = q + u s.

5. Otherwise, the two line segments are not parallel but do not intersect.
*/
        // Return parameter values, if user passed in valid pointers
        if (tp)
                *tp = t;

        if (up)
                *up = u;

        // If the parameters are in range, we have overlap!
        if ((t >= 0) && (t <= 1.0) && (u >= 0) && (u <= 1.0))
                return 1;

        return 0;
}


// Finds the intersection between two lines (if any)
int Geometry::Intersects(Line * l1, Dimension * d1, double * tp/*= 0*/, double * up/*= 0*/)
{
        Line l2(d1->position, d1->endpoint);
        return Intersects(l1, &l2, tp, up);
}


// Finds the intesection(s) between a line and a circle (if any)
int Geometry::Intersects(Line * l, Circle * c, double * tp/*= 0*/, double * up/*= 0*/, double * vp/*= 0*/, double * wp/*= 0*/)
{
#if 0
        Vector center = c->position;
        Vector v1 = l->position - center;
        Vector v2 = l->endpoint - center;
        Vector d = v2 - v1;
        double dr = d.Magnitude();
        double determinant = (v1.x * v2.y) - (v1.y * v2.x);

        double discriminant = ((c->radius * c->radius) * (dr * dr)) - (determinant * determinant);

        if (discriminant < 0)
                return false;

        

        return true;
#else
/*
I'm thinking a better approach to this might be as follows:

-- Get the distance of the circle's center from the line segment. If it's
   > the radius, it doesn't intersect.
-- If the parameter is off the line segment, check distance to endpoints. (Not sure
   how to proceed from here, it's different than the following.)
   [Actually, you can use the following for all of it. You only know if you have
    an intersection at the last step, which is OK.]
-- If the radius == distance, we have a tangent line.
-- If radius > distance, use Pythagorus to find the length on either side of the
   normal to the spots where the hypotenuse (== radius' length) contact the line.
-- Use those points to find the parameter on the line segment; if they're not on
   the line segment, no intersection.
*/
        double t = ParameterOfLineAndPoint(l->position, l->endpoint, c->position);
//small problem here: it clamps the result to the line segment. NOT what we want
//here! !!! FIX !!! [DONE]
        Vector p = l->GetPointAtParameter(t);
        double distance = Vector::Magnitude(c->position, p);

        // If the center of the circle is farther from the line than the radius, fail.
        if (distance > c->radius)
                return 0;

        // Now we have to check for intersection points.
        // Tangent case: (needs to return something)
        if ((distance == c->radius) && (t >= 0.0) && (t <= 1.0))
                return 1;

        // The line intersects the circle in two points (possibly). Use Pythagorus
        // to find them for testing.
        double offset = sqrt((c->radius * c->radius) - (distance * distance));
//need to convert distance to paramter value... :-/
//t = position on line / length of line segment, so if we divide the offset by length,
//that should give us what we want.
        double length = Vector::Magnitude(l->position, l->endpoint);
        double t1 = t + (offset / length);
        double t2 = t - (offset / length);

//need to find angles for the circle...
        Vector cp1 = l->position + (Vector(l->position, l->endpoint) * (length * t1));
        Vector cp2 = l->position + (Vector(l->position, l->endpoint) * (length * t2));
        double a1 = Vector(c->position, cp1).Angle();
        double a2 = Vector(c->position, cp2).Angle();

//instead of this, return a # which is the # of intersections. [DONE]
        int intersections = 0;

        // Now check for if the parameters are in range
        if ((t1 >= 0) && (t1 <= 1.0))
        {
                intersections++;
        }

        if ((t2 >= 0) && (t2 <= 1.0))
        {
                intersections++;
        }

        return intersections;
#endif
}