object.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__GEOMETRY_OBJECT_H
#define PLASK__GEOMETRY_OBJECT_H
 
#include <functional>
#include <set>
#include <tuple>
#include <vector>
 
#include <boost/variant.hpp>
#include <boost/algorithm/string.hpp>
 
#include "../material/air.hpp"
#include "../material/material.hpp"
#include "../material/db.hpp"
#include "../utils/iterators.hpp"
#include "primitives.hpp"
 
#include <boost/signals2.hpp>
#include "../utils/event.hpp"
 
#include "../axes.hpp"
#include "../utils/warnings.hpp"
#include "../utils/xml/writer.hpp"
 
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <boost/bind.hpp>
 
#define PLASK_GEOMETRY_TYPE_NAME_SUFFIX_2D "2d"
 
#define PLASK_GEOMETRY_TYPE_NAME_SUFFIX_3D "3d"
 
#define PLASK_GEOMETRY_MAX_STEPS 10
 
#define PLASK_GEOMETRY_MIN_STEP_SIZE 0.005
 
namespace plask {
 
class GeometryReader;
 
struct PathHints;
struct Path;
 
struct Geometry;
template <int dimensions> struct GeometryObjectD;
template <int dimensions> struct TranslationContainer;
 
typedef boost::variant<shared_ptr<Material>, shared_ptr<MaterialsDB::MixedCompositionFactory>> SolidOrGradientMaterial;
 
struct PLASK_API GeometryObject : public enable_shared_from_this<GeometryObject> {
    enum Type {
        TYPE_LEAF = 0,           
        TYPE_TRANSFORM = 1,      
        TYPE_SPACE_CHANGER = 2,  
        TYPE_CONTAINER = 3,      
        TYPE_GEOMETRY = 4,       
        TYPE_SEPARATOR = 5       
    };
 
    class PLASK_API Event : public EventWithSourceAndFlags<GeometryObject, unsigned> {
        const GeometryObject* _originalSource;
 
      public:
        using EventWithSourceAndFlags<GeometryObject, unsigned>::FlagsType;
 
        enum Flags : FlagsType {
            EVENT_DELETE = 1 << 0,            
            EVENT_RESIZE = 1 << 1,            
            EVENT_DELEGATED = 1 << 2,         
            EVENT_CHILDREN_INSERT = 1 << 3,   
            EVENT_CHILDREN_REMOVE = 1 << 4,   
            EVENT_CHILDREN_GENERIC = 1 << 5,  
            EVENT_EDGES =
                1 << 6,  
            EVENT_STEPS = 1 << 7,        
            EVENT_USER_DEFINED = 1 << 8  
        };
 
        FlagsType flagsForParent() const {
            return flagsWithout(EVENT_DELETE | EVENT_CHILDREN_INSERT | EVENT_CHILDREN_REMOVE | EVENT_CHILDREN_GENERIC) |
                   EVENT_DELEGATED | (hasFlag(EVENT_DELETE) ? EVENT_RESIZE : 0u);
        }
 
        FlagsType flagsForParentWithChildrenWasChangedInformation() const {
            FlagsType result = flagsForParent();
            if (hasAnyFlag(EVENT_CHILDREN_INSERT | EVENT_CHILDREN_REMOVE | EVENT_CHILDREN_GENERIC))
                result |= EVENT_CHILDREN_GENERIC;
            return result;
        }
 
        bool hasFlag(Flags flag) const { return hasAnyFlag(flag); }
 
        bool isDelete() const { return hasFlag(EVENT_DELETE); }
 
        bool isResize() const { return hasFlag(EVENT_RESIZE); }
 
        bool isDelgatedFromChild() const { return hasFlag(EVENT_DELEGATED); }
 
        bool hasChangedChildrenList() const {
            return hasAnyFlag(EVENT_CHILDREN_INSERT | EVENT_CHILDREN_REMOVE | EVENT_CHILDREN_GENERIC);
        }
 
        bool hasChangedEdges() const { return hasFlag(EVENT_EDGES); }
 
        const GeometryObject* originalSource() const { return _originalSource; }
 
        explicit Event(GeometryObject* source, FlagsType flags = 0)
            : EventWithSourceAndFlags<GeometryObject, unsigned>(source, flags), _originalSource(source) {}
 
        explicit Event(GeometryObject* source, const GeometryObject* originalSource, FlagsType flags)
            : EventWithSourceAndFlags<GeometryObject, unsigned>(source, flags), _originalSource(originalSource) {}
    };
 
    struct PLASK_API ChildrenListChangedEvent : public Event {
        using Event::FlagsType;
 
        ChildrenListChangedEvent(GeometryObject* source,
                                 FlagsType flags,
                                 const std::size_t beginIndex,
                                 const std::size_t endIndex)
            : Event(source, flags), beginIndex(beginIndex), endIndex(endIndex) {}
 
        const std::size_t beginIndex;
 
        const std::size_t endIndex;
    };
 
    struct PLASK_API Subtree {
        shared_ptr<const GeometryObject> object;
 
        std::vector<Subtree> children;
 
        Subtree(shared_ptr<const GeometryObject> object = shared_ptr<const GeometryObject>()) : object(object) {}
 
        Subtree(shared_ptr<const GeometryObject> object, const std::vector<Subtree>& children)
            : object(object), children(children) {}
 
        Subtree(shared_ptr<const GeometryObject> object, std::vector<Subtree>&& children)
            : object(object), children(std::forward<std::vector<Subtree>>(children)) {}
 
        static Subtree extendIfNotEmpty(shared_ptr<const GeometryObject> root, Subtree&& children) {
            return children.empty() ? Subtree() : Subtree(root, std::vector<Subtree>{std::forward<Subtree>(children)});
        }
 
        static Subtree extendIfNotEmpty(const GeometryObject* root, Subtree&& children) {
            return children.empty()
                       ? Subtree()
                       : Subtree(root->shared_from_this(), std::vector<Subtree>{std::forward<Subtree>(children)});
        }
 
        bool hasBranches() const;
 
        Path toLinearPath() const;
 
        Path getLastPath() const;
 
        bool empty() const { return !object; }
    };
 
    struct PLASK_API Changer {
        virtual ~Changer() {}
 
        virtual bool apply(shared_ptr<GeometryObject>& to_change, Vec<3, double>* translation = 0) const = 0;
    };
 
    struct PLASK_API CompositeChanger : public Changer {
        std::vector<const Changer*> changers;
 
        CompositeChanger(const Changer* changer);
 
        CompositeChanger& operator()(const Changer* changer);
 
        CompositeChanger& append(const Changer* changer) { return operator()(changer); }
 
        CompositeChanger() {}
 
        ~CompositeChanger();
 
        bool apply(shared_ptr<GeometryObject>& to_change, Vec<3, double>* translation = 0) const override;
    };
 
    struct PLASK_API ReplaceChanger : public Changer {
        shared_ptr<const GeometryObject> from;
        shared_ptr<GeometryObject> to;
 
        Vec<3, double> translation;
 
        ReplaceChanger() {}
 
        ReplaceChanger(shared_ptr<const GeometryObject> from, shared_ptr<GeometryObject> to, Vec<3, double> translation)
            : from(from), to(to), translation(translation) {}
 
        template <typename F>
        ReplaceChanger(const shared_ptr<const GeometryObject>& from, F calc_replace)
            : from(from), translation(0.0, 0.0, 0.0) {
            this->to = calc_replace(this->from);
        }
 
        bool apply(shared_ptr<GeometryObject>& to_change, Vec<3, double>* translation = 0) const override;
    };
 
    struct PLASK_API ToBlockChanger : public ReplaceChanger {
        ToBlockChanger(shared_ptr<const GeometryObject> toChange, const SolidOrGradientMaterial& material, bool draft = false);
    };
 
    struct PLASK_API DeleteChanger : public Changer {
        shared_ptr<const GeometryObject> toDel;
 
        DeleteChanger(shared_ptr<const GeometryObject> toDel) : toDel(toDel) {}
 
        bool apply(shared_ptr<GeometryObject>& to_change, Vec<3, double>* translation = 0) const override;
    };
 
    typedef std::function<bool(const GeometryObject&)> Predicate;
 
    static bool PredicateIsLeaf(const GeometryObject& el) { return el.isLeaf(); }
 
    struct PLASK_API PredicateIsA {
        const GeometryObject& objectToBeEqual;
        PredicateIsA(const GeometryObject& objectToBeEqual) : objectToBeEqual(objectToBeEqual) {}
        PredicateIsA(const shared_ptr<GeometryObject>& objectToBeEqual) : objectToBeEqual(*objectToBeEqual) {}
        PredicateIsA(const shared_ptr<const GeometryObject>& objectToBeEqual) : objectToBeEqual(*objectToBeEqual) {}
        bool operator()(const GeometryObject& el) const { return &el == &objectToBeEqual; }
    };
 
    struct PLASK_API PredicateHasRole {
        std::string role_name;
        PredicateHasRole(const std::string& role_name) : role_name(role_name) {
            boost::algorithm::trim(this->role_name);
        };
        PredicateHasRole(std::string&& role_name) : role_name(std::move(role_name)) {
            boost::algorithm::trim(this->role_name);
        };
        bool operator()(const GeometryObject& obj) const { return obj.roles.find(role_name) != obj.roles.end(); }
    };
 
    class PLASK_API WriteXMLCallback {
        std::map<const GeometryObject*, std::string> names_of_saved;
 
        std::map<const GeometryObject*, unsigned> counts;  
 
        unsigned nextAutoName;
 
      public:
        WriteXMLCallback() : nextAutoName(0) {}
 
        void prerareToAutonaming(const GeometryObject& subtree_root);
 
        virtual std::string getName(const GeometryObject& object, AxisNames& axesNames) const;
 
        virtual std::vector<std::string> getPathNames(const GeometryObject& parent,
                                                      const GeometryObject& child,
                                                      std::size_t index_of_child_in_parent) const;
 
        XMLWriter::Element makeTag(XMLElement& parent_tag, const GeometryObject& object, AxisNames& axesNames);
 
        XMLElement makeChildTag(XMLElement& container_tag,
                                const GeometryObject& container,
                                std::size_t index_of_child_in_parent) const;
 
        static bool isRef(const XMLElement& el) { return el.getName() == "again"; }
    };
 
    unsigned max_steps;
 
    double min_step_size;
 
    void setMaxSteps(unsigned value) {
        max_steps = value;
        fireChanged(GeometryObject::Event::EVENT_STEPS);
    }
 
    void setMinStepSize(double value) {
        min_step_size = value;
        fireChanged(GeometryObject::Event::EVENT_STEPS);
    }
 
    std::set<std::string> roles;
 
    boost::signals2::signal<void(Event&)> changed;
 
    template <typename ClassT, typename methodT>
    boost::signals2::connection changedConnectMethod(ClassT* obj,
                                                     methodT method,
                                                     boost::signals2::connect_position at = boost::signals2::at_back) {
        return changed.connect(boost::bind(method, obj, _1), at);
    }
 
    template <typename ClassT, typename methodT> void changedDisconnectMethod(ClassT* obj, methodT method) {
        changed.disconnect(boost::bind(method, obj, _1));
    }
 
    /*
     * Just call changed with given event data.
     * Subroles can redefine this and do some extra actions.
     * @param evt event data
     */
    /*virtual void callChanged(Event& evt) {
        changed(evt);
    }*/
 
    template <typename EventT = Event, typename... Args>
    void fireChanged(Args&&... event_constructor_params_without_source) {
        EventT evt(this, std::forward<Args>(event_constructor_params_without_source)...);
        changed(evt);  // callChanged
    }
 
    GeometryObject(const GeometryObject& to_copy)
        : enable_shared_from_this<GeometryObject>(to_copy),
          max_steps(to_copy.max_steps),
          min_step_size(to_copy.min_step_size) {}
 
    GeometryObject& operator=(const GeometryObject& to_copy) {
        enable_shared_from_this<GeometryObject>::operator=(to_copy);
        max_steps = to_copy.max_steps;
        min_step_size = to_copy.min_step_size;
        return *this;
    }
 
    GeometryObject() : max_steps(0), min_step_size(0) {}
 
    GeometryObject(unsigned max_steps, double min_step_size) : max_steps(max_steps), min_step_size(min_step_size) {}
 
    virtual ~GeometryObject();
 
    virtual std::string getTypeName() const = 0;
 
    virtual void writeXML(XMLWriter::Element& parent_xml_object,
                          WriteXMLCallback& write_cb,
                          AxisNames parent_axes) const;
 
    void writeXML(XMLWriter::Element& parent_xml_object, WriteXMLCallback& write_cb) const {
        writeXML(parent_xml_object, write_cb, AxisNames::getAbsoluteNames());
    }
 
    void writeXML(XMLWriter::Element& parent_xml_object) const {
        WriteXMLCallback write_cb;
        writeXML(parent_xml_object, write_cb, AxisNames::getAbsoluteNames());
    }
 
    template <int DIMS> shared_ptr<GeometryObjectD<DIMS>> asD();
 
    template <int DIMS> shared_ptr<const GeometryObjectD<DIMS>> asD() const;
 
    shared_ptr<Geometry> asGeometry();
 
    shared_ptr<const Geometry> asGeometry() const;
 
    virtual Type getType() const = 0;
 
    bool isLeaf() const { return getType() == TYPE_LEAF; }
    bool isTransform() const { return getType() == TYPE_TRANSFORM || getType() == TYPE_SPACE_CHANGER; }
    bool isSpaceChanger() const { return getType() == TYPE_SPACE_CHANGER; }
    bool isContainer() const { return getType() == TYPE_CONTAINER; }
    bool isGeometry() const { return getType() == TYPE_GEOMETRY; }
 
    /*
     * Get material only if it this object is solid (has assign exactly one material).
     * @return material or nullptr if it is not solid
     *
     * Default implementation returns nullptr.
     */
    // virtual shared_ptr<Material> singleMaterial() const { return shared_ptr<Material>(); }
 
    virtual void addPointsAlongToSet(std::set<double>& points,
                                     Primitive<3>::Direction PLASK_UNUSED(direction),
                                     unsigned PLASK_UNUSED(max_steps),
                                     double PLASK_UNUSED(min_step_size)) const = 0;
 
    std::set<double> getPointsAlong(Primitive<3>::Direction direction,
                                    unsigned max_steps = PLASK_GEOMETRY_MAX_STEPS,
                                    double min_step_size = PLASK_GEOMETRY_MIN_STEP_SIZE) const {
        std::set<double> points;
        addPointsAlongToSet(points, direction, max_steps, min_step_size);
        return points;
    }
 
    bool hasRole(std::string role_name) const {
        boost::algorithm::trim(role_name);
        return roles.find(role_name) != roles.end();
    }
 
    void addRole(std::string role_name) {
        boost::algorithm::trim(role_name);
        roles.insert(role_name);
    }
 
    void removeRole(std::string role_name) {
        boost::algorithm::trim(role_name);
        roles.erase(role_name);
    }
 
    void clearRoles() { roles.clear(); }
 
    virtual int getDimensionsCount() const = 0;
 
    virtual void validate() const {}
 
    // TODO ? predicate, path
    virtual bool hasInSubtree(const GeometryObject& el) const;
 
    bool hasInSubtree(const GeometryObject& el, const PathHints* pathHints) const {
        return !getObjects(PredicateIsA(el), pathHints).empty();
    }
 
    bool hasInSubtree(shared_ptr<const GeometryObject> el, const PathHints* pathHints) const {
        return hasInSubtree(*el, pathHints);
    }
 
    // TODO ? predicate
    virtual Subtree getPathsTo(const GeometryObject& el, const PathHints* pathHints = 0) const = 0;
 
    virtual void getObjectsToVec(const Predicate& predicate,
                                 std::vector<shared_ptr<const GeometryObject>>& dest,
                                 const PathHints* path = 0) const = 0;
 
    void getObjectsToVec(const Predicate& predicate,
                         std::vector<shared_ptr<const GeometryObject>>& dest,
                         const PathHints& path) const {
        getObjectsToVec(predicate, dest, &path);
    }
 
    std::vector<shared_ptr<const GeometryObject>> getObjects(const Predicate& predicate,
                                                             const PathHints* path = 0) const {
        std::vector<shared_ptr<const GeometryObject>> result;
        getObjectsToVec(predicate, result, path);
        return result;
    }
 
    std::vector<shared_ptr<const GeometryObject>> getObjects(const Predicate& predicate, const PathHints& path) const {
        return getObjects(predicate, &path);
    }
 
    void getLeafsToVec(std::vector<shared_ptr<const GeometryObject>>& dest, const PathHints* path = 0) const {
        getObjectsToVec(&GeometryObject::PredicateIsLeaf, dest, path);
    }
 
    void getLeafsToVec(std::vector<shared_ptr<const GeometryObject>>& dest, const PathHints& path) const {
        getLeafsToVec(dest, &path);
    }
 
    std::vector<shared_ptr<const GeometryObject>> getLeafs(const PathHints* path = 0) const {
        std::vector<shared_ptr<const GeometryObject>> result;
        getLeafsToVec(result, path);
        return result;
    }
 
    std::vector<shared_ptr<const GeometryObject>> getLeafs(const PathHints& path) const { return getLeafs(&path); }
 
    void getObjectsWithRoleToVec(const std::string& role, std::vector<shared_ptr<const GeometryObject>>& dest) const {
        getObjectsToVec(PredicateHasRole(role), dest);
    }
 
    std::vector<shared_ptr<const GeometryObject>> getObjectsWithRole(const std::string& role) const {
        return getObjects(PredicateHasRole(role));
    }
 
    virtual std::size_t getChildrenCount() const = 0;
 
    virtual shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const = 0;
 
    virtual std::size_t getRealChildrenCount() const;
 
    virtual shared_ptr<GeometryObject> getRealChildNo(std::size_t child_no) const;
 
    virtual void removeAtUnsafe(std::size_t index);
 
    void removeAt(std::size_t index) {
        ensureIsValidChildNr(index, "removeAt", "index");
        removeAtUnsafe(index);
        fireChildrenRemoved(index, index + 1);
    }
 
    void removeRangeUnsafe(std::size_t index_begin, std::size_t index_end) {
        while (index_begin < index_end) removeAtUnsafe(--index_end);
    }
 
    bool removeRange(std::size_t index_begin, std::size_t index_end) {
        if (index_begin >= index_end) return false;
        ensureIsValidChildNr(index_end - 1, "removeRange", "index_end-1");
        removeRangeUnsafe(index_begin, index_end);
        fireChildrenRemoved(index_begin, index_end);
        return true;
    }
 
    virtual void forEachRealObjectInSubtree(std::function<bool(const GeometryObject&)> callback) const;
 
  private:
    struct ChildGetter {  // used by begin(), end()
        shared_ptr<const GeometryObject> el;
        ChildGetter(const shared_ptr<const GeometryObject>& el) : el(el) {}
        shared_ptr<GeometryObject> operator()(std::size_t index) const { return el->getChildNo(index); }
    };
 
  public:
    FunctorIndexedIterator<ChildGetter> begin() const {
        return FunctorIndexedIterator<ChildGetter>(ChildGetter(this->shared_from_this()), 0);
    }
 
    FunctorIndexedIterator<ChildGetter> end() const {
        return FunctorIndexedIterator<ChildGetter>(ChildGetter(this->shared_from_this()), getChildrenCount());
    }
 
    // virtual GeometryTransform getTransform()
 
    virtual shared_ptr<const GeometryObject> changedVersion(const Changer& changer,
                                                            Vec<3, double>* translation = 0) const = 0;
 
    virtual shared_ptr<GeometryObject> shallowCopy() const = 0;
 
    virtual shared_ptr<GeometryObject> deepCopy(
        std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const = 0;
 
    shared_ptr<GeometryObject> deepCopy() {
        std::map<const GeometryObject*, shared_ptr<GeometryObject>> copied;
        return deepCopy(copied);
    }
 
    bool canHasAsChild(const GeometryObject& potential_child) const { return !potential_child.hasInSubtree(*this); }
 
    bool canHasAsParent(const GeometryObject& potential_parent) const { return !this->hasInSubtree(potential_parent); }
 
    void ensureCanHasAsParent(const GeometryObject& potential_parent) const;
 
    void ensureCanHaveAsChild(const GeometryObject& potential_child) const {
        potential_child.ensureCanHasAsParent(*this);
    }
 
  protected:
    virtual void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const;
 
    virtual void writeXMLChildren(XMLWriter::Element& dest_xml_object,
                                  WriteXMLCallback& write_cb,
                                  const AxisNames& axes) const;
 
    void ensureIsValidChildNr(std::size_t child_no,
                              const char* method_name = "getChildNo",
                              const char* arg_name = "child_no") const {
        std::size_t children_count = getRealChildrenCount();
        if (child_no >= children_count)
            throw OutOfBoundsException(method_name, arg_name, child_no, 0, children_count - 1);
    }
 
    void ensureIsValidInsertPosition(std::size_t child_no,
                                     const char* method_name = "insert",
                                     const char* arg_name = "pos") const {
        std::size_t children_count = getRealChildrenCount();
        if (child_no > children_count)
            throw OutOfBoundsException(method_name, arg_name, child_no, 0, children_count - 1);
    }
 
    void fireChildrenChanged() {
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE | GeometryObject::Event::EVENT_CHILDREN_GENERIC);
    }
 
    void fireChildrenRemoved(std::size_t beginIndex, std::size_t endIndex) {
        this->fireChanged<ChildrenListChangedEvent>(
            GeometryObject::Event::EVENT_RESIZE | GeometryObject::Event::EVENT_CHILDREN_REMOVE, beginIndex, endIndex);
    }
 
    void fireChildrenInserted(std::size_t beginIndex, std::size_t endIndex) {
        this->fireChanged<ChildrenListChangedEvent>(
            GeometryObject::Event::EVENT_RESIZE | GeometryObject::Event::EVENT_CHILDREN_INSERT, beginIndex, endIndex);
    }
};
 
template <int dim> struct Translation;
 
template <int dim> struct PLASK_API GeometryObjectD : public GeometryObject {
    static const int DIM = dim;
    typedef typename Primitive<dim>::Box Box;
    typedef typename Primitive<dim>::DVec DVec;
 
    struct LineSegment {
      private:
        DVec _p[2];
 
      public:
        LineSegment(const DVec& p0, const DVec& p1) {
            _p[0] = p0;
            _p[1] = p1;
            if (_p[1] < _p[0]) std::swap(_p[0], _p[1]);
        }
        const DVec& p0() const { return _p[0]; }
        const DVec& p1() const { return _p[1]; }
        const DVec& operator[](std::size_t i) const { return _p[i]; }
 
        bool operator<(const LineSegment& c) const {
            return _p[0] < c._p[0] || (!(c._p[0] < _p[0]) && _p[1] < c._p[1]);
        }
    };
 
    int getDimensionsCount() const override { return dim; }
 
    using GeometryObject::getPathsTo;
 
    virtual Subtree getPathsAt(const DVec& point, bool all = false) const = 0;
 
    virtual bool contains(const DVec& point) const = 0;
 
    /*
     * Check if this geometry object contains some point from given @a area.
     * @param area rectangular area
     * @return true only if this geometry contains some points from @a area
     */
    // TODO unused - to use and implement in subclasses (most have impl.) or to remove
    // virtual bool intersects(const Box& area) const = 0;
 
    virtual Box getBoundingBox() const = 0;
 
    virtual DVec getBoundingBoxSize() const { return getBoundingBox().size(); }
 
    virtual Box getRealBoundingBox() const { return getBoundingBox(); }
 
    virtual shared_ptr<Material> getMaterial(const DVec& p) const = 0;
 
    shared_ptr<Material> getMaterialOrAir(const DVec& p) const {
        auto real_mat = getMaterial(p);
        return real_mat ? real_mat : plask::make_shared<materials::Air>();
    }
 
    virtual void getBoundingBoxesToVec(const GeometryObject::Predicate& predicate,
                                       std::vector<Box>& dest,
                                       const PathHints* path = 0) const = 0;
 
    void getBoundingBoxesToVec(const GeometryObject::Predicate& predicate,
                               std::vector<Box>& dest,
                               const PathHints& path) const {
        getBoundingBoxesToVec(predicate, dest, &path);
    }
 
    std::vector<Box> getBoundingBoxes(const GeometryObject::Predicate& predicate, const PathHints* path = 0) const {
        std::vector<Box> result;
        getBoundingBoxesToVec(predicate, result, path);
        return result;
    }
 
    std::vector<Box> getBoundingBoxes(const GeometryObject::Predicate& predicate, const PathHints& path) {
        return getBoundingBoxes(predicate, &path);
    }
 
    void getLeafsBoundingBoxesToVec(std::vector<Box>& dest, const PathHints* path = 0) const {
        getBoundingBoxesToVec(&GeometryObject::PredicateIsLeaf, dest, path);
    }
 
    void getLeafsBoundingBoxesToVec(std::vector<Box>& dest, const PathHints& path) const {
        getLeafsBoundingBoxesToVec(dest, &path);
    }
 
    std::vector<Box> getLeafsBoundingBoxes(const PathHints* path = 0) const {
        std::vector<Box> result;
        getLeafsBoundingBoxesToVec(result, path);
        return result;
    }
 
    std::vector<Box> getLeafsBoundingBoxes(const PathHints& path) const { return getLeafsBoundingBoxes(&path); }
 
    void getObjectBoundingBoxesToVec(std::vector<Box>& dest,
                                     const GeometryObject& object,
                                     const PathHints* path = 0) const {
        getBoundingBoxesToVec(GeometryObject::PredicateIsA(object), dest, path);
    }
 
    void getObjectBoundingBoxesToVec(std::vector<Box>& dest,
                                     const GeometryObject& object,
                                     const PathHints& path) const {
        getObjectBoundingBoxesToVec(dest, object, &path);
    }
 
    std::vector<Box> getObjectBoundingBoxes(const GeometryObject& object, const PathHints* path = 0) const {
        std::vector<Box> result;
        getObjectBoundingBoxesToVec(result, object, path);
        return result;
    }
 
    std::vector<Box> getObjectBoundingBoxes(const GeometryObject& object, const PathHints& path) const {
        return getObjectBoundingBoxes(object, &path);
    }
 
    virtual void getPositionsToVec(const Predicate& predicate,
                                   std::vector<DVec>& dest,
                                   const PathHints* path = 0) const = 0;
 
    void getPositionsToVec(const Predicate& predicate, std::vector<DVec>& dest, const PathHints& path) const {
        getPositionsToVec(predicate, dest, &path);
    }
 
    std::vector<DVec> getPositions(const Predicate& predicate, const PathHints* path = 0) const {
        std::vector<DVec> result;
        getPositionsToVec(predicate, result, path);
        return result;
    }
 
    std::vector<DVec> getPositions(const Predicate& predicate, const PathHints& path) const {
        return getPositions(predicate, &path);
    }
 
    void getLeafsPositionsToVec(std::vector<DVec>& dest, const PathHints* path = 0) const {
        getPositionsToVec(&GeometryObject::PredicateIsLeaf, dest, path);
    }
 
    void getLeafsPositionsToVec(std::vector<DVec>& dest, const PathHints& path) const {
        getLeafsPositionsToVec(dest, &path);
    }
 
    std::vector<DVec> getLeafsPositions(const PathHints* path = 0) const {
        std::vector<DVec> result;
        getLeafsPositionsToVec(result, path);
        return result;
    }
 
    std::vector<DVec> getLeafsPositions(const PathHints& path) const { return getLeafsPositions(&path); }
 
    void getObjectPositionsToVec(std::vector<DVec>& dest,
                                 const GeometryObject& object,
                                 const PathHints* path = 0) const {
        getPositionsToVec(PredicateIsA(object), dest, path);
    }
 
    void getObjectPositionsToVec(std::vector<DVec>& dest, const GeometryObject& object, const PathHints& path) const {
        getObjectPositionsToVec(dest, object, &path);
    }
 
    std::vector<DVec> getObjectPositions(const GeometryObject& object, const PathHints* path = 0) const {
        return getPositions(PredicateIsA(object), path);
    }
 
    std::vector<DVec> getObjectPositions(const GeometryObject& object, const PathHints& path) const {
        return getObjectPositions(object, &path);
    }
 
    // /*
    //  * Get objects from the subtree with root in this, which fulfill predecate. Returned objects
    //  * are wrapped in transformations, which transform them to the root coordinates.
    //  * @param predicate
    //  * @param dest[out] place to append resulted objects
    //  * @param path
    //  */
    // virtual void extractToVec(const Predicate& predicate, std::vector< shared_ptr<const GeometryObjectD<dim> > >&
    // dest, const PathHints* path = 0) const = 0;
 
    // /*
    //  * Get objects from the subtree with root in this, which fulfill predecate. Returned objects
    //  * are wrapped in transformations, which transform them to the root coordinates.
    //  * @param predicate
    //  * @param dest[out] place to append resulted objects
    //  * @param path
    //  */
    // void extractToVec(const Predicate& predicate, std::vector< shared_ptr<const GeometryObjectD<dim> > >& dest, const
    // PathHints& path) const {
    //     extractToVec(predicate, dest, &path);
    // }
 
    // /*
    //  * Get objects from the subtree with root in this, which fulfill predecate. Returned objects
    //  * are wrapped in transformations, which transform them to the root coordinates.
    //  * @param predicate
    //  * @param path
    //  * @return resulted objects
    //  */
    // std::vector< shared_ptr<const GeometryObjectD<dim> > > extract(const Predicate& predicate, const PathHints* path
    // = 0) const {
    //     std::vector< shared_ptr<const GeometryObjectD<dim> > > dest;
    //     extractToVec(predicate, dest, path);
    //     return dest;
    // }
 
    // /*
    //  * Get objects from the subtree with root in this, which fulfill predecate. Returned objects
    //  * are wrapped in transformations, which transform them to the root coordinates.
    //  * @param predicate
    //  * @param path
    //  * @return resulted objects
    //  */
    // std::vector<shared_ptr<const GeometryObjectD<dim>>> extract(const Predicate& predicate, const PathHints& path)
    // const {
    //     return extract(predicate, &path);
    // }
 
    // /*
    //  * Get instances of the object withing subtree with root in this. Returned
    //  * are wrapped in transformations, which transform them to the root coordinates.
    //  * @param object object to extract
    //  * @param path
    //  * @return resulted objects
    //  */
    // std::vector<shared_ptr<const GeometryObjectD<dim>>> extractObject(const GeometryObjectD<dim>& object, const
    // PathHints* path = 0) {
    //     return extract(PredicateIsA(object), path);
    // }
 
    // /*
    //  * Get instances of the object withing subtree with root in this. Returned intances
    //  * are wrapped in transformations, which transform them to the root coordinates.
    //  * @param object object to extract
    //  * @param path
    //  * @return resulted objects
    //  */
    // std::vector<shared_ptr<const GeometryObjectD<dim>>> extractObject(const GeometryObjectD<dim>& object, const
    // PathHints& path) {
    //     return extractObject(object, &path);
    // }
 
    // /*
    //  * Get leafs withing subtree with root in this, wrapped in transformations, which transform them to the root
    //  coordinates.
    //  * @param path
    //  * @return resulted objects
    //  */
    // std::vector<shared_ptr<const GeometryObjectD<dim>>> extractLeafs(const PathHints* path = 0) {
    //     return extract(&GeometryObject::PredicateIsLeaf, path);
    // }
 
    // /*
    //  * Get leafs withing subtree with root in this, wrapped in transformations, which transform them to the root
    //  coordinates.
    //  * @param path
    //  * @return resulted objects
    //  */
    // std::vector<shared_ptr<const GeometryObjectD<dim>>> extractLeafs(const PathHints& path) {
    //     return extractLeafs(&path);
    // }
 
    // //TODO
    // //shared_ptr<const TranslationContainer<dim>> extractIntoContainer(const Predicate& predicate, const PathHints*
    // path = 0) const;
    // //shared_ptr<const TranslationContainer<dim>> extractIntoContainer(const Predicate& predicate, const PathHints&
    // path) const;
 
    // Path getMatchingPathToObjectAt(const DVec& point, const Predicate& predicate, const PathHints* path = 0) const;
 
    shared_ptr<const GeometryObject> getMatchingAt(const DVec& point,
                                                   const Predicate& predicate,
                                                   const PathHints* path = 0) const;
 
    inline shared_ptr<const GeometryObject> getMatchingAt(const DVec& point,
                                                          const Predicate& predicate,
                                                          const PathHints& path) const {
        return getMatchingAt(point, predicate, &path);
    }
 
    inline bool objectIncludes(const GeometryObject& object, const PathHints* path, const DVec& point) const {
        return getMatchingAt(point, PredicateIsA(object), path) != nullptr;
    }
 
    inline bool objectIncludes(const GeometryObject& object, const PathHints& path, const DVec& point) const {
        return objectIncludes(object, &path, point);
    }
 
    inline bool objectIncludes(const GeometryObject& object, const DVec& point) const {
        return objectIncludes(object, nullptr, point);
    }
 
    std::set<std::string> getRolesAt(const DVec& point, const plask::PathHints* path = 0) const;
 
    std::set<std::string> getRolesAt(const DVec& point, const plask::PathHints& path) const {
        return getRolesAt(point, &path);
    }
 
    shared_ptr<const GeometryObject> hasRoleAt(const std::string& role_name,
                                               const DVec& point,
                                               const plask::PathHints* path = 0) const {
        return getMatchingAt(point, GeometryObject::PredicateHasRole(role_name), path);
    }
 
    shared_ptr<const GeometryObject> hasRoleAt(const std::string& role_name,
                                               const DVec& point,
                                               const plask::PathHints& path) const {
        return hasRoleAt(role_name, point, &path);
    }
 
    virtual void addLineSegmentsToSet(std::set<LineSegment>& PLASK_UNUSED(segments),
                                      unsigned PLASK_UNUSED(max_steps),
                                      double PLASK_UNUSED(min_step_size)) const = 0;
 
    std::set<LineSegment> getLineSegments(unsigned max_steps = PLASK_GEOMETRY_MAX_STEPS,
                                          double min_step_size = PLASK_GEOMETRY_MIN_STEP_SIZE) const {
        std::set<LineSegment> segments;
        addLineSegmentsToSet(segments, max_steps, min_step_size);
        return segments;
    }
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(GeometryObjectD<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(GeometryObjectD<3>)
 
}  // namespace plask
 
#endif  // PLASK__GEOMETRY_OBJECT_H