[architektonas] / src / dimension.cpp

// dimension.cpp: Dimension object
//
// 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  04/04/2011  Created this file, basic rendering
// JLH  03/14/2013  Updated to new connection system
//

#include "dimension.h"

#include <QtGui>
#include "mathconstants.h"
#include "painter.h"


Dimension::Dimension(Vector p1, Vector p2, DimensionType dt/*= DTLinear*/ ,Object * p/*= NULL*/):
        Object(p1, p), endpoint(p2),
        dragging(false), draggingHandle1(false), draggingHandle2(false),
        length(p2.Magnitude()), dimensionType(dt), size(0.25), point1(NULL), point2(NULL)
{
        // We set the size to 1/4 base unit. Could be anything.
        type = OTDimension;
}


// This is bad, p1 & p2 could be NULL, causing much consternation...
Dimension::Dimension(Connection p1, Connection p2, DimensionType dt/*= DTLinear*/ , Object * p/*= NULL*/):
        dragging(false), draggingHandle1(false), draggingHandle2(false),
        length(0), dimensionType(dt), size(0.25), point1(p1), point2(p2)
{
        type = OTDimension;
}


Dimension::~Dimension()
{
}


/*virtual*/ void Dimension::Draw(Painter * painter)
{
        // If there are valid Vector pointers in here, use them to update the internal
        // positions. Otherwise, we just use the internal positions by default.
        if (point1.object)
                position = point1.object->GetPointAtParameter(point1.t);

        if (point2.object)
                endpoint = point2.object->GetPointAtParameter(point2.t);

        if (state == OSSelected)
                painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
        else
//              painter->SetPen(QPen(Qt::blue, 1.0, Qt::SolidLine));
                painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));

        painter->SetBrush(QBrush(QColor(Qt::blue)));

        // Draw an aligned dimension line
        double angle = Vector(endpoint - position).Angle();
        double orthoAngle = angle + (PI / 2.0);
        Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle));
        Vector unit = Vector(endpoint - position).Unit();

// Arrowhead:
//      Point p1 = head - (unit * 9.0 * size);
//      Point p2 = p1 + (orthogonal * 3.0 * size);
//      Point p3 = p1 - (orthogonal * 3.0 * size);

/*
The numbers hardcoded into here, what are they?
I believe they are pixels.
*/

        // Get our line parallel to our points
        Point p1 = position + (orthogonal * 10.0 * size);
        Point p2 = endpoint + (orthogonal * 10.0 * size);

        Point p3 = position + (orthogonal * 16.0 * size);
        Point p4 = endpoint + (orthogonal * 16.0 * size);
        Point p5 = position + (orthogonal * 4.0 * size);
        Point p6 = endpoint + (orthogonal * 4.0 * size);

        // Draw extension lines
        painter->DrawLine(p3, p5);
        painter->DrawLine(p4, p6);

        // Calculate whether or not the arrowheads are too crowded to put inside
        // the extension lines. 9.0 is the length of the arrowhead.
//      double t = Vector::Parameter(position, endpoint, endpoint - (unit * 9.0 * size));
//      double t = Vector::Parameter(position, endpoint, position + (unit * 9.0 * size));
        double t = Vector::Parameter(endpoint, position, position + (unit * 9.0 * size));
//printf("Dimension::Draw(): t = %lf\n", t);

// On the screen, it's acting like this is actually 58%...
// This is correct, we want it to happen at > 50%
        if (t > 0.58)
        {
                // Draw main dimension line + arrowheads
                painter->DrawLine(p1, p2);
                painter->DrawArrowhead(p1, p2, size);
                painter->DrawArrowhead(p2, p1, size);
        }
        else
        {
                Point p7 = p1 - (unit * 9.0 * size);
                Point p8 = p2 + (unit * 9.0 * size);
                painter->DrawArrowhead(p1, p7, size);
                painter->DrawArrowhead(p2, p8, size);
                painter->DrawLine(p1, p1 - (unit * 14.0 * size));
                painter->DrawLine(p2, p2 + (unit * 14.0 * size));
        }

        // Draw length of dimension line...
        painter->SetFont(QFont("Arial", 8.0 * Painter::zoom * size));
        Vector v1((p1.x - p2.x) / 2.0, (p1.y - p2.y) / 2.0);
        Point ctr = p2 + v1;
        QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude());
        painter->DrawAngledText(ctr, angle, dimText, size);
}


/*virtual*/ Vector Dimension::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 Dimension::Collided(Vector /*point*/)
{
#if 0
        objectWasDragged = false;
        Vector lineSegment = endpoint - position;
        Vector v1 = point - position;
        Vector v2 = point - endpoint;
        double parameterizedPoint = lineSegment.Dot(v1) / lineSegment.Magnitude(), distance;

        // Geometric interpretation:
        // pp is the paremeterized point on the vector ls 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;
                }
        }
#endif

        state = OSInactive;
        return false;
}


/*virtual*/ void Dimension::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;
}


/*virtual*/ void Dimension::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;
}


/*virtual*/ void Dimension::Enumerate(FILE * file)
{
        fprintf(file, "DIMENSION (%lf,%lf) (%lf,%lf) %i\n", position.x, position.y, endpoint.x, endpoint.y, type);
}


// Dimensions are special: they contain exactly *two* points. Here, we check
// only for zero/non-zero in returning the correct points.
/*virtual*/ Vector Dimension::GetPointAtParameter(double parameter)
{
        if (parameter == 0)
                return position;

        return endpoint;
}


/*virtual*/ void Dimension::Connect(Object * obj, double param)
{
        // There are four possibilities here...
        // The param is only looking for 0 or 1 here.
        if (point1.object == NULL && point2.object == NULL)
        {
                point1.object = obj;
                point1.t = param;
        }
        else if (point1.object == NULL && point2.object != NULL)
        {
                if (point2.t == param)
                        point2.object = obj;
                else
                {
                        point1.object = obj;
                        point1.t = param;
                }
        }
        else if (point1.object != NULL && point2.object == NULL)
        {
                if (point1.t == param)
                        point1.object = obj;
                else
                {
                        point2.object = obj;
                        point2.t = param;
                }
        }
        else if (point1.object != NULL && point2.object != NULL)
        {
                if (point1.t == param)
                        point1.object = obj;
                else
                        point2.object = obj;
        }
}


/*virtual*/ void Dimension::Disconnect(Object * obj, double param)
{
        if (point1.object == obj && point1.t == param)
                point1.object = NULL;
        else if (point2.object == obj && point2.t == param)
                point2.object = NULL;
}


/*virtual*/ void Dimension::DisconnectAll(Object * obj)
{
        if (point1.object == obj)
                point1.object = NULL;

        if (point2.object == obj)
                point2.object = NULL;
}


/*virtual*/ QRectF Dimension::Extents(void)
{
        Point p1 = position;
        Point p2 = endpoint;

        if (point1.object)
                p1 = point1.object->GetPointAtParameter(point1.t);

        if (point2.object)
                p2 = point2.object->GetPointAtParameter(point2.t);

        return QRectF(QPointF(p1.x, p1.y), QPointF(p2.x, p2.y));
}


#if 0
/*virtual*/ ObjectType Dimension::Type(void)
{
        return OTDimension;
}
#endif


void Dimension::FlipSides(void)
{
#if 0
        Vector tmp = position;
        position = endpoint;
        endpoint = tmp;
#else
        Connection tmp = point1;
        point1 = point2;
        point2 = tmp;
//      double tmp = point1.t;
//      point1.t = point2.t;
//      point2.t = tmp;
//      Object * tmp = point1.object;
//      point1.object = point2.object;
//      point2.object = tmp;
#endif
        needUpdate = true;
}