Shamusworld >> Repos - architektonas/blob - src/base/constructionline.cpp

   1 // constructionline.cpp
   2 //
   3 // Part of the Architektonas Project
   4 // Originally part of QCad Community Edition by Andrew Mustun
   5 // Extensively rewritten and refactored by James L. Hammons
   6 // Portions copyright (C) 2001-2003 RibbonSoft
   7 // Copyright (C) 2010 Underground Software
   8 // See the README and GPLv2 files for licensing and warranty information
   9 //
  10 // JLH = James L. Hammons <jlhamm@acm.org>
  11 //
  12 // Who  When        What
  13 // ---  ----------  -----------------------------------------------------------
  14 // JLH  05/28/2010  Added this text. :-)
  15 // JLH  06/02/2010  Moved implementation from header to here WHERE IT BELONGS.
  16 //
  17
  18 #include "constructionline.h"
  19
  20 #include "debug.h"
  21
  22 /**
  23  * Constructor.
  24  */
  25 ConstructionLine::ConstructionLine(EntityContainer * parent,
  26         const ConstructionLineData & d): AtomicEntity(parent), data(d)
  27 {
  28         calculateBorders();
  29 }
  30
  31 /**
  32  * Destructor.
  33  */
  34 ConstructionLine::~ConstructionLine()
  35 {
  36 }
  37
  38 Entity * ConstructionLine::clone()
  39 {
  40         ConstructionLine * c = new ConstructionLine(*this);
  41         c->initId();
  42         return c;
  43 }
  44
  45 /**     @return RS2::EntityConstructionLine */
  46 /*virtual*/ RS2::EntityType ConstructionLine::rtti() const
  47 {
  48         return RS2::EntityConstructionLine;
  49 }
  50
  51 /**
  52  * @todo
  53  * @return Start point of the entity.
  54  */
  55 /*virtual*/ Vector ConstructionLine::getStartpoint() const
  56 {
  57         return Vector(false);
  58 }
  59
  60 /**
  61  * @todo
  62  * @return End point of the entity.
  63  */
  64 /*virtual*/ Vector ConstructionLine::getEndpoint() const
  65 {
  66         return Vector(false);
  67 }
  68
  69 /** @return Copy of data that defines the line. */
  70 ConstructionLineData ConstructionLine::getData() const
  71 {
  72         return data;
  73 }
  74
  75 /** @return First definition point. */
  76 Vector ConstructionLine::getPoint1() const
  77 {
  78         return data.point1;
  79 }
  80 /** @return Second definition point. */
  81 Vector ConstructionLine::getPoint2() const
  82 {
  83         return data.point2;
  84 }
  85
  86 void ConstructionLine::calculateBorders()
  87 {
  88         minV = Vector::minimum(data.point1, data.point2);
  89         maxV = Vector::maximum(data.point1, data.point2);
  90 }
  91
  92 Vector ConstructionLine::getNearestEndpoint(const Vector & coord, double * dist)
  93 {
  94         double dist1, dist2;
  95         Vector * nearerPoint;
  96
  97         dist1 = data.point1.distanceTo(coord);
  98         dist2 = data.point2.distanceTo(coord);
  99
 100         if (dist2 < dist1)
 101         {
 102                 if (dist != NULL)
 103                         *dist = dist2;
 104
 105                 nearerPoint = &data.point2;
 106         }
 107         else
 108         {
 109                 if (dist != NULL)
 110                         *dist = dist1;
 111
 112                 nearerPoint = &data.point1;
 113         }
 114
 115         return *nearerPoint;
 116 }
 117
 118 Vector ConstructionLine::getNearestPointOnEntity(const Vector & coord,
 119         bool /*onEntity*/, double * /*dist*/, Entity ** entity)
 120 {
 121         if (entity != NULL)
 122                 *entity = this;
 123
 124         Vector ae = data.point2-data.point1;
 125         Vector ea = data.point1-data.point2;
 126         Vector ap = coord-data.point1;
 127         Vector ep = coord-data.point2;
 128
 129         if (ae.magnitude() < 1.0e-6 || ea.magnitude() < 1.0e-6)
 130                 return Vector(false);
 131
 132         // Orthogonal projection from both sides:
 133         Vector ba = ae * Vector::dotP(ae, ap) / (ae.magnitude() * ae.magnitude());
 134         Vector be = ea * Vector::dotP(ea, ep) / (ea.magnitude() * ea.magnitude());
 135
 136         return data.point1 + ba;
 137 }
 138
 139 Vector ConstructionLine::getNearestCenter(const Vector & /*coord*/, double * dist)
 140 {
 141         if (dist != NULL)
 142                 *dist = RS_MAXDOUBLE;
 143
 144         return Vector(false);
 145 }
 146
 147 Vector ConstructionLine::getNearestMiddle(const Vector & /*coord*/, double * dist)
 148 {
 149         if (dist != NULL)
 150                 *dist = RS_MAXDOUBLE;
 151
 152         return Vector(false);
 153 }
 154
 155 Vector ConstructionLine::getNearestDist(double /*distance*/, const Vector & /*coord*/,
 156         double * dist)
 157 {
 158         if (dist != NULL)
 159                 *dist = RS_MAXDOUBLE;
 160
 161         return Vector(false);
 162 }
 163
 164 double ConstructionLine::getDistanceToPoint(const Vector& coord,
 165         Entity** entity,
 166         RS2::ResolveLevel /*level*/, double /*solidDist*/)
 167 {
 168         DEBUG->print("ConstructionLine::getDistanceToPoint");
 169
 170         if (entity != NULL)
 171                 *entity = this;
 172
 173         double dist = RS_MAXDOUBLE;
 174         Vector ae = data.point2-data.point1;
 175         Vector ea = data.point1-data.point2;
 176         Vector ap = coord-data.point1;
 177         Vector ep = coord-data.point2;
 178
 179         if (ae.magnitude() < 1.0e-6 || ea.magnitude() < 1.0e-6)
 180                 return dist;
 181
 182         // Orthogonal projection from both sides:
 183         Vector ba = ae * Vector::dotP(ae, ap) / Math::pow(ae.magnitude(), 2);
 184         Vector be = ea * Vector::dotP(ea, ep) / Math::pow(ea.magnitude(), 2);
 185
 186         DEBUG->print("ba: %f", ba.magnitude());
 187         DEBUG->print("ae: %f", ae.magnitude());
 188
 189         Vector cp = Vector::crossP(ap, ae);
 190         dist = cp.magnitude() / ae.magnitude();
 191
 192         return dist;
 193 }
 194
 195 void ConstructionLine::move(Vector offset)
 196 {
 197         data.point1.move(offset);
 198         data.point2.move(offset);
 199         //calculateBorders();
 200 }
 201
 202 void ConstructionLine::rotate(Vector center, double angle)
 203 {
 204         data.point1.rotate(center, angle);
 205         data.point2.rotate(center, angle);
 206         //calculateBorders();
 207 }
 208
 209 void ConstructionLine::scale(Vector center, Vector factor)
 210 {
 211         data.point1.scale(center, factor);
 212         data.point2.scale(center, factor);
 213         //calculateBorders();
 214 }
 215
 216 void ConstructionLine::mirror(Vector axisPoint1, Vector axisPoint2)
 217 {
 218         data.point1.mirror(axisPoint1, axisPoint2);
 219         data.point2.mirror(axisPoint1, axisPoint2);
 220 }
 221
 222 /*virtual*/ void ConstructionLine::draw(PaintInterface *, GraphicView *, double)
 223 {
 224 }
 225
 226 /**
 227  * Dumps the point's data to stdout.
 228  */
 229 std::ostream & operator<<(std::ostream & os, const ConstructionLine & l)
 230 {
 231         os << " ConstructionLine: " << l.getData() << "\n";
 232         return os;
 233 }