[architektonas] / src / line.cpp

// line.cpp: Line object
//
// Part of the Architektonas Project
// (C) 2011 Underground Software
// See the README and GPLv3 files for licensing and warranty information
//
// JLH = James L. Hammons <jlhamm@acm.org>
//
// WHO  WHEN        WHAT
// ---  ----------  ------------------------------------------------------------
// JLH  03/22/2011  Created this file
// JLH  04/11/2011  Fixed attached dimensions to stay at correct length when
//                  "Fixed Length" button is down
// JLH  04/27/2011  Fixed attached dimension to stay a correct length when
//                  "Fixed Length" button is *not* down ;-)
//

#include "line.h"

#include <QtGui>
#include "dimension.h"

Line::Line(Vector p1, Vector p2, Object * p/*= NULL*/): Object(p1, p), endpoint(p2),
        dragging(false), draggingHandle1(false), draggingHandle2(false), //needUpdate(false),
        length(Vector::Magnitude(p2, p1))
{
}

Line::~Line()
{
}

/*virtual*/ void Line::Draw(QPainter * painter)
{
        if (state == OSSelected)
                painter->setPen(QPen(Qt::red, 2.0, Qt::DotLine));
        else
                painter->setPen(QPen(Qt::black, 1.0, Qt::SolidLine));

//      if (draggingHandle1)
        if (state == OSSelected)
                painter->drawEllipse(QPointF(position.x, position.y), 4.0, 4.0);

//      if (draggingHandle2)
        if (state == OSSelected)
                painter->drawEllipse(QPointF(endpoint.x, endpoint.y), 4.0, 4.0);

        if (Object::fixedLength && (draggingHandle1 || draggingHandle2))
        {
                Vector point1 = (draggingHandle1 ? endpoint : position);
                Vector point2 = (draggingHandle1 ? position : endpoint);

                Vector current(point2 - point1);
                Vector v = current.Unit() * length;
                Vector v2 = point1 + v;
                painter->drawLine((int)point1.x, (int)point1.y, (int)v2.x, (int)v2.y);

                if (current.Magnitude() > length)
                {
                        painter->setPen(QPen(QColor(128, 0, 0), 1.0, Qt::DashLine));
                        painter->drawLine((int)v2.x, (int)v2.y, (int)point2.x, (int)point2.y);
                }
        }
        else
                painter->drawLine((int)position.x, (int)position.y, (int)endpoint.x, (int)endpoint.y);
}

/*virtual*/ Vector Line::Center(void)
{
        // Technically, this is the midpoint but who are we to quibble? :-)
        Vector v((position.x - endpoint.x) / 2.0, (position.y - endpoint.y) / 2.0);
        return endpoint + v;
}

/*virtual*/ bool Line::Collided(Vector point)
{
        objectWasDragged = false;
        Vector lineSegment = endpoint - position;
        Vector v1 = point - position;
        Vector v2 = point - endpoint;
        double parameterizedPoint = lineSegment.Dot(v1) / lineSegment.Magnitude(), distance;

        // Geometric interpretation:
        // The paremeterized point on the vector ls is where the perpendicular intersects ls.
        // If pp < 0, then the perpendicular lies beyond the 1st endpoint. If pp > length of ls,
        // then the perpendicular lies beyond the 2nd endpoint.

        if (parameterizedPoint < 0.0)
                distance = v1.Magnitude();
        else if (parameterizedPoint > lineSegment.Magnitude())
                distance = v2.Magnitude();
        else                                    // distance = ?Det?(ls, v1) / |ls|
                distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y) / lineSegment.Magnitude());

        // If the segment endpoints are s and e, and the point is p, then the test for the perpendicular
        // intercepting the segment is equivalent to insisting that the two dot products {s-e}.{s-p} and
        // {e-s}.{e-p} are both non-negative.  Perpendicular distance from the point to the segment is
        // computed by first computing the area of the triangle the three points form, then dividing by the
        // length of the segment.  Distances are done just by the Pythagorean theorem.  Twice the area of the
        // triangle formed by three points is the determinant of the following matrix:
        //
        // sx sy 1
        // ex ey 1
        // px py 1
        //
        // By translating the start point to the origin, this can be rewritten as:
        // By subtracting row 1 from all rows, you get the following:
        // [because sx = sy = 0. you could leave out the -sx/y terms below. because we subtracted
        // row 1 from all rows (including row 1) row 1 turns out to be zero. duh!]
        //
        // 0         0         0        0  0  0
        // (ex - sx) (ey - sy) 0   ==>  ex ey 0
        // (px - sx) (py - sy) 0        px py 0
        //
        // which greatly simplifies the calculation of the determinant.

        if (state == OSInactive)
        {
//printf("Line: pp = %lf, length = %lf, distance = %lf\n", parameterizedPoint, lineSegment.Magnitude(), distance);
//printf("      v1.Magnitude = %lf, v2.Magnitude = %lf\n", v1.Magnitude(), v2.Magnitude());
//printf("      point = %lf,%lf,%lf; p1 = %lf,%lf,%lf; p2 = %lf,%lf,%lf\n", point.x, point.y, point.z, position.x, position.y, position.z, endpoint.x, endpoint.y, endpoint.z);
//printf("      \n", );
//How to translate this into pixels from Document space???
//Maybe we need to pass a scaling factor in here from the caller? That would make sense, as
//the caller knows about the zoom factor and all that good kinda crap
                if (v1.Magnitude() < 10.0)
                {
                        oldState = state;
                        state = OSSelected;
                        oldPoint = position; //maybe "position"?
                        draggingHandle1 = true;
                        return true;
                }
                else if (v2.Magnitude() < 10.0)
                {
                        oldState = state;
                        state = OSSelected;
                        oldPoint = endpoint; //maybe "position"?
                        draggingHandle2 = true;
                        return true;
                }
                else if (distance < 2.0)
                {
                        oldState = state;
                        state = OSSelected;
                        oldPoint = point;
                        dragging = true;
                        return true;
                }
        }
        else if (state == OSSelected)
        {
                // Here we test for collision with handles as well! (SOON!)
/*
Like so:
                if (v1.Magnitude() < 2.0) // Handle #1
                else if (v2.Magnitude() < 2.0) // Handle #2
*/
                if (distance < 2.0)
                {
                        oldState = state;
//                      state = OSInactive;
                        oldPoint = point;
                        dragging = true;
                        return true;
                }
        }

        state = OSInactive;
        return false;
}

/*virtual*/ void Line::PointerMoved(Vector point)
{
        // We know this is true because mouse move messages don't come here unless
        // the object was actually clicked on--therefore we *know* we're being
        // dragged...
        objectWasDragged = true;

        if (dragging)
        {
                // Here we need to check whether or not we're dragging a handle or the object itself...
                Vector delta = point - oldPoint;

                position += delta;
                endpoint += delta;

                oldPoint = point;
                needUpdate = true;
        }
        else if (draggingHandle1)
        {
                Vector delta = point - oldPoint;

                position += delta;

                oldPoint = point;
                needUpdate = true;
        }
        else if (draggingHandle2)
        {
                Vector delta = point - oldPoint;

                endpoint += delta;

                oldPoint = point;
                needUpdate = true;
        }
        else
                needUpdate = false;

        if (needUpdate)
        {
// should only do this if "Fixed Length" is set... !!! FIX !!! [DONE]
                Vector point1 = (draggingHandle1 ? endpoint : position);
                Vector point2 = (draggingHandle1 ? position : endpoint);

                Vector current(point2, point1);
                Vector v = current.Unit() * length;
                Vector v2 = point1 + v;

                //bleh
                if (!Object::fixedLength)
                        v2 = point2;

                if (dimPoint1)
                        dimPoint1->SetPoint1(draggingHandle1 ? v2 : position);
                
                if (dimPoint2)
                        dimPoint2->SetPoint2(draggingHandle2 ? v2 : endpoint);
        }
}

/*virtual*/ void Line::PointerReleased(void)
{
        if (draggingHandle1 || draggingHandle2)
        {
                // Set the length (in case the global state was set to fixed (or not))
                if (Object::fixedLength)
                {
                        if (draggingHandle1)    // startpoint
                        {
                                Vector v = Vector(position - endpoint).Unit() * length;
                                position = endpoint + v;
                        }
                        else                                    // endpoint
                        {
//                              Vector v1 = endpoint - position;
                                Vector v = Vector(endpoint - position).Unit() * length;
                                endpoint = position + v;
                        }
                }
                else
                {
                        // Otherwise, we calculate the new length, just in case on the next move
                        // it turns out to have a fixed length. :-)
                        length = Vector(endpoint - position).Magnitude();
                }
        }

        dragging = false;
        draggingHandle1 = false;
        draggingHandle2 = false;

        // Here we check for just a click: If object was clicked and dragged, then
        // revert to the old state (OSInactive). Otherwise, keep the new state that
        // we set.
/*Maybe it would be better to just check for "object was dragged" state and not have to worry
about keeping track of old states...
*/
        if (objectWasDragged)
                state = oldState;
}

void Line::SetDimensionOnPoint1(Dimension * dimension)
{
        dimPoint1 = dimension;

        if (dimension)
                dimension->SetPoint1(position);
}

void Line::SetDimensionOnPoint2(Dimension * dimension)
{
        dimPoint2 = dimension;

        if (dimension)
                dimension->SetPoint2(endpoint);
}

/*
Intersection of two lines:

Find where the lines with equations r = i + j + t (3i - j) and r = -i + s (j) intersect.

When they intersect, we can set the equations equal to one another:

i + j + t (3i - j) = -i + s (j)

Equating coefficients:
1 + 3t = -1 and 1 - t = s
So t = -2/3 and s = 5/3

The position vector of the intersection point is therefore given by putting t = -2/3 or s = 5/3 into one of the above equations. This gives -i +5j/3 .


so, let's say we have two lines, l1 and l2. Points are v0(p0x, p0y), v1(p1x, p1y) for l1
and v2(p2x, p2y), v3(p3x, p3y) for l2.

d1 = v1 - v0, d2 = v3 - v2

Our parametric equations for the line then are:

r1 = v0 + t(d1)
r2 = v2 + s(d2)

Set r1 = r2, thus we have:

v0 + t(d1) = v2 + s(d2)

Taking coefficients, we have:

p0x + t(d1x) = p2x + s(d2x)
p0y + t(d1y) = p2y + s(d2y)

rearranging we get:

t(d1x) - s(d2x) = p2x - p0x
t(d1y) - s(d2y) = p2y - p0y

Determinant D is ad - bc where the matrix look like:

a b
c d

so D = (d1x)(d2y) - (d2x)(d1y)
if D = 0, the lines are parallel.
Dx = (p2x - p0x)(d2y) - (d2x)(p2y - p0y)
Dy = (d1x)(p2y - p0y) - (p2x - p0x)(d1y)
t = Dx/D, s = Dy/D

We only need to calculate t, as we can then multiply it by d1 to get the intersection point.

---------------------------------------------------------------------------------------------------

The first and most preferred method for intersection calculation is the perp-product calculation. There are two vectors, v1 and v2. Create a third vector vector between the starting points of these vectors, and calculate the perp product of v2 and the two other vectors. These two scalars have to be divided to get the mulitplication ratio of v1 to reach intersection point. So:

v1 ( bx1 , by1 );
v2 ( bx2 , by2 );
v3 ( bx3 , by3 );

Perp product is equal with dot product of normal of first vector and the second vector, so we need normals:

n1 ( -by1 , bx1 );
n3 ( -by3 , bx3 );

Dot products:

dp1 = n3 . v2 = -by3 * bx2 + bx3 * by2;
dp2 = n1 . v2 = -by1 * bx2 + bx1 * by2;

ratio = dp1 / dp2;
crossing vector = v1 * ratio;

And that's it.

-----------------------------------

So... to code this, let's say we have two Lines: l1 & l2.

Vector v1 = l1.endpoint - l1.position;
Vector v2 = l2.endpoint - l2.position;
Vector v3 = v2 - v1;

Vector normal1(-v1.y, v1.x);
Vector normal3(-v3.y, v3.x);

double dotProduct1 = v2.Dot(normal1);
double dotProduct2 = v2.Dot(normal3);

if (dotProduct2 == 0)
        return ParallelLines;
else
{
        // I think we'd still have to add the intersection to the position point to get the intersection...
        Point intersection = v1 * (dotProduct1 / dotProduct2);
        return intersection;
}
*/