A ellipse that can be put in a drawing. More...

#include <ellipse.h>

Inheritance diagram for lc::entity::Ellipse:

Collaboration diagram for lc::entity::Ellipse:

Public Member Functions
	Ellipse (const geo::Coordinate &center, const geo::Coordinate &majorP, double minorRadius, double startAngle, double endAngle, bool reversed, const Layer_CSPtr layer, const MetaInfo_CSPtr metaInfo=nullptr, const Block_CSPtr block=nullptr)
	Create ellipse. More...

	Ellipse (const Ellipse_CSPtr other, bool sameID=false)

virtual CADEntity_CSPtr	move (const geo::Coordinate &offset) const override
	move, moves by an offset More...

virtual CADEntity_CSPtr	copy (const geo::Coordinate &offset) const override
	copy, copies by an offset More...

virtual CADEntity_CSPtr	rotate (const geo::Coordinate &rotation_center, const double rotation_angle) const override
	rotate, rotate operation More...

virtual CADEntity_CSPtr	scale (const geo::Coordinate &scale_center, const geo::Coordinate &scale_factor) const override
	scale, scales the entity More...

virtual CADEntity_CSPtr	mirror (const geo::Coordinate &axis1, const geo::Coordinate &axis2) const override

virtual const geo::Area	boundingBox () const override
	boundingBox of the entity More...

virtual CADEntity_CSPtr	modify (Layer_CSPtr layer, const MetaInfo_CSPtr metaInfo, Block_CSPtr block) const override
	modify Return a new entity with the same ID bit with possible modified metainfo and/pr layer information #return new entity with same ID More...

std::vector< lc::geo::Coordinate >	findBoxPoints () const

virtual std::vector < EntityCoordinate >	snapPoints (const geo::Coordinate &coord, const SimpleSnapConstrain &constrain, double minDistanceToSnap, int maxNumberOfSnapPoints) const override
	see interface Snapable More...

virtual geo::Coordinate	nearestPointOnPath (const geo::Coordinate &coord) const override
	Find the nearest point on the path for this entity for the coordinate coord The path of a entity that it can possibly take. More...

virtual void	accept (GeoEntityVisitor &v) const override

virtual void	dispatch (EntityDispatch &ed) const override

Public Member Functions inherited from lc::entity::CADEntity
	CADEntity ()

	CADEntity (Layer_CSPtr layer, const MetaInfo_CSPtr metaInfo=nullptr, const Block_CSPtr block=nullptr)
	CADEntity Constructor. More...

	CADEntity (CADEntity_CSPtr cadEntity, bool sameID)

	CADEntity (CADEntity_CSPtr cadEntity)

virtual	~CADEntity ()=default

Layer_CSPtr	layer () const
	layer return the layer this entity is placed on More...

template<typename T >
const std::shared_ptr< const T >	metaInfo (std::string metaName) const

MetaInfo_CSPtr	metaInfo () const

Block_CSPtr	block () const
	Return the current entity block. More...

Public Member Functions inherited from lc::ID
	ID ()
	Default constructor, provides a new unique ID to each entity. More...

	ID (ID_DATATYPE)

virtual	~ID ()=default

ID_DATATYPE	id () const
	returns the ID of the entity More...

bool	operator== (const ID &id) const

void	setID (ID_DATATYPE id)

Public Member Functions inherited from lc::Visitable
virtual	~Visitable ()=default

Public Member Functions inherited from lc::geo::Ellipse
	Ellipse (const Coordinate &center, const Coordinate &majorP, double minorRadius, double startAngle, double endAngle, bool reversed=false)

const Coordinate	center () const
	center, Returns Center point of Ellipse More...

const Coordinate	majorP () const
	majorP, Returns major point of the ellipse, relative to center More...

double	minorRadius () const
	minorRadius, Returns the minor radius of ellipse More...

double	startAngle () const
	startAngle, Returns Start elliptic!! angle of ellipse More...

double	endAngle () const
	endAngle, Return the end elliptic!! angle of ellipse More...

Coordinate	getPoint (const double &angle) const
	getPoint, return a point on ellipse with given elliptic angle More...

Coordinate	startPoint () const
	startPoint, start point of ellipse More...

Coordinate	endPoint () const
	endPoint, end point of ellipse More...

std::vector< Coordinate >	findPotentialNearestPoints (const Coordinate &coord) const
	findPotentialNearestPoints More...

Coordinate	nearestPointOnPath (const Coordinate &coord) const
	nearestPointOnPath, (ignore if it arc) More...

Coordinate	nearestPointOnEntity (const Coordinate &coord) const
	nearestPointOnEntity, ( not ignore arc) More...

bool	isArc () const
	isArc More...

bool	isReversed () const

double	ratio () const
	ratio of major radius to minor radius More...

double	majorRadius () const
	Major Radius. More...

double	getAngle () const
	getAngle of MajorP More...

double	getEllipseAngle (const Coordinate &coord) const
	getEllipseAngle More...

bool	isAngleBetween (double angle) const

Ellipse	georotate (const Coordinate &center, const double rotation_angle) const
	rotate an ellipse at a center by an angle More...

Ellipse	geoscale (const Coordinate &center, const Coordinate &factor) const
	scale an ellipse at some center by some factor More...

const maths::Equation	equation () const
	Returns the quadratic equation. More...

Public Member Functions inherited from lc::geo::Base
virtual	~Base ()=default

Additional Inherited Members
Static Public Member Functions inherited from lc::Snapable
static void	remove_ifDistanceGreaterThen (std::vector< EntityCoordinate > &points, const geo::Coordinate &reference, const double distance)

static void	snapPointsCleanup (std::vector< EntityCoordinate > &points, const geo::Coordinate &reference, const unsigned int maxNumberOfSnapPoints, const double minDistanceToSnap)

Static Public Attributes inherited from lc::ID
static std::atomic< ID_DATATYPE >	__idCounter

Protected Member Functions inherited from lc::entity::CADEntity
	CADEntity (const lc::builder::CADEntityBuilder &builder)

Detailed Description

A ellipse that can be put in a drawing.

A Ellipse is a graphics elipse item that can be put on a drawing using a CreateEntity operation.

See also: CreateEntities::append

Author: R. van Twisk

Date: 2012-04-16

Definition at line 27 of file ellipse.h.

Constructor & Destructor Documentation

Ellipse::Ellipse	(	const geo::Coordinate &	center,
		const geo::Coordinate &	majorP,
		double	minorRadius,
		double	startAngle,
		double	endAngle,
		bool	reversed,
		const Layer_CSPtr	layer,
		const MetaInfo_CSPtr	metaInfo = `nullptr`,
		const Block_CSPtr	block = `nullptr`
	)

Create ellipse.

Parameters

center
majorP	relative to center
minorRadius
startAngle
endAngle
reversed
layer
metaInfo
block

Definition at line 9 of file ellipse.cpp.

                                           :
         CADEntity(layer, metaInfo, block),
         geo::Ellipse(center, majorP, minorRadius, startAngle, endAngle, reversed) {
 }

Ellipse::Ellipse	(	const Ellipse_CSPtr	other,
		bool	sameID = `false`
	)

Definition at line 22 of file ellipse.cpp.

                                                        :
         CADEntity(other, sameID),
         geo::Ellipse(other->center(), other->majorP(), other->minorRadius(), other->startAngle(), other->endAngle(),
                      other->isReversed()) {
 }

Member Function Documentation

virtual void lc::entity::Ellipse::accept ( GeoEntityVisitor & v ) const

inlineoverridevirtual

Reimplemented from lc::entity::CADEntity.

Definition at line 117 of file ellipse.h.

117 { v.visit(*this); }

const geo::Area Ellipse::boundingBox ( ) const

overridevirtual

boundingBox of the entity

Returns: geo::Area area

Implements lc::entity::CADEntity.

Definition at line 112 of file ellipse.cpp.

                                          {
     const std::vector<geo::Coordinate> points = findBoxPoints();
     double minX, minY, maxX, maxY;
 
     minX = points[0].x();
     maxX = points[0].x();
     minY = points[0].y();
     maxY = points[0].y();
 
     const auto checkPoint = [&](const geo::Coordinate& point) {
         if (point.x() < minX)
             minX = point.x();
         if (point.x() > maxX)
             maxX = point.x();
         if (point.y() < minY)
             minY = point.y();
         if (point.y() > maxY)
             maxY = point.y();
     };
 
     for (const auto& point : points)
         checkPoint(point);
 
     return geo::Area(geo::Coordinate(minX, minY),
                      geo::Coordinate(maxX, maxY));
 }

CADEntity_CSPtr Ellipse::copy ( const geo::Coordinate & offset ) const

overridevirtual

copy, copies by an offset

Parameters

geo::Coordinate offset

Returns: CADEntity_CSPtr copied entity

Implements lc::entity::CADEntity.

Definition at line 42 of file ellipse.cpp.

                                                                {
     auto newEllipse = std::make_shared<Ellipse>(this->center() + offset,
                                                 this->majorP(),
                                                 this->minorRadius(),
                                                 this->startAngle(), this->endAngle(),
                                                 isReversed(),
                                                 layer(),
                                                 metaInfo(),
                                                 block());
     return newEllipse;
 }

virtual void lc::entity::Ellipse::dispatch ( EntityDispatch & ed ) const

inlineoverridevirtual

Implements lc::entity::CADEntity.

Definition at line 119 of file ellipse.h.

                                                                      {
                 ed.visit(shared_from_this());
             }

std::vector< lc::geo::Coordinate > Ellipse::findBoxPoints ( ) const

Returns: left, right, top, bottom, startPoint(for arc), endPoint(for arc)

Definition at line 158 of file ellipse.cpp.

                                                         {
     std::vector<lc::geo::Coordinate> resPoints;
     const double a = majorP().magnitude();
     const double b = this->minorRadius();
     const double angle = this->getAngle();
     geo::Coordinate c1, c2, c3, c4;
     bool simple = false; // (major axis = ox axis) or (major axis =  oy axis)
 
     if (sin(angle) == 0) {
         c1 = geo::Coordinate(this->center().x() + a, this->center().y());
         c2 = geo::Coordinate(this->center().x(), this->center().y() + b);
         c3 = geo::Coordinate(this->center().x() - a, this->center().y());
         c4 = geo::Coordinate(this->center().x(), this->center().y() - b);
 
         simple = true;
     }
 
     if (cos(angle) == 0) {
         c1 = geo::Coordinate(this->center().x() + b, this->center().y());
         c2 = geo::Coordinate(this->center().x(), this->center().y() + a);
         c3 = geo::Coordinate(this->center().x() - b, this->center().y());
         c4 = geo::Coordinate(this->center().x(), this->center().y() - a);
 
         simple = true;
     }
 
     if (!simple) {
         double tanAngle = std::tan(-this->getAngle());
 
         auto getY = [&](double x) {
             return -b * b * x / (a * a * tanAngle);
         };
 
         double x = a * a * tanAngle / (sqrt(a * a * tanAngle * tanAngle + b * b));
         c1 = geo::Coordinate(x, getY(x));
         c2 = geo::Coordinate(-x, getY(-x));
 
         tanAngle = -1 / tanAngle;
         x = a * a * tanAngle / (sqrt(a * a * tanAngle * tanAngle + b * b));
         c3 = geo::Coordinate(x, getY(x));
         c4 = geo::Coordinate(-x, getY(-x));
 
         c1 = c1.rotate(angle) + this->center();
         c2 = c2.rotate(angle) + this->center();
         c3 = c3.rotate(angle) + this->center();
         c4 = c4.rotate(angle) + this->center();
     }
 
     if (this->isArc()) {
         resPoints.push_back(startPoint());
         resPoints.push_back(endPoint());
     }
 
     auto checkPoint = [&](geo::Coordinate cord) {
         if (isAngleBetween(getEllipseAngle(cord)))
             resPoints.push_back(cord);
     };
 
     checkPoint(c1);
     checkPoint(c2);
     checkPoint(c3);
     checkPoint(c4);
 
     return resPoints;
 }

CADEntity_CSPtr Ellipse::mirror	(	const geo::Coordinate &	axis1,
		const geo::Coordinate &	axis2
	)		const

overridevirtual

Implements lc::entity::CADEntity.

Definition at line 87 of file ellipse.cpp.

                                                                                             {
     auto cen = this->center().mirror(axis1, axis2);
     auto maj = (cen + this->majorP()).mirror(axis1, axis2);
     auto majP = maj - cen;
 
     geo::Coordinate startP, endP;
     if (isArc()) {
         startP = startPoint().mirror(axis1, axis2);
         endP = endPoint().mirror(axis1, axis2);
     }
 
     auto newEllipse = std::make_shared<Ellipse>(cen, majP,
                                                 minorRadius(),
                                                 getEllipseAngle(startP),
                                                 getEllipseAngle(endP),
                                                 !isReversed(),
                                                 layer(),
                                                 metaInfo(),
                                                 block()
     );
     newEllipse->setID(this->id());
 
     return newEllipse;
 }

CADEntity_CSPtr Ellipse::modify	(	Layer_CSPtr	layer,
		const MetaInfo_CSPtr	metaInfo,
		Block_CSPtr	block
	)		const

overridevirtual

modify Return a new entity with the same ID bit with possible modified metainfo and/pr layer information #return new entity with same ID

Implements lc::entity::CADEntity.

Definition at line 139 of file ellipse.cpp.

                                                                                                          {
     auto newEntity = std::make_shared<Ellipse>(
             this->center(),
             this->majorP(),
             this->minorRadius(),
             this->startAngle(),
             this->endAngle(),
             this->isReversed(),
             layer,
             metaInfo,
             block
     );
 
     newEntity->setID(this->id());
 
     return newEntity;
 }

CADEntity_CSPtr Ellipse::move ( const geo::Coordinate & offset ) const

overridevirtual

move, moves by an offset

Parameters

geo::Coordinate offset

Returns: CADEntity_CSPtr moved entity

Implements lc::entity::CADEntity.

Definition at line 29 of file ellipse.cpp.

                                                                {
     auto newellipse = std::make_shared<Ellipse>(this->center() + offset,
                                                 this->majorP(),
                                                 this->minorRadius(),
                                                 this->startAngle(), this->endAngle(),
                                                 isReversed(),
                                                 layer(),
                                                 metaInfo(),
                                                 block());
     newellipse->setID(this->id());
     return newellipse;
 }

geo::Coordinate Ellipse::nearestPointOnPath ( const geo::Coordinate & coord ) const

overridevirtual

Find the nearest point on the path for this entity for the coordinate coord The path of a entity that it can possibly take.

For example for any Arc the path is the full circle if the start/stop angle is 0 to 2*pi

Parameters

coord Coordinate to lookup the nearest coordinate from

See also: lc::entity::CADEntity

Implements lc::Snapable.

Definition at line 282 of file ellipse.cpp.

                                                                           {
     return geo::Ellipse::nearestPointOnPath(coord);
 }

CADEntity_CSPtr Ellipse::rotate	(	const geo::Coordinate &	rotation_center,
		const double	rotation_angle
	)		const

overridevirtual

rotate, rotate operation

Parameters

geo::Coordinate	rotation_center
double	rotation_angle

Returns: CADEntity_CSPtr rotated entity

Implements lc::entity::CADEntity.

Definition at line 54 of file ellipse.cpp.

                                                                                                        {
     auto rotated = this->georotate(rotation_center, rotation_angle);
     auto newEllipse = std::make_shared<Ellipse>(rotated.center(),
                                                 rotated.majorP(),
                                                 rotated.minorRadius(),
                                                 rotated.startAngle(),
                                                 rotated.endAngle(),
                                                 isReversed(),
                                                 layer(),
                                                 metaInfo(),
                                                 block()
     );
     newEllipse->setID(this->id());
     return newEllipse;
 }

CADEntity_CSPtr Ellipse::scale	(	const geo::Coordinate &	scale_center,
		const geo::Coordinate &	scale_factor
	)		const

overridevirtual

scale, scales the entity

Parameters

geo::Coordinate	scale_center
double	scale_factor

Returns

Implements lc::entity::CADEntity.

Definition at line 70 of file ellipse.cpp.

                                                                                                          {
     auto scaled = this->geoscale(scale_center, scale_factor);
     auto newEllipse = std::make_shared<Ellipse>(scaled.center(),
                                                 scaled.majorP(),
                                                 scaled.minorRadius(),
                                                 scaled.startAngle(),
                                                 scaled.endAngle(),
                                                 isReversed(),
                                                 layer(),
                                                 metaInfo(),
                                                 block()
     );
 
     newEllipse->setID(this->id());
     return newEllipse;
 }

std::vector< EntityCoordinate > Ellipse::snapPoints	(	const geo::Coordinate &	coord,
		const SimpleSnapConstrain &	constrain,
		double	minDistanceToSnap,
		int	maxNumberOfSnapPoints
	)		const

overridevirtual

see interface Snapable

Implements lc::Snapable.

Definition at line 226 of file ellipse.cpp.

                                                      {
 
     std::vector<EntityCoordinate> resPoints;
     int ind = 0;
 
     if (constrain.constrain() & SimpleSnapConstrain::LOGICAL) {
         geo::Coordinate tmp;
 
         resPoints.emplace_back(this->center(), ind++);
 
         auto points = this->findBoxPoints();
         for (auto p: points)
             resPoints.emplace_back(p, ind++);
 
         geo::Coordinate minorP(this->majorP().angle());
         minorP = minorP.rotate(M_PI_2);
         minorP = minorP * this->minorRadius();
 
         if (sin(this->getAngle()) != 0 && cos(this->getAngle()) != 0) {
             //add Ellipse vertices
             tmp = center() + majorP();
             if (this->isAngleBetween(0))
                 resPoints.emplace_back(tmp, ind++);
 
             tmp = center() - majorP();
             if (this->isAngleBetween(M_PI))
                 resPoints.emplace_back(tmp, ind++);
 
             tmp = center() + minorP;
             if (this->isAngleBetween(M_PI_2))
                 resPoints.emplace_back(tmp, ind++);
 
             tmp = center() - minorP;
             if (this->isAngleBetween(-M_PI_2))
                 resPoints.emplace_back(tmp, ind++);
         }
     }
 
     // Any where on entity path
     if (constrain.constrain() & SimpleSnapConstrain::ON_ENTITYPATH) {
         geo::Coordinate nearestPoint = this->nearestPointOnPath(coord);
         resPoints.emplace_back(nearestPoint, ind++);
     }
 
     // Any where on entity
     if (constrain.constrain() & SimpleSnapConstrain::ON_ENTITY) {
         geo::Coordinate nearestPoint = nearestPointOnEntity(coord);
         resPoints.emplace_back(nearestPoint, ind++);
     }
 
     // Cleanup array of snappoints
     Snapable::snapPointsCleanup(resPoints, coord, maxNumberOfSnapPoints, minDistanceToSnap);
     return resPoints;
 }

The documentation for this class was generated from the following files:

lckernel/cad/primitive/ellipse.h
lckernel/cad/primitive/ellipse.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation