Shamusworld >> Repos - architektonas/blob - src/base/rs_circle.h

   1 #ifndef RS_CIRCLE_H
   2 #define RS_CIRCLE_H
   3
   4 #include "rs_atomicentity.h"
   5
   6 /**
   7  * Holds the data that defines a circle.
   8  */
   9 class RS_CircleData
  10 {
  11 public:
  12     RS_CircleData() {}
  13
  14     RS_CircleData(const Vector& center,
  15                   double radius) {
  16
  17         this->center = center;
  18         this->radius = radius;
  19     }
  20
  21     void reset() {
  22         center = Vector(false);
  23         radius = 0.0;
  24     }
  25
  26     bool isValid() {
  27         return (center.valid && radius>RS_TOLERANCE);
  28     }
  29
  30     friend class RS_Circle;
  31
  32     friend std::ostream& operator << (std::ostream& os,
  33                                       const RS_CircleData& ad) {
  34         os << "(" << ad.center <<
  35         "/" << ad.radius <<
  36         ")";
  37         return os;
  38     }
  39
  40 public:
  41     Vector center;
  42     double radius;
  43 };
  44
  45
  46
  47 /**
  48  * Class for a circle entity.
  49  *
  50  * @author Andrew Mustun
  51  */
  52 class RS_Circle : public RS_AtomicEntity
  53 {
  54 public:
  55     RS_Circle (RS_EntityContainer* parent,
  56                const RS_CircleData& d);
  57     virtual ~RS_Circle() {}
  58
  59     virtual RS_Entity* clone() {
  60         RS_Circle* c = new RS_Circle(*this);
  61         c->initId();
  62         return c;
  63     }
  64
  65     /** @return RS2::EntityCircle */
  66     virtual RS2::EntityType rtti() const {
  67         return RS2::EntityCircle;
  68     }
  69     /** @return true */
  70     virtual bool isEdge() const {
  71         return true;
  72     }
  73
  74     /** @return Copy of data that defines the circle. **/
  75     RS_CircleData getData() {
  76         return data;
  77     }
  78
  79         virtual VectorSolutions getRefPoints();
  80
  81         virtual Vector getStartpoint() const {
  82                 return data.center + Vector(data.radius, 0.0);
  83         }
  84         virtual Vector getEndpoint() const {
  85                 return data.center + Vector(data.radius, 0.0);
  86         }
  87         /**
  88          * @return Direction 1. The angle at which the arc starts at
  89          * the startpoint.
  90          */
  91         double getDirection1() const {
  92                 return M_PI/2.0;
  93         }
  94         /**
  95          * @return Direction 2. The angle at which the arc starts at
  96          * the endpoint.
  97          */
  98         double getDirection2() const {
  99                 return M_PI/2.0*3.0;
 100         }
 101
 102     /** @return The center point (x) of this arc */
 103     Vector getCenter() {
 104         return data.center;
 105     }
 106     /** Sets new center. */
 107         void setCenter(const Vector& c) {
 108                 data.center = c;
 109         }
 110     /** @return The radius of this arc */
 111     double getRadius() {
 112         return data.radius;
 113     }
 114     /** Sets new radius. */
 115     void setRadius(double r) {
 116         data.radius = r;
 117     }
 118     double getAngleLength() const;
 119     virtual double getLength();
 120
 121     bool createFromCR(const Vector& c, double r);
 122     bool createFrom2P(const Vector& p1, const Vector& p2);
 123     bool createFrom3P(const Vector& p1, const Vector& p2,
 124                       const Vector& p3);
 125
 126     virtual Vector getNearestEndpoint(const Vector& coord,
 127                                          double* dist = NULL);
 128     virtual Vector getNearestPointOnEntity(const Vector& coord,
 129             bool onEntity = true, double* dist = NULL, RS_Entity** entity=NULL);
 130     virtual Vector getNearestCenter(const Vector& coord,
 131                                        double* dist = NULL);
 132     virtual Vector getNearestMiddle(const Vector& coord,
 133                                        double* dist = NULL);
 134     virtual Vector getNearestDist(double distance,
 135                                      const Vector& coord,
 136                                      double* dist = NULL);
 137     virtual Vector getNearestDist(double distance,
 138                                      bool startp);
 139     virtual double getDistanceToPoint(const Vector& coord,
 140                                       RS_Entity** entity=NULL,
 141                                       RS2::ResolveLevel level=RS2::ResolveNone,
 142                                                                           double solidDist = RS_MAXDOUBLE);
 143
 144     virtual void move(Vector offset);
 145     virtual void rotate(Vector center, double angle);
 146     virtual void scale(Vector center, Vector factor);
 147     virtual void mirror(Vector axisPoint1, Vector axisPoint2);
 148         virtual void moveRef(const Vector& ref, const Vector& offset);
 149
 150 //    virtual void draw(RS_Painter* painter, RS_GraphicView* view, double patternOffset=0.0);
 151     virtual void draw(PaintInterface * painter, RS_GraphicView * view, double patternOffset = 0.0);
 152
 153     friend std::ostream & operator<<(std::ostream & os, const RS_Circle & a);
 154
 155     virtual void calculateBorders();
 156
 157 protected:
 158     RS_CircleData data;
 159 };
 160
 161 #endif