#include <lwpolyline.h>

Inheritance diagram for lc::entity::LWPolyline:

Collaboration diagram for lc::entity::LWPolyline:

Public Member Functions
	LWPolyline (const std::vector< LWVertex2D > &vertex, double width, double elevation, double tickness, bool closed, geo::Coordinate const &extrusionDirection, const Layer_CSPtr layer, const MetaInfo_CSPtr metaInfo=nullptr, const Block_CSPtr block=nullptr)

	LWPolyline (const LWPolyline_CSPtr other, bool sameID=false)

double	width () const

double	elevation () const

double	tickness () const

geo::Coordinate const &	extrusionDirection () const

std::vector< LWVertex2D > const &	vertex () const

bool	closed () const

virtual std::vector < EntityCoordinate >	snapPoints (const geo::Coordinate &coord, const SimpleSnapConstrain &constrain, double minDistanceToSnap, int maxNumberOfSnapPoints) const override
	Find a number of snap points the line has available This function returns a ordered list, closest to coord and can return multiple snap points. 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...

std::tuple< geo::Coordinate, std::shared_ptr< const geo::Vector >, std::shared_ptr < const geo::Arc > >	nearestPointOnPath2 (const geo::Coordinate &coord) const

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< CADEntity_CSPtr > const	asEntities () const

virtual void	accept (GeoEntityVisitor &v) const override

virtual void	dispatch (EntityDispatch &ed) const override

virtual std::map< unsigned int, lc::geo::Coordinate >	dragPoints () const override
	Get all points of the entity that can be dragged. More...

virtual CADEntity_CSPtr	setDragPoints (std::map< unsigned int, lc::geo::Coordinate > dragPoints) const override
	Return modified entity. More...

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

Private Member Functions
void	generateEntities ()
	Generate entities of the polyline. More...

Private Attributes
const std::vector< LWVertex2D >	_vertex

const double	_width

const double	_elevation

const double	_tickness

const bool	_closed

const geo::Coordinate	_extrusionDirection

std::vector< CADEntity_CSPtr >	_entities

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

Lightweight polyline

Definition at line 86 of file lwpolyline.h.

Constructor & Destructor Documentation

LWPolyline::LWPolyline	(	const std::vector< LWVertex2D > &	vertex,
		double	width,
		double	elevation,
		double	tickness,
		bool	closed,
		geo::Coordinate const &	extrusionDirection,
		const Layer_CSPtr	layer,
		const MetaInfo_CSPtr	metaInfo = `nullptr`,
		const Block_CSPtr	block = `nullptr`
	)

LWPolyline Constructor

Parameters

width	of the vertex on each entity
elevation	of the polyline
tickness	of the polyline
extrusionDirection	of the polyline
vertex	entries of the polyline
layer
metaInfo

Definition at line 15 of file lwpolyline.cpp.

                                                 :
         CADEntity(layer, metaInfo, block),
         _vertex(vertex),
         _width(width),
         _elevation(elevation),
         _tickness(tickness),
         _closed(closed),
         _extrusionDirection(extrusionDirection) {
 
     generateEntities();
 
 }

LWPolyline::LWPolyline	(	const LWPolyline_CSPtr	other,
		bool	sameID = `false`
	)

Definition at line 36 of file lwpolyline.cpp.

                                                                 : CADEntity(other, sameID),
                                                                     _vertex(other->_vertex),
                                                                     _width(other->_width),
                                                                     _elevation(other->_elevation),
                                                                     _tickness(other->_tickness),
                                                                     _closed(other->_closed),
                                                                     _extrusionDirection(other->_extrusionDirection) {
     generateEntities();
 }

Member Function Documentation

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

inlineoverridevirtual

Reimplemented from lc::entity::CADEntity.

Definition at line 213 of file lwpolyline.h.

213 { v.visit(*this); }

std::vector< CADEntity_CSPtr > const LWPolyline::asEntities ( ) const

Return a vector of entities for this polyline The vector will contain entity::vector and entity::Arc items

Definition at line 299 of file lwpolyline.cpp.

                                                               {
     return _entities;
 }

const geo::Area LWPolyline::boundingBox ( ) const

overridevirtual

boundingBox of the entity

Returns: geo::Area area

Implements lc::entity::CADEntity.

Definition at line 92 of file lwpolyline.cpp.

                                             {
     if(_entities.size() == 0) {
         return geo::Area();
     }
 
     auto it = _entities.begin();
     geo::Area area = (*it)->boundingBox();
     it++;
 
     while(it != _entities.end()) {
         area = area.merge((*it)->boundingBox());
         it++;
     }
 
     return area;
 }

bool lc::entity::LWPolyline::closed ( ) const

inline

Definition at line 133 of file lwpolyline.h.

                                 {
                 return _closed;
             }

CADEntity_CSPtr LWPolyline::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 57 of file lwpolyline.cpp.

                                                                   {
     std::vector<LWVertex2D> newVertex;
     for (auto vertex : _vertex) {
         newVertex.emplace_back(vertex.location() + offset, vertex.bulge(), vertex.startWidth(), vertex.endWidth());
     }
     auto newEntity = std::make_shared<LWPolyline>(newVertex, width(), elevation(), tickness(), closed(),
                                                   extrusionDirection(), layer(), metaInfo());
     return newEntity;
 }

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

inlineoverridevirtual

Implements lc::entity::CADEntity.

Definition at line 215 of file lwpolyline.h.

                                                                      {
                 ed.visit(shared_from_this());
             }

std::map< unsigned int, lc::geo::Coordinate > LWPolyline::dragPoints ( ) const

overridevirtual

Get all points of the entity that can be dragged.

Returns: Map of points

Implements lc::Draggable.

Definition at line 267 of file lwpolyline.cpp.

                                                                    {
     std::map<unsigned int, geo::Coordinate> dragPoints;
     unsigned int i = 0;
 
     for(auto vertex : _vertex) {
         dragPoints[i] = vertex.location();
         i++;
     }
 
     return dragPoints;
 }

double lc::entity::LWPolyline::elevation ( ) const

inline

Definition at line 117 of file lwpolyline.h.

                                      {
                 return _elevation;
             }

geo::Coordinate const& lc::entity::LWPolyline::extrusionDirection ( ) const

inline

Definition at line 125 of file lwpolyline.h.

                                                             {
                 return _extrusionDirection;
             }

void LWPolyline::generateEntities ( )

private

Generate entities of the polyline.

Definition at line 126 of file lwpolyline.cpp.

                                   {
     auto itr = _vertex.begin();
     auto lastPoint = itr;
     itr++;
     while (itr != vertex().end()) {
         if (lastPoint->bulge() != 0.) {
             _entities.push_back(std::make_shared<const Arc>(
                     geo::Arc::createArcBulge(lastPoint->location(), itr->location(), lastPoint->bulge()),
                     layer(),
                     metaInfo(),
                     block()
             ));
         }
         else {
             _entities.push_back(std::make_shared<const Line>(lastPoint->location(), itr->location(), layer(), metaInfo(), block()));
         }
         lastPoint = itr;
         itr++;
     }
 
     if (_closed) {
         auto firstP = _vertex.begin();
         if (lastPoint->bulge() != 0.) {
             _entities.push_back(std::make_shared<const Arc>(
                     geo::Arc::createArcBulge(lastPoint->location(), firstP->location(), lastPoint->bulge()),
                     layer(),
                     metaInfo(),
                     block()
             ));
         }
         else {
             _entities.push_back(std::make_shared<const Line>(lastPoint->location(), firstP->location(), layer(), metaInfo(), block()));
         }
     }
 }

virtual CADEntity_CSPtr lc::entity::LWPolyline::mirror	(	const geo::Coordinate &	axis1,
		const geo::Coordinate &	axis2
	)		const

inlineoverridevirtual

Implements lc::entity::CADEntity.

Definition at line 193 of file lwpolyline.h.

                                                                {
                 return NULL; // TODO: no return statement, not implemented in lwpolyline.cpp
             }

CADEntity_CSPtr LWPolyline::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 109 of file lwpolyline.cpp.

                                                                                                             {
     auto newEntity = std::make_shared<LWPolyline>(
             _vertex,
             _width,
             _elevation,
             _tickness,
             _closed,
             _extrusionDirection,
             layer,
             metaInfo,
             block
     );
     newEntity->setID(this->id());
 
     return newEntity;
 }

CADEntity_CSPtr LWPolyline::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 46 of file lwpolyline.cpp.

                                                                   {
     std::vector<LWVertex2D> newVertex;
     for (auto vertex : _vertex) {
         newVertex.emplace_back(vertex.location() + offset, vertex.bulge(), vertex.startWidth(), vertex.endWidth());
     }
     auto newEntity = std::make_shared<LWPolyline>(newVertex, width(), elevation(), tickness(), closed(),
                                                   extrusionDirection(), layer(), metaInfo());
     newEntity->setID(this->id());
     return newEntity;
 }

geo::Coordinate LWPolyline::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 229 of file lwpolyline.cpp.

                                                                              {
     auto &&info = nearestPointOnPath2(coord);
     return std::get<0>(info);
 }

std::tuple< geo::Coordinate, std::shared_ptr< const geo::Vector >, std::shared_ptr< const geo::Arc > > LWPolyline::nearestPointOnPath2 ( const geo::Coordinate & coord ) const

Definition at line 234 of file lwpolyline.cpp.

                                           {
     const auto &&entities = asEntities();
 
     double minimumDistance = std::numeric_limits<double>::max();
     std::shared_ptr<const geo::Vector> nearestVector = nullptr;
     std::shared_ptr<const geo::Arc> nearestArc = nullptr;
     geo::Coordinate nearestCoordinate;
     for (auto &geoItem : entities) {
         if (auto vector = std::dynamic_pointer_cast<const geo::Vector>(geoItem)) {
             auto npoe = vector->nearestPointOnPath(coord);
             auto thisDistance = npoe.distanceTo(coord);
             if (thisDistance < minimumDistance) {
                 minimumDistance = thisDistance;
                 nearestCoordinate = npoe;
                 nearestVector = vector;
             }
         } else if (auto arc = std::dynamic_pointer_cast<const geo::Arc>(geoItem)) {
             auto npoe = arc->nearestPointOnPath(coord);
             auto thisDistance = npoe.distanceTo(coord);
             if (thisDistance < minimumDistance) {
                 minimumDistance = thisDistance;
                 nearestCoordinate = npoe;
                 nearestArc = arc;
             }
         } else {
             std::cerr << "Unknown entity found in LWPolyline during boundingBox generation" << std::endl;
         }
     }
     return std::make_tuple(nearestCoordinate, nearestVector, nearestArc);
 }

CADEntity_CSPtr LWPolyline::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 67 of file lwpolyline.cpp.

                                                                                                           {
     std::vector<LWVertex2D> newVertex;
     for (auto vertex : _vertex) {
         newVertex.emplace_back(vertex.location().rotate(rotation_center, rotation_angle), vertex.bulge(),
                                vertex.startWidth(), vertex.endWidth());
     }
     auto newEntity = std::make_shared<LWPolyline>(newVertex, width(), elevation(), tickness(), closed(),
                                                   extrusionDirection(), layer(), metaInfo());
     return newEntity;
 }

CADEntity_CSPtr LWPolyline::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 78 of file lwpolyline.cpp.

                                                                                                             {
     std::vector<LWVertex2D> newVertex;
     if (scale_factor.x() != scale_factor.y()) {
         // TODO decide what to do with non-uniform scale factors
     }
     for (auto vertex : _vertex) {
         newVertex.emplace_back(vertex.location().scale(scale_center, scale_factor), vertex.bulge() * scale_factor.x(),
                                vertex.startWidth(), vertex.endWidth());
     }
     auto newEntity = std::make_shared<LWPolyline>(newVertex, width(), elevation(), tickness(), closed(),
                                                   extrusionDirection(), layer(), metaInfo());
     return newEntity;
 }

CADEntity_CSPtr LWPolyline::setDragPoints ( std::map< unsigned int, lc::geo::Coordinate > dragPoints ) const

overridevirtual

Return modified entity.

Parameters

dragPoints Modified points

Returns: New entity or same entity if an error occurred Return the new entity which corresponds to the given points. Points must be associated to the same number given in dragPoints().

Implements lc::Draggable.

Definition at line 280 of file lwpolyline.cpp.

                                                                                                 {
     try {
         std::vector<LWVertex2D> newVertex;
         unsigned int i = 0;
 
         for(auto vertex : _vertex) {
             newVertex.push_back(LWVertex2D(dragPoints[i], vertex.bulge(), vertex.startWidth(), vertex.endWidth()));
             i++;
         }
 
         auto newEntity = std::make_shared<LWPolyline>(newVertex, width(), elevation(), tickness(), closed(), extrusionDirection(), layer(), metaInfo());
         newEntity->setID(id());
         return newEntity;
     }
     catch(std::out_of_range& e) {
         return shared_from_this();
     }
 }

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

overridevirtual

Find a number of snap points the line has available This function returns a ordered list, closest to coord and can return multiple snap points.

Parameters

coord	Coordinate to lookup the nearest coordinate from
minDistanceToSnap	Minimum distance to the path to snap into. THis is a hint parameter and we should follow this, but it will be later filtered again
maxNumberOfSnapPoints	Maximum number of snappoints that have to be looked up

See also: lc::EntityCoordinate

Implements lc::Snapable.

Definition at line 162 of file lwpolyline.cpp.

                                                                                       {
     std::vector<EntityCoordinate> points;
     if (constrain.constrain() & SimpleSnapConstrain::LOGICAL) {
         const auto &&entities = asEntities();
         for (auto &geoItem : entities) {
             if (auto vector = std::dynamic_pointer_cast<const geo::Vector>(geoItem)) {
                 points.emplace_back(vector->start(), -1);
                 points.emplace_back(vector->end(), -2);
             } else if (auto arc = std::dynamic_pointer_cast<const geo::Arc>(geoItem)) {
                 points.emplace_back(arc->startP(), -3);
                 points.emplace_back(arc->endP(), -4);
                 points.emplace_back(arc->center(), -5);
 
                 // Add 4 coordinates
                 // Top Point
                 if (arc->isAngleBetween(.5 * M_PI)) {
                     const auto coord = arc->center() + lc::geo::Coordinate(0., arc->radius());
                     points.emplace_back(coord, 1);
                 }
                 // Right Point
                 if (arc->isAngleBetween(0)) {
                     const auto coord = arc->center() + lc::geo::Coordinate(arc->radius(), 0.);
                     points.emplace_back(coord, 2);
                 }
                 // Left Point
                 if (arc->isAngleBetween(M_PI)) {
                     const auto coord = arc->center() + lc::geo::Coordinate(-arc->radius(), 0.);
                     points.emplace_back(coord, 3);
                 }
                 // Bottom Point
                 if (arc->isAngleBetween(-.5 * M_PI)) {
                     const auto coord = arc->center() + lc::geo::Coordinate(0., -arc->radius());
                     points.emplace_back(coord, 4);
                 }
             } else {
                 std::cerr << "Unknown entity found in LWPolyline during snapPoints generation" << std::endl;
             }
         }
     }
 
     if (constrain.constrain() & SimpleSnapConstrain::ON_ENTITY) {
         auto &&info = nearestPointOnPath2(coord);
         geo::Coordinate npoe = std::get<0>(info);
         if (auto &arc = std::get<2>(info)) {
             const double a = (npoe - arc->center()).angle();
             if (arc->isAngleBetween(a)) {
                 points.emplace_back(npoe, -6);
             }
         } else if (auto &vector = std::get<1>(info)) {
             if (vector->nearestPointOnEntity(coord).distanceTo(coord) < minDistanceToSnap) {
                 points.emplace_back(npoe, -7);
             }
         }
     }
 
     if (constrain.constrain() & SimpleSnapConstrain::ON_ENTITYPATH) {
         geo::Coordinate npoe = nearestPointOnPath(coord);
         points.emplace_back(npoe, -1);
     }
 
     // Cleanup array of snappoints
     Snapable::snapPointsCleanup(points, coord, maxNumberOfSnapPoints, minDistanceToSnap);
     return points;
 }

double lc::entity::LWPolyline::tickness ( ) const

inline

Definition at line 121 of file lwpolyline.h.

                                     {
                 return _tickness;
             }

std::vector<LWVertex2D> const& lc::entity::LWPolyline::vertex ( ) const

inline

Definition at line 129 of file lwpolyline.h.

                                                         {
                 return _vertex;
             }

double lc::entity::LWPolyline::width ( ) const

inline

Definition at line 113 of file lwpolyline.h.

                                  {
                 return _width;
             }

Member Data Documentation

const bool lc::entity::LWPolyline::_closed

private

Definition at line 156 of file lwpolyline.h.

const double lc::entity::LWPolyline::_elevation

private

Definition at line 154 of file lwpolyline.h.

std::vector<CADEntity_CSPtr> lc::entity::LWPolyline::_entities

private

Definition at line 158 of file lwpolyline.h.

const geo::Coordinate lc::entity::LWPolyline::_extrusionDirection

private

Definition at line 157 of file lwpolyline.h.

const double lc::entity::LWPolyline::_tickness

private

Definition at line 155 of file lwpolyline.h.

const std::vector<LWVertex2D> lc::entity::LWPolyline::_vertex

private

Definition at line 152 of file lwpolyline.h.

const double lc::entity::LWPolyline::_width

private

Definition at line 153 of file lwpolyline.h.

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

lckernel/cad/primitive/lwpolyline.h
lckernel/cad/primitive/lwpolyline.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation