1 // line.cpp: Line 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 03/22/2011 Created this file
12 // JLH 04/11/2011 Fixed attached dimensions to stay at correct length when
13 // "Fixed Length" button is down
14 // JLH 04/27/2011 Fixed attached dimension to stay a correct length when
15 // "Fixed Length" button is *not* down ;-)
16 // JLH 05/29/2011 Added (some) mouseover hints
22 #include "container.h"
23 #include "dimension.h"
24 #include "mathconstants.h"
28 Line::Line(Vector p1, Vector p2, Object * p/*= NULL*/): Object(p1, p),
29 /*type(OTLine),*/ endpoint(p2),
30 draggingLine(false), draggingHandle1(false), draggingHandle2(false), //needUpdate(false),
31 length(Vector::Magnitude(p2, p1)), angle(Vector(endpoint - position).Unit()),
32 hitPoint1(false), hitPoint2(false), hitLine(false)
40 // Taking care of connections should be done by the Container, as we don't know
41 // anything about any other object connected to this one.
43 // If there are any attached Dimensions, we must set the attachment points
44 // to NULL since they will no longer be valid.
45 if (attachedDimension)
47 attachedDimension->SetPoint1(NULL);
48 attachedDimension->SetPoint2(NULL);
50 // IT WOULD BE NICE to have any object points attached to this line automagically
51 // connect to this dimension object at this point, instead of just becoming
57 /*virtual*/ void Line::Draw(Painter * painter)
59 painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
61 if ((state == OSSelected) || ((state == OSInactive) && hitPoint1))
62 painter->DrawHandle(position);
64 if ((state == OSSelected) || ((state == OSInactive) && hitPoint2))
65 painter->DrawHandle(endpoint);
67 if ((state == OSInactive) && !hitLine)
68 painter->SetPen(QPen(Qt::black, 1.0, Qt::SolidLine));
70 if (Object::fixedLength && (draggingHandle1 || draggingHandle2))
72 Vector point1 = (draggingHandle1 ? endpoint : position);
73 Vector point2 = (draggingHandle1 ? position : endpoint);
75 Vector current(point2 - point1);
76 Vector v = current.Unit() * length;
77 Vector v2 = point1 + v;
78 painter->DrawLine(point1, v2);
80 if (current.Magnitude() > length)
82 painter->SetPen(QPen(QColor(128, 0, 0), 1.0, Qt::DashLine));
83 painter->DrawLine(v2, point2);
87 painter->DrawLine(position, endpoint);
89 // If we're dragging an endpoint, draw an information panel showing both
90 // the length and angle being set.
91 if (draggingHandle1 || draggingHandle2)
93 double absAngle = (Vector(endpoint - position).Angle()) * RADIANS_TO_DEGREES;
94 double absLength = Vector(position - endpoint).Magnitude();
98 text = QObject::tr("Length: %1 in.\n") + QChar(0x2221) + QObject::tr(": %2");
99 text = text.arg(absLength).arg(absAngle);
101 QPen pen = QPen(QColor(0x00, 0xFF, 0x00), 1.0, Qt::SolidLine);
102 painter->SetPen(pen);
103 painter->SetBrush(QBrush(QColor(0x40, 0xFF, 0x40, 0x9F)));
104 QRectF textRect(10.0, 10.0, 270.0, 70.0); // x, y, w, h (in Qt coords)
105 painter->DrawRoundedRect(textRect, 7.0, 7.0);
107 textRect.setLeft(textRect.left() + 14);
108 painter->SetFont(*Object::font);
109 pen = QPen(QColor(0x00, 0x5F, 0xDF));
110 painter->SetPen(pen);
111 painter->DrawText(textRect, Qt::AlignVCenter, text);
115 /*virtual*/ Vector Line::Center(void)
117 // Technically, this is the midpoint but who are we to quibble? :-)
118 Vector v((position.x - endpoint.x) / 2.0, (position.y - endpoint.y) / 2.0);
122 /*virtual*/ bool Line::Collided(Vector point)
124 // We can assume this, since this is a mouse down event here.
125 objectWasDragged = false;
128 // return HitStateChanged();
130 // this is shite. this should be checked for in the Container, not here!
131 // If we're part of a non-top-level container, send this signal to it
132 if (parent->type == OTContainer && !((Container *)parent)->isTopLevelContainer
133 && (hitLine || hitPoint1 || hitPoint2))
135 parent->state = OSSelected;
140 There's a small problem here with the implementation: You can have a dimension tied
141 to only one point while at the same time you can have a dimension sitting on this line.
142 Since there's only *one* dimPoint for each point, this can be problematic...
144 We solve this by allowing only *one* Dimension object to be attached to the Line,
145 Arc, etc. and by giving the Dimension object a pointer to our endpoints.
147 Problem still arises when we delete this object; The attached Dimension object will
148 then have bad pointers! What it *should* do is delete the object if and only if this
149 line is not attached to any other object. If it is, then one of those attachment
150 points should be sent to the dimension object (done for position & endpoint).
152 NOTE: The STL vector<T> *does not* take ownership of pointers, therefore is suitable
155 Also: It would be nice to have a preview of the dimension being drawn, with a modifier
156 key to make it draw/show on the other side...
158 TODO: Make Dimension preview with modifier keys for showing on other side
160 // Is the dimension tool active? Let's use it:
163 // User clicked on the line itself (endpoint checks should preceed this one):
164 // (Priorities are taken care of in HitTest()...)
168 if (attachedDimension == NULL)
170 // How to get this object into the top level container???
172 The real question is do we care. I think so, because if this isn't in the top
173 level container, it won't get drawn...
174 But we can fix that by making this object call any attached object's (like
175 a dimension only) Draw() function... :-/
177 attachedDimension = new Dimension(&position, &endpoint, DTLinear, this);
180 parent->Add(attachedDimension);
184 // If there's one already there, tell it to flip sides...
185 attachedDimension->FlipSides();
188 // New approach here: We look for connected objects.
189 Object * attachedDimension = FindAttachedDimension();
191 if (attachedDimension)
193 // If there's an attached Dimension, tell it to switch sides...
194 ((Dimension *)attachedDimension)->FlipSides();
198 // Otherwise, we make a new one and attach it here.
199 attachedDimension = new Dimension(Connection(this, 0), Connection(this, 1.0), DTLinear, this);
200 connected.push_back(Connection(attachedDimension, 0));
201 connected.push_back(Connection(attachedDimension, 1.0));
204 parent->Add(attachedDimension);
213 if (state == OSInactive)
215 //printf("Line: pp = %lf, length = %lf, distance = %lf\n", parameterizedPoint, lineSegment.Magnitude(), distance);
216 //printf(" v1.Magnitude = %lf, v2.Magnitude = %lf\n", v1.Magnitude(), v2.Magnitude());
217 //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);
219 //How to translate this into pixels from Document space???
220 //Maybe we need to pass a scaling factor in here from the caller? That would make sense, as
221 //the caller knows about the zoom factor and all that good kinda crap
222 //I think what's needed is an Object class variable/method that can be changed by the TLC and
223 //called in derived classes to properly scale the location to the current zoom level. That *should* work.
225 // ALSO: Need to code a global (read: Object class) variable that tells use whether a modifier
226 // key was pressed in addition to the mouse click, so we can do stuff like, say, hold
227 // down CTRL and be able to do multiple selecting of objects (in that case, we would
228 // keep the Object state from changing).
233 oldPoint = position; //maybe "position"?
234 draggingHandle1 = true;
241 oldPoint = endpoint; //maybe "position"?
242 draggingHandle2 = true;
254 else if (state == OSSelected)
256 // Here we test for collision with handles as well! (SOON!) [I think it works...NOPE]
259 if (v1.Magnitude() < 2.0) // Handle #1
260 else if (v2.Magnitude() < 2.0) // Handle #2
265 // state = OSInactive;
269 // Toggle selected state if CTRL held
270 if (qApp->keyboardModifiers() == Qt::ControlModifier)
277 // If CTRL is held, then we bypass the "turn off" code. Still didn't hit
278 // *this* object though. :-)
279 if (qApp->keyboardModifiers() == Qt::ControlModifier)
282 // If we got here, we clicked on nothing, so set the object to inactive.
283 // (Once we can read key modifiers, we can override this to allow multiple selection.)
289 /*virtual*/ void Line::PointerMoved(Vector point)
291 if (selectionInProgress)
293 // Check for whether or not the rect contains this line
295 if (selection.normalized().contains(Extents()))
297 // if (selection.normalized().contains(position.x, position.y)
298 // && selection.normalized().contains(endpoint.x, endpoint.y))
299 if (selection.contains(position.x, position.y)
300 && selection.contains(endpoint.x, endpoint.y))
309 // Hit test tells us what we hit (if anything) through boolean variables. (It
310 // also tells us whether or not the state changed. --not any more)
313 needUpdate = HitStateChanged();
315 objectWasDragged = (draggingLine | draggingHandle1 | draggingHandle2);
317 if (objectWasDragged)
319 Vector delta = point - oldPoint;
321 if (draggingHandle1 || draggingLine)
324 if (draggingHandle2 || draggingLine)
330 //doesn't work QMainWindow::statusBar()->setText("You are manipulating a line");
334 We can't count on any coupling between the dimension object and us, so how do we do this???
335 Also, there may be more than one Dimension object connected to a single endpoint!
338 - Keep track of the state of the connected dimension
339 - Pass the Dimension the point that's being changed and the delta
342 - Pass the point in a notification function (how?)
343 - Pass the point as a reference to the class instance object (&endpoint). This
344 way, the line doesn't have to care about keeping track of Dimensions
345 connected to it. But still have to care about other connected entities
346 (other Lines, Circles, Arcs, Splines, Texts, etc). I think I'd be OK with
347 this. Since the Dimension has a pointer to our object, all we have to do is
348 update our coordinates and the Dimension object will adjust itself on the
349 next repaint. Problem solved, and we don't have to know anything about how
350 many Dimensions are connected to us, or where! \o/
351 The question then becomes, how do we do this kind of coupling???
353 We need to know about connected entities so that we can have them either move
354 in expected ways or constrain the movement of this Line object. This is how we
355 will be a cut above all other CAD software currently out there: the GUI will
356 try to do the right thing, most of the time. :-)
360 // should only do this if "Fixed Length" is set... !!! FIX !!! [DONE]
361 Vector point1 = (draggingHandle1 ? endpoint : position);
362 Vector point2 = (draggingHandle1 ? position : endpoint);
364 if (Object::fixedAngle)
366 // Here we calculate the component of the current vector along the fixed angle.
367 // A_compB = (A . Bu) * Bu
368 double magnitudeAlongB = Vector::Dot(Vector(point2 - point1), angle);
370 Actually, this isn't quite right. What we want to do is look for the intersection along either
371 the horizontal line or vertical line that intersects from the current mouse position.
375 position = endpoint + (angle * magnitudeAlongB);
378 endpoint = position + (angle * magnitudeAlongB);
383 //If we tell the dimension to flip sides, this is no longer a valid
384 //assumption. !!! FIX !!!
385 //Ideally, we should just send the point that's changing to the Dimension object
386 //and have it figure out which point needs to move... Or is it???
387 // Ideally, we shouldn't have to fuck around with this shit. We need to fix the rendering code
388 // so that we don't have to wait until the dragging is done to correct the position of the
389 // point in question, but we'd need another variable tho.
392 dimPoint1->SetPoint1(draggingHandle1 ? v2 : position);
395 dimPoint2->SetPoint2(draggingHandle2 ? v2 : endpoint);
401 /*virtual*/ void Line::PointerReleased(void)
403 if (draggingHandle1 || draggingHandle2)
405 // Set the length (in case the global state was set to fixed (or not))
406 if (Object::fixedLength)
408 if (draggingHandle1) // startpoint
410 Vector v = Vector(position - endpoint).Unit() * length;
411 position = endpoint + v;
415 Vector v = Vector(endpoint - position).Unit() * length;
416 endpoint = position + v;
421 // Otherwise, we calculate the new length, just in case on the next
422 // move it turns out to have a fixed length. :-)
423 length = Vector(endpoint - position).Magnitude();
426 if (!Object::fixedAngle)
428 // Calculate the new angle, just in case on the next move it turns
429 // out to be fixed. :-)
430 angle = Vector(endpoint - position).Unit();
434 draggingLine = false;
435 draggingHandle1 = false;
436 draggingHandle2 = false;
438 if (objectWasDragged)
443 /*virtual*/ bool Line::HitTest(Point point)
447 hitPoint1 = hitPoint2 = hitLine = false;
448 Vector lineSegment = endpoint - position;
449 Vector v1 = point - position;
450 Vector v2 = point - endpoint;
451 double t = Vector::Parameter(position, endpoint, point);
454 // Geometric interpretation:
455 // The parameter "t" on the vector lineSegment is where the normal of
456 // lineSegment coincides with point. If t < 0, the normal lies beyond the
457 // 1st endpoint. If t > 1, then the normal lies beyond the 2nd endpoint. We
458 // only calculate the length of the normal between the point and the
459 // lineSegment when the parameter is between 0 and 1.
461 // Geometric interpretation of "distance = ?Det?(ls, v1) / |ls|":
462 // If the segment endpoints are s and e, and the point is p, then the test
463 // for the perpendicular intercepting the segment is equivalent to insisting
464 // that the two dot products {s-e}.{s-p} and {e-s}.{e-p} are both non-negative.
465 // Perpendicular distance from the point to the segment is computed by first
466 // computing the area of the triangle the three points form, then dividing by
467 // the length of the segment. Distances are done just by the Pythagorean
468 // theorem. Twice the area of the triangle formed by three points is the
469 // determinant of the following matrix:
471 // sx sy 1 0 0 1 0 0 0
472 // ex ey 1 ==> ex ey 1 ==> ex ey 0
473 // px py 1 px py 1 px py 0
475 // By translating the start point to the origin, and subtracting row 1 from
476 // all other rows, we end up with the matrix on the right which greatly
477 // simplifies the calculation of the determinant.
480 distance = v1.Magnitude();
482 distance = v2.Magnitude();
484 // distance = ?Det?(ls, v1) / |ls|
485 distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y)
486 / lineSegment.Magnitude());
488 if ((v1.Magnitude() * Painter::zoom) < 8.0)
490 else if ((v2.Magnitude() * Painter::zoom) < 8.0)
492 else if ((distance * Painter::zoom) < 5.0)
495 return (hitPoint1 || hitPoint2 || hitLine ? true : false);
496 // return HitStateChanged();
500 // Check to see if the point passed in coincides with any we have. If so, return a
501 // pointer to it; otherwise, return NULL.
502 /*virtual*/ Vector * Line::GetPointAt(Vector v)
506 else if (v == endpoint)
513 /*virtual*/ void Line::Enumerate(FILE * file)
515 fprintf(file, "LINE (%lf,%lf) (%lf,%lf)\n", position.x, position.y, endpoint.x, endpoint.y);
519 /*virtual*/ Object * Line::Copy(void)
521 #warning "!!! This doesn't take care of attached Dimensions !!!"
523 This is a real problem. While having a pointer in the Dimension to this line's points
524 is fast & easy, it creates a huge problem when trying to replicate an object like this.
526 Maybe a way to fix that then, is to have reference numbers instead of pointers. That
527 way, if you copy them, ... you might still have problems. Because you can't be sure if
528 a copy will be persistant or not, you then *definitely* do not want them to have the
529 same reference number.
531 return new Line(position, endpoint, parent);
535 /*virtual*/ Vector Line::GetPointAtParameter(double parameter)
539 else if (parameter >= 1.0)
542 // Our parameter lies between zero and one, so calculate it!
543 Vector v(endpoint, position);
544 double length = v.Magnitude();
545 // We scale the magnitude of v so that it lies between 0 and 1...
546 // By multiplying the parameter by the magnitude, we obtain the point we
547 // want. No scaling necessary as it's inherent in the approach!
548 double spotOnLength = length * parameter;
550 // To get our point, we use the initial point of the line and add in our
552 Vector result = position + (v * spotOnLength);
557 /*virtual*/ QRectF Line::Extents(void)
559 QRectF rect(QPointF(position.x, position.y), QPointF(endpoint.x, endpoint.y));
560 return rect.normalized();
564 /*virtual*/ void Line::Translate(Vector amount)
571 /*virtual*/ void Line::Rotate(Vector point, double angle)
576 /*virtual*/ void Line::Scale(Vector point, double amount)
581 void Line::SetDimensionOnLine(Dimension * dimension/*=NULL*/)
583 // If they don't pass one in, create it for the caller.
584 if (dimension == NULL)
586 //printf("Line::SetDimensionOnLine(): Creating new dimension...\n");
587 // dimension = new Dimension(position, endpoint, DTLinear, this);
588 dimension = new Dimension(Connection(this, 0), Connection(this, 1.0), DTLinear, this);
592 //printf("Line::SetDimensionOnLine(): Adding to parent...\n");
593 parent->Add(dimension);
598 dimension->Connect(this, 0);
599 dimension->Connect(this, 1.0);
602 // Make sure the Dimension is connected to us...
603 Connect(dimension, 0);
604 Connect(dimension, 1.0);
608 Object * Line::FindAttachedDimension(void)
610 // Is there anything connected to this line? If not, return NULL
611 if (connected.size() < 2)
614 // Otherwise, we have to search our objects to see if there's a likely
615 // candidate. In this case, we're looking for a pointer to the same object
616 // with a parameter of 0 and 1 respectively. This is O((n^2)/2).
617 for(uint i=0; i<connected.size(); i++)
619 for(uint j=i+1; j<connected.size(); j++)
621 //printf("Line: connected[i]=%X, connected[j]=%X, connected[i].t=%lf, connected[j].t=%lf\n", connected[i].object, connected[j].object, connected[i].t, connected[j].t);
622 if ((connected[i].object == connected[j].object)
623 && ((connected[i].t == 0 && connected[j].t == 1.0)
624 || (connected[i].t == 1.0 && connected[j].t == 0)))
625 return connected[i].object;
629 // Didn't find anything, so return NULL
634 void Line::SaveHitState(void)
636 oldHitPoint1 = hitPoint1;
637 oldHitPoint2 = hitPoint2;
638 oldHitLine = hitLine;
642 bool Line::HitStateChanged(void)
644 if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine))
652 Intersection of two lines:
654 Find where the lines with equations r = i + j + t (3i - j) and r = -i + s (j) intersect.
656 When they intersect, we can set the equations equal to one another:
658 i + j + t (3i - j) = -i + s (j)
660 Equating coefficients:
661 1 + 3t = -1 and 1 - t = s
662 So t = -2/3 and s = 5/3
664 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 .
667 so, let's say we have two lines, l1 and l2. Points are v0(p0x, p0y), v1(p1x, p1y) for l1
668 and v2(p2x, p2y), v3(p3x, p3y) for l2.
670 d1 = v1 - v0, d2 = v3 - v2
672 Our parametric equations for the line then are:
677 Set r1 = r2, thus we have:
679 v0 + t(d1) = v2 + s(d2)
681 Taking coefficients, we have:
683 p0x + t(d1x) = p2x + s(d2x)
684 p0y + t(d1y) = p2y + s(d2y)
688 t(d1x) - s(d2x) = p2x - p0x
689 t(d1y) - s(d2y) = p2y - p0y
691 Determinant D is ad - bc where the matrix looks like:
696 so D = (d1x)(d2y) - (d2x)(d1y)
697 if D = 0, the lines are parallel.
698 Dx = (p2x - p0x)(d2y) - (d2x)(p2y - p0y)
699 Dy = (d1x)(p2y - p0y) - (p2x - p0x)(d1y)
702 We only need to calculate t, as we can then multiply it by d1 to get the intersection point.
704 ---------------------------------------------------------------------------------------------------
706 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:
712 Perp product is equal with dot product of normal of first vector and the second vector, so we need normals:
719 dp1 = n3 . v2 = -by3 * bx2 + bx3 * by2;
720 dp2 = n1 . v2 = -by1 * bx2 + bx1 * by2;
723 crossing vector = v1 * ratio;
727 -----------------------------------
729 So... to code this, let's say we have two Lines: l1 & l2.
731 Vector v1 = l1.endpoint - l1.position;
732 Vector v2 = l2.endpoint - l2.position;
735 Vector normal1(-v1.y, v1.x);
736 Vector normal3(-v3.y, v3.x);
738 double dotProduct1 = v2.Dot(normal1);
739 double dotProduct2 = v2.Dot(normal3);
741 if (dotProduct2 == 0)
742 return ParallelLines;
745 // I think we'd still have to add the intersection to the position point to get the intersection...
746 Point intersection = v1 * (dotProduct1 / dotProduct2);