entitycontainer.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <limits>
#include <string>
#include <vector>

#include "cad/const.h"
#include "cad/base/id.h"
#include "cad/dochelpers/quadtree.h"

#include "cad/vo/entitydistance.h"
#include "cad/functions/intersect.h"
#include "cad/geometry/geocoordinate.h"
#include "cad/primitive/line.h"

namespace lc {
    class Layer;
    template <typename CT>
    class EntityContainer {
        public:
            EntityContainer() {
                _tree = new QuadTree<CT>(geo::Area(geo::Coordinate(-500000., -500000.),
                                                   geo::Coordinate(500000., 500000.)
                ));
            }

            EntityContainer(const EntityContainer& other) {
                _tree = new QuadTree<CT>(*other._tree);
            }


            virtual ~EntityContainer() {
                delete _tree;
            }

            EntityContainer& operator = (const EntityContainer& ec) {
                if (this != &ec) {
                    _tree = new QuadTree<CT>(*ec._tree);
                }

                return *this;
            }

            void insert(CT entity) {
                _tree->insert(entity);
            }


            void combine(const EntityContainer& entities) {
                for (auto i : entities.asVector(std::numeric_limits<short>::max())) {
                    _tree->insert(i);
                }
            }

            void remove(CT entity) {
                _tree->erase(entity);
            }

            std::vector<CT> asVector(short maxLevel = std::numeric_limits<short>::max()) const {
                return _tree->retrieve(maxLevel);
            }
            CT entityByID(ID_DATATYPE id) const {
                return _tree->entityByID(id);
            }

            EntityContainer entitiesByLayer(const Layer_CSPtr layer) const {
                EntityContainer container;

                for (auto i : asVector(std::numeric_limits<short>::max())) {
                    if (i->layer() == layer) {
                        container.insert(i);
                    }
                }

                return container;
            }

            EntityContainer entitiesByMetaType(const std::string& metaName) const {
                EntityContainer container;

                for (auto i : asVector(std::numeric_limits<short>::max())) {
                    //       if (i->metaInfo(metaName) != nullptr) {
                    //           container.insert(i);
                    // }
                }

                return container;
            }

            EntityContainer entitiesFullWithinArea(const geo::Area& area,
                                                   const short maxLevel = std::numeric_limits<short>::max()) const {
                EntityContainer container;
                std::vector<CT> entities = _tree->retrieve(area, maxLevel);

                for (auto i : entities) {
                    // If the item fully with's with the selection area sinmply add it
                    if (i->boundingBox().inArea(area)) {
                        container.insert(i);
                    }
                }

                return container;
            }

            geo::Area boundingBox() const {
                geo::Area extends;
                const std::vector<CT> entities = _tree->retrieve();
                if (entities.size() > 0) {
                    extends = entities[0]->boundingBox();
                    for (const auto &i : entities) {
                        extends = extends.merge(i->boundingBox());
                    }
                }
                return extends;
            }

            EntityContainer
            entitiesWithinAndCrossingArea(const geo::Area& area,
                                          const short maxLevel = std::numeric_limits<short>::max()) const {
                EntityContainer container;
                std::vector<CT> entities = _tree->retrieve(area, maxLevel);

                for (auto i : entities) {

                    // If the item fully with's with the selection area sinmply add it
                    if (i->boundingBox().inArea(area)) {
                        container.insert(i);
                        continue;
                    }

                    // if it has 2 corners inside area, we know for 100% sure that the entity, or
                    // at least part of it is located within area
                    // We test for 2 (not 1) because for exampke with a arc we can have one corner inside
                    // The area, but still not intersecting with area
                    auto c = i->boundingBox().numCornersInside(area);

                    if (c == 2) {
                        container.insert(i);
                        continue;
                    }

                    // Path to area intersection testing
                    lc::Intersect intersect(Intersect::OnEntity, 10e-4);

                    auto &&v = area.top();
                    visitorDispatcher<bool, lc::GeoEntityVisitor>(intersect, v, *i.get());
                    if (!intersect.result().empty()) {
                        container.insert(i);
                        continue;
                    }

                    v = area.left();
                    visitorDispatcher<bool, GeoEntityVisitor>(intersect, v, *i.get());
                    if (!intersect.result().empty()) {
                        container.insert(i);
                        continue;
                    }

                    v = area.bottom();
                    visitorDispatcher<bool, GeoEntityVisitor>(intersect, v, *i.get());
                    if (!intersect.result().empty()) {
                        container.insert(i);
                        continue;
                    }

                    v = area.right();
                    visitorDispatcher<bool, GeoEntityVisitor>(intersect, v, *i.get());
                    if (!intersect.result().empty()) {
                        container.insert(i);
                        continue;
                    }
                }

                return container;
            }

            EntityContainer
            entitiesWithinAndCrossingAreaFast(const geo::Area& area,
                                              const short maxLevel = std::numeric_limits<short>::max()) const {
                EntityContainer container;

                std::vector<CT> &&entities = _tree->retrieve(area, maxLevel);

                for (auto &i : entities) {
                    // If the item fully with's with the selection area simply add it
                    if (i->boundingBox().overlaps(area)) {
                        container.insert(i);
                    }
                }

                return container;
            }

            std::vector<lc::EntityDistance> getEntityPathsNearCoordinate(const lc::geo::Coordinate& point,
                                                                         double distance) const {

                const auto area = lc::geo::Area(lc::geo::Coordinate(point.x(), point.y())+distance/2.,
                                                lc::geo::Coordinate(point.x(),point.y())+distance/2.);
                std::vector<CT> ent = _tree->retrieve(area);

                // Now calculate for each entity if we are near the entities path
                std::vector<lc::EntityDistance> entities;
                for (auto item : ent) {
                    Snapable_CSPtr entity = std::dynamic_pointer_cast<const lc::Snapable>(item);

                    if (entity != nullptr) { // Not all entities might be snapable, so we only test if this is possible.
                        lc::geo::Coordinate eCoordinate = entity->nearestPointOnPath(point);
                        if (eCoordinate.distanceTo(point) < distance) {
                            entities.emplace_back(item, eCoordinate);
                        }
                    }
                }

                return entities;
            }

            lc::geo::Area bounds() const {
                return _tree->bounds();
            }

            void optimise() {
                _tree->optimise();
            }


            template<typename U, typename T> void each(T func) {
                _tree->template each<U>(func);
            }

            template<typename U, typename T> void each(T func) const {
                _tree->template each<const U>(func);
            }
        private:
            QuadTree<CT>* _tree;
    };
}