1 // dimension.cpp: Dimension object
3 // Part of the Architektonas Project
4 // (C) 2011 Underground Software
5 // See the README and GPLv3 files for licensing and warranty information
7 // JLH = James Hammons <jlhamm@acm.org>
10 // --- ---------- ------------------------------------------------------------
11 // JLH 04/04/2011 Created this file, basic rendering
12 // JLH 03/14/2013 Updated to new connection system
15 #include "dimension.h"
18 #include "mathconstants.h"
22 Dimension::Dimension(Vector p1, Vector p2, DimensionType dt/*= DTLinear*/ ,Object * p/*= NULL*/):
23 Object(p1, p), endpoint(p2),
24 dragging(false), draggingHandle1(false), draggingHandle2(false),
25 length(p2.Magnitude()), dimensionType(dt), size(0.25), point1(NULL), point2(NULL)
27 // We set the size to 1/4 base unit. Could be anything.
32 // This is bad, p1 & p2 could be NULL, causing much consternation...
33 Dimension::Dimension(Connection p1, Connection p2, DimensionType dt/*= DTLinear*/ , Object * p/*= NULL*/):
34 dragging(false), draggingHandle1(false), draggingHandle2(false),
35 length(0), dimensionType(dt), size(0.25), point1(p1), point2(p2)
41 Dimension::~Dimension()
46 /*virtual*/ void Dimension::Draw(Painter * painter)
48 // If there are valid Vector pointers in here, use them to update the internal
49 // positions. Otherwise, we just use the internal positions by default.
51 position = point1.object->GetPointAtParameter(point1.t);
54 endpoint = point2.object->GetPointAtParameter(point2.t);
56 if (state == OSSelected)
57 painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
59 // painter->SetPen(QPen(Qt::blue, 1.0, Qt::SolidLine));
60 painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
62 painter->SetBrush(QBrush(QColor(Qt::blue)));
64 // Draw an aligned dimension line
65 double angle = Vector(endpoint - position).Angle();
66 double orthoAngle = angle + (PI / 2.0);
67 Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle));
68 Vector unit = Vector(endpoint - position).Unit();
71 // Point p1 = head - (unit * 9.0 * size);
72 // Point p2 = p1 + (orthogonal * 3.0 * size);
73 // Point p3 = p1 - (orthogonal * 3.0 * size);
76 The numbers hardcoded into here, what are they?
77 I believe they are pixels.
80 // Get our line parallel to our points
81 Point p1 = position + (orthogonal * 10.0 * size);
82 Point p2 = endpoint + (orthogonal * 10.0 * size);
84 Point p3 = position + (orthogonal * 16.0 * size);
85 Point p4 = endpoint + (orthogonal * 16.0 * size);
86 Point p5 = position + (orthogonal * 4.0 * size);
87 Point p6 = endpoint + (orthogonal * 4.0 * size);
89 // Draw extension lines
90 painter->DrawLine(p3, p5);
91 painter->DrawLine(p4, p6);
93 // Calculate whether or not the arrowheads are too crowded to put inside
94 // the extension lines. 9.0 is the length of the arrowhead.
95 double t = Vector::Parameter(position, endpoint, endpoint - (unit * 9.0 * size));
96 //printf("Dimension::Draw(): t = %lf\n", t);
100 // Draw main dimension line + arrowheads
101 painter->DrawLine(p1, p2);
102 painter->DrawArrowhead(p1, p2, size);
103 painter->DrawArrowhead(p2, p1, size);
107 Point p7 = p1 - (unit * 9.0 * size);
108 Point p8 = p2 + (unit * 9.0 * size);
109 painter->DrawArrowhead(p1, p7, size);
110 painter->DrawArrowhead(p2, p8, size);
111 painter->DrawLine(p1, p1 - (unit * 14.0 * size));
112 painter->DrawLine(p2, p2 + (unit * 14.0 * size));
115 // Draw length of dimension line...
116 painter->SetFont(QFont("Arial", 10.0 * Painter::zoom * size));
117 Vector v1((p1.x - p2.x) / 2.0, (p1.y - p2.y) / 2.0);
119 QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude());
120 painter->DrawAngledText(ctr, angle, dimText, size);
124 /*virtual*/ Vector Dimension::Center(void)
126 // Technically, this is the midpoint but who are we to quibble? :-)
127 Vector v((position.x - endpoint.x) / 2.0, (position.y - endpoint.y) / 2.0);
132 /*virtual*/ bool Dimension::Collided(Vector /*point*/)
135 objectWasDragged = false;
136 Vector lineSegment = endpoint - position;
137 Vector v1 = point - position;
138 Vector v2 = point - endpoint;
139 double parameterizedPoint = lineSegment.Dot(v1) / lineSegment.Magnitude(), distance;
141 // Geometric interpretation:
142 // pp is the paremeterized point on the vector ls where the perpendicular intersects ls.
143 // If pp < 0, then the perpendicular lies beyond the 1st endpoint. If pp > length of ls,
144 // then the perpendicular lies beyond the 2nd endpoint.
146 if (parameterizedPoint < 0.0)
147 distance = v1.Magnitude();
148 else if (parameterizedPoint > lineSegment.Magnitude())
149 distance = v2.Magnitude();
150 else // distance = ?Det?(ls, v1) / |ls|
151 distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y) / lineSegment.Magnitude());
153 // If the segment endpoints are s and e, and the point is p, then the test for the perpendicular
154 // intercepting the segment is equivalent to insisting that the two dot products {s-e}.{s-p} and
155 // {e-s}.{e-p} are both non-negative. Perpendicular distance from the point to the segment is
156 // computed by first computing the area of the triangle the three points form, then dividing by the
157 // length of the segment. Distances are done just by the Pythagorean theorem. Twice the area of the
158 // triangle formed by three points is the determinant of the following matrix:
164 // By translating the start point to the origin, this can be rewritten as:
165 // By subtracting row 1 from all rows, you get the following:
166 // [because sx = sy = 0. you could leave out the -sx/y terms below. because we subtracted
167 // row 1 from all rows (including row 1) row 1 turns out to be zero. duh!]
170 // (ex - sx) (ey - sy) 0 ==> ex ey 0
171 // (px - sx) (py - sy) 0 px py 0
173 // which greatly simplifies the calculation of the determinant.
175 if (state == OSInactive)
177 //printf("Line: pp = %lf, length = %lf, distance = %lf\n", parameterizedPoint, lineSegment.Magnitude(), distance);
178 //printf(" v1.Magnitude = %lf, v2.Magnitude = %lf\n", v1.Magnitude(), v2.Magnitude());
179 //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);
181 //How to translate this into pixels from Document space???
182 //Maybe we need to pass a scaling factor in here from the caller? That would make sense, as
183 //the caller knows about the zoom factor and all that good kinda crap
184 if (v1.Magnitude() < 10.0)
188 oldPoint = position; //maybe "position"?
189 draggingHandle1 = true;
192 else if (v2.Magnitude() < 10.0)
196 oldPoint = endpoint; //maybe "position"?
197 draggingHandle2 = true;
200 else if (distance < 2.0)
209 else if (state == OSSelected)
211 // Here we test for collision with handles as well! (SOON!)
214 if (v1.Magnitude() < 2.0) // Handle #1
215 else if (v2.Magnitude() < 2.0) // Handle #2
220 // state = OSInactive;
233 /*virtual*/ void Dimension::PointerMoved(Vector point)
235 // We know this is true because mouse move messages don't come here unless
236 // the object was actually clicked on--therefore we *know* we're being
238 objectWasDragged = true;
242 // Here we need to check whether or not we're dragging a handle or the object itself...
243 Vector delta = point - oldPoint;
251 else if (draggingHandle1)
253 Vector delta = point - oldPoint;
260 else if (draggingHandle2)
262 Vector delta = point - oldPoint;
274 /*virtual*/ void Dimension::PointerReleased(void)
276 if (draggingHandle1 || draggingHandle2)
278 // Set the length (in case the global state was set to fixed (or not))
279 if (Object::fixedLength)
282 if (draggingHandle1) // startpoint
284 Vector v = Vector(position - endpoint).Unit() * length;
285 position = endpoint + v;
289 // Vector v1 = endpoint - position;
290 Vector v = Vector(endpoint - position).Unit() * length;
291 endpoint = position + v;
296 // Otherwise, we calculate the new length, just in case on the next move
297 // it turns out to have a fixed length. :-)
298 length = Vector(endpoint - position).Magnitude();
303 draggingHandle1 = false;
304 draggingHandle2 = false;
306 // Here we check for just a click: If object was clicked and dragged, then
307 // revert to the old state (OSInactive). Otherwise, keep the new state that
309 /*Maybe it would be better to just check for "object was dragged" state and not have to worry
310 about keeping track of old states...
312 if (objectWasDragged)
317 /*virtual*/ void Dimension::Enumerate(FILE * file)
319 fprintf(file, "DIMENSION (%lf,%lf) (%lf,%lf) %i\n", position.x, position.y, endpoint.x, endpoint.y, type);
323 // Dimensions are special: they contain exactly *two* points. Here, we check
324 // only for zero/non-zero in returning the correct points.
325 /*virtual*/ Vector Dimension::GetPointAtParameter(double parameter)
334 /*virtual*/ void Dimension::Connect(Object * obj, double param)
336 // There are four possibilities here...
337 // The param is only looking for 0 or 1 here.
338 if (point1.object == NULL && point2.object == NULL)
343 else if (point1.object == NULL && point2.object != NULL)
345 if (point2.t == param)
353 else if (point1.object != NULL && point2.object == NULL)
355 if (point1.t == param)
363 else if (point1.object != NULL && point2.object != NULL)
365 if (point1.t == param)
373 /*virtual*/ void Dimension::Disconnect(Object * obj, double param)
375 if (point1.object == obj && point1.t == param)
376 point1.object = NULL;
377 else if (point2.object == obj && point2.t == param)
378 point2.object = NULL;
382 /*virtual*/ void Dimension::DisconnectAll(Object * obj)
384 if (point1.object == obj)
385 point1.object = NULL;
387 if (point2.object == obj)
388 point2.object = NULL;
392 /*virtual*/ QRectF Dimension::Extents(void)
398 p1 = point1.object->GetPointAtParameter(point1.t);
401 p2 = point2.object->GetPointAtParameter(point2.t);
403 return QRectF(QPointF(p1.x, p1.y), QPointF(p2.x, p2.y));
408 /*virtual*/ ObjectType Dimension::Type(void)
415 void Dimension::FlipSides(void)
418 Vector tmp = position;
422 Connection tmp = point1;
425 // double tmp = point1.t;
426 // point1.t = point2.t;
428 // Object * tmp = point1.object;
429 // point1.object = point2.object;
430 // point2.object = tmp;