space.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__CALCULATION_SPACE_H
#define PLASK__CALCULATION_SPACE_H
 
#include "edge.hpp"
#include "transform_space_cartesian.hpp"
#include "transform_space_cylindric.hpp"
 
#include "../axes.hpp"
 
#include <boost/signals2.hpp>
#include "../optional.hpp"
#include "../utils/event.hpp"
 
namespace plask {
 
struct PLASK_API Geometry : public GeometryObject {
    shared_ptr<Material> defaultMaterial;
 
    AxisNames axisNames;
 
    enum Direction {
        DIRECTION_LONG = Primitive<3>::DIRECTION_LONG,
        DIRECTION_TRAN = Primitive<3>::DIRECTION_TRAN,
        DIRECTION_VERT = Primitive<3>::DIRECTION_VERT
    };
 
    Geometry(shared_ptr<Material> defaultMaterial = make_shared<materials::Air>())
        : GeometryObject(PLASK_GEOMETRY_MAX_STEPS, PLASK_GEOMETRY_MIN_STEP_SIZE), defaultMaterial(defaultMaterial) {}
 
    Geometry(const Geometry& to_copy) : GeometryObject(to_copy), defaultMaterial(to_copy.defaultMaterial) {}
 
    Geometry& operator=(const Geometry& to_copy) {
        GeometryObject::operator=(to_copy);
        defaultMaterial = to_copy.defaultMaterial;
        return *this;
    }
 
    virtual ~Geometry() { fireChanged(Event::EVENT_DELETE); }
 
    virtual void setEdges(Direction direction, const edge::Strategy& border_lo, const edge::Strategy& border_hi) = 0;
 
    virtual void setEdges(Direction direction, const edge::Strategy& border_to_set) {
        setEdges(direction, border_to_set, border_to_set);
    }
 
    virtual void setPlanarEdges(const edge::Strategy& border_to_set) = 0;
 
    void setAllEdges(const edge::Strategy& border_to_set) {
        setPlanarEdges(border_to_set);
        setEdges(DIRECTION_VERT, border_to_set);
    }
 
    virtual void setEdge(Direction direction, bool higher, const edge::Strategy& border_to_set) = 0;
 
    // void setEdges(const std::function< std::unique_ptr<edge::Strategy> >(const std::string& s)>& borderValuesGetter,
    // const AxisNames& axesNames);
 
    void setEdges(const std::function<plask::optional<std::string>(const std::string& s)>& borderValuesGetter,
                  const AxisNames& axesNames,
                  const MaterialsDB& materialsDB = MaterialsDB::getDefault(),
                  bool draft = false);
 
    virtual const edge::Strategy& getEdge(Direction direction, bool higher) const = 0;
 
    virtual bool isSymmetric(Direction direction) const {
        return getEdge(direction, false).type() == edge::Strategy::MIRROR ||
               getEdge(direction, true).type() == edge::Strategy::MIRROR;
    }
 
    bool isPeriodic(Direction direction) const {
        return getEdge(direction, false).type() == edge::Strategy::PERIODIC ||
               getEdge(direction, true).type() == edge::Strategy::PERIODIC;
    }
 
    bool isExtended(Direction direction, bool higher) const { return getEdge(direction, higher).type() == edge::Strategy::EXTEND; }
 
    Type getType() const override { return TYPE_GEOMETRY; }
 
    virtual shared_ptr<GeometryObjectD<3>> getObject3D() const = 0;
 
  protected:
    template <typename EdgeType> static const EdgeType& castEdge(const edge::Strategy& strategy) {
        return dynamic_cast<const EdgeType&>(strategy);
    }
 
    virtual const char* alternativeDirectionName(std::size_t ax, std::size_t orient) const {
        const char* directions[3][2] = {{"back", "front"}, {"left", "right"}, {"bottom", "top"}};
        return directions[ax][orient];
    }
 
    void storeEdgeInXML(XMLWriter::Element& dest_xml_object, Direction direction, bool higher) const;
};
 
template <int dim> class PLASK_API GeometryD : public Geometry {
    boost::signals2::connection connection_with_child;
 
  public:
    enum { DIM = dim };
 
    typedef Vec<dim, double> CoordsType;
 
  protected:
    shared_ptr<Material> getMaterialOrDefault(const Vec<dim, double>& p) const {
        auto real_mat = getChild()->getMaterial(p);
        return real_mat ? real_mat : defaultMaterial;
    }
 
    typename Primitive<dim>::Box cachedBoundingBox;
 
    void onChildChanged(const GeometryObject::Event& evt);
 
    void disconnectOnChildChanged();
 
    void initNewChild();
 
    virtual ~GeometryD() { disconnectOnChildChanged(); }
 
  public:
    int getDimensionsCount() const override;
 
    virtual shared_ptr<Material> getMaterial(const Vec<dim, double>& p) const;
 
    virtual shared_ptr<GeometryObjectD<dim>> getChild() const = 0;
 
    virtual shared_ptr<GeometryObjectD<dim>> getChildUnsafe() const = 0;
 
    const typename Primitive<dim>::Box& getChildBoundingBox() const { return cachedBoundingBox; }
 
    bool hasInSubtree(const GeometryObject& el) const override { return getChild()->hasInSubtree(el); }
 
    bool hasInSubtree(shared_ptr<const GeometryObject> el, const PathHints* pathHints) const {
        return getChild()->hasInSubtree(*el, pathHints);
    }
 
    Subtree getPathsTo(const GeometryObject& el, const PathHints* pathHints = 0) const override {
        return getChild()->getPathsTo(el, pathHints);
    }
 
    void getObjectsToVec(const Predicate& predicate,
                         std::vector<shared_ptr<const GeometryObject>>& dest,
                         const PathHints* path = 0) const override {
        return getChild()->getObjectsToVec(predicate, dest, path);
    }
 
    std::size_t getChildrenCount() const override { return getObject3D() ? 1 : 0; }
 
    shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const override {
        // if (!hasChild() || child_no > 0) throw OutOfBoundsException("geometry::getChildNo", "child_no");
        if (child_no >= getChildrenCount()) throw OutOfBoundsException("geometry::getChildNo", "child_no");
        return getObject3D();
    }
 
    std::vector<shared_ptr<const GeometryObject>> getLeafs(const PathHints* path = nullptr) const {
        return getChild()->getLeafs(path);
    }
 
    std::vector<shared_ptr<const GeometryObject>> getLeafs(const PathHints& path) const { return getChild()->getLeafs(path); }
 
    std::vector<CoordsType> getLeafsPositions(const PathHints* path = nullptr) const { return getChild()->getLeafsPositions(path); }
 
    std::vector<CoordsType> getLeafsPositions(const PathHints& path) const { return getChild()->getLeafsPositions(path); }
 
    std::vector<CoordsType> getObjectPositions(const GeometryObject& object, const PathHints* path = nullptr) const {
        return getChild()->getObjectPositions(object, path);
    }
 
    std::vector<CoordsType> getObjectPositions(const GeometryObject& object, const PathHints& path) const {
        return getChild()->getObjectPositions(object, path);
    }
 
    std::vector<CoordsType> getObjectPositions(const shared_ptr<const GeometryObject>& object,
                                               const PathHints* path = nullptr) const {
        return getChild()->getObjectPositions(*object, path);
    }
 
    std::vector<CoordsType> getObjectPositions(const shared_ptr<const GeometryObject>& object, const PathHints& path) const {
        return getChild()->getObjectPositions(*object, path);
    }
 
    std::vector<typename Primitive<DIM>::Box> getLeafsBoundingBoxes(const PathHints* path = nullptr) const {
        return getChild()->getLeafsBoundingBoxes(path);
    }
 
    std::vector<typename Primitive<DIM>::Box> getLeafsBoundingBoxes(const PathHints& path) const {
        return getChild()->getLeafsBoundingBoxes(path);
    }
 
    std::vector<typename Primitive<DIM>::Box> getObjectBoundingBoxes(const GeometryObject& object,
                                                                     const PathHints* path = nullptr) const {
        return getChild()->getObjectBoundingBoxes(object, path);
    }
 
    std::vector<typename Primitive<DIM>::Box> getObjectBoundingBoxes(const GeometryObject& object, const PathHints& path) const {
        return getChild()->getObjectBoundingBoxes(object, path);
    }
 
    std::vector<typename Primitive<DIM>::Box> getObjectBoundingBoxes(const shared_ptr<const GeometryObject>& object,
                                                                     const PathHints* path = nullptr) const {
        return getChild()->getObjectBoundingBoxes(*object, path);
    }
 
    std::vector<typename Primitive<DIM>::Box> getObjectBoundingBoxes(const shared_ptr<const GeometryObject>& object,
                                                                     const PathHints& path) const {
        return getChild()->getObjectBoundingBoxes(*object, path);
    }
 
    std::vector<shared_ptr<const GeometryObject>> getObjectsWithRole(const std::string& role) const {
        return getChild()->getObjectsWithRole(role);
    }
 
    GeometryObject::Subtree getPathsAt(const CoordsType& point, bool all = false) const {
        return getChild()->getPathsAt(wrapEdges(point), all);
    }
 
    // std::vector<shared_ptr<const GeometryObjectD<DIMS>>> extract(const Predicate& predicate, const PathHints* path =
    // 0) const {
    //     return getChild()->extract(predicate, path);
    // }
 
    // std::vector<shared_ptr<const GeometryObjectD<DIMS>>> extract(const Predicate& predicate, const PathHints& path)
    // const {
    //     return getChild()->extract(predicate, path);
    // }
 
    // std::vector<shared_ptr<const GeometryObjectD<DIMS>>> extractObject(const shared_ptr<const GeometryObjectD<DIMS>>&
    // object, const PathHints* path = 0) const {
    //     return getChild()->extractObject(*object, path);
    // }
 
    // std::vector<shared_ptr<const GeometryObjectD<DIMS>>> extractObject(const shared_ptr<const GeometryObjectD<DIMS>>&
    // object, const PathHints& path) const {
    //     return getChild()->extractObject(*object, path);
    // }
 
    inline shared_ptr<const GeometryObject> getMatchingAt(const CoordsType& point,
                                                          const Predicate& predicate,
                                                          const PathHints* path = 0) {
        return getChild()->getMatchingAt(wrapEdges(point), predicate, path);
    }
 
    inline shared_ptr<const GeometryObject> getMatchingAt(const CoordsType& point,
                                                          const Predicate& predicate,
                                                          const PathHints& path) {
        return getChild()->getMatchingAt(wrapEdges(point), predicate, path);
    }
 
    inline bool objectIncludes(const GeometryObject& object, const PathHints* path, const CoordsType& point) const {
        return getChild()->objectIncludes(object, path, wrapEdges(point));
    }
 
    inline bool objectIncludes(const GeometryObject& object, const PathHints& path, const CoordsType& point) const {
        return getChild()->objectIncludes(object, path, wrapEdges(point));
    }
 
    inline bool objectIncludes(const GeometryObject& object, const CoordsType& point) const {
        return getChild()->objectIncludes(object, wrapEdges(point));
    }
 
    inline shared_ptr<const GeometryObject> hasRoleAt(const std::string& role_name,
                                                      const CoordsType& point,
                                                      const plask::PathHints* path = 0) const {
        return getChild()->hasRoleAt(role_name, wrapEdges(point), path);
    }
 
    shared_ptr<const GeometryObject> hasRoleAt(const std::string& role_name,
                                               const CoordsType& point,
                                               const plask::PathHints& path) const {
        return getChild()->hasRoleAt(role_name, wrapEdges(point), path);
    }
 
    std::set<std::string> getRolesAt(const CoordsType& point, const plask::PathHints* path = 0) const;
 
    std::set<std::string> getRolesAt(const CoordsType& point, const plask::PathHints& path) const;
 
    void setPlanarEdges(const edge::Strategy& border_to_set) override;
 
    // /*
    //  * Get the sub/super-space of this one (automatically detected)
    //  * \param object geometry object within the geometry tree of this subspace or with this space child as its
    //  sub-tree
    //  * \param path hints specifying particular instance of the geometry object
    //  * \param copyEdges indicates whether the new space should have the same edges as this one
    //  * \return new space
    //  */
    // virtual GeometryD<DIMS>* getSubspace(const shared_ptr<GeometryObjectD<dim>>& object, const PathHints*
    // path=nullptr, bool copyEdges=false) const = 0;
 
    // /*
    //  * Get the sub/super-space of this one (automatically detected) with specified edges
    //  * \param object geometry object within the geometry tree of this subspace or with this space child as its
    //  sub-tree
    //  * \param path hints specifying particular instance of the geometry object
    //  * \param edges map of edge name to edge description
    //  * \param axesNames name of the axes for edges
    //  * \return new space
    //  */
    // virtual GeometryD<DIMS>* getSubspace(const shared_ptr<GeometryObjectD<dim>>& object, const PathHints*
    // path=nullptr,
    //                                              const std::map<std::string, std::string>& edges=null_borders,
    //                                              const AxisNames& axesNames=AxisNames("lon","tran","up")) const {
    //     GeometryD<dim>* subspace = getSubspace(object, path, false);
    //     subspace->setEdges( [&](const std::string& s) -> plask::optional<std::string> {
    //         auto b = edges.find(s);
    //         return (b != edges.end()) ? plask::optional<std::string>(b->second) : plask::optional<std::string>();
    //     }, axesNames);
    //     return subspace;
    // }
 
    virtual CoordsType wrapEdges(CoordsType p) const = 0;
 
    void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const override;
};
 
template <> inline void GeometryD<2>::setPlanarEdges(const edge::Strategy& border_to_set) {
    setEdges(DIRECTION_TRAN, border_to_set);
}
 
template <> inline void GeometryD<3>::setPlanarEdges(const edge::Strategy& border_to_set) {
    setEdges(DIRECTION_LONG, border_to_set);
    setEdges(DIRECTION_TRAN, border_to_set);
}
 
template <> void GeometryD<2>::writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const;
template <> void GeometryD<3>::writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const;
 
PLASK_API_EXTERN_TEMPLATE_CLASS(GeometryD<2>)
PLASK_API_EXTERN_TEMPLATE_CLASS(GeometryD<3>)
 
 
class PLASK_API Geometry2DCartesian : public GeometryD<2> {
    shared_ptr<Extrusion> extrusion;
 
    edge::StrategyPairHolder<Primitive<2>::DIRECTION_TRAN> leftright;
    edge::StrategyPairHolder<Primitive<2>::DIRECTION_VERT> bottomup;
 
    shared_ptr<Material> frontMaterial;
    shared_ptr<Material> backMaterial;
 
  public:
    static constexpr const char* NAME = "cartesian" PLASK_GEOMETRY_TYPE_NAME_SUFFIX_2D;
 
    std::string getTypeName() const override { return NAME; }
 
    void setLeftEdge(const edge::Strategy& newValue) {
        leftright.setLo(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getLeftEdge() { return leftright.getLo(); }
 
    void setRightEdge(const edge::Strategy& newValue) {
        leftright.setHi(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getRightEdge() { return leftright.getHi(); }
 
    void setBottomEdge(const edge::Strategy& newValue) {
        bottomup.setLo(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getBottomEdge() { return bottomup.getLo(); }
 
    void setTopEdge(const edge::Strategy& newValue) {
        bottomup.setHi(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getTopEdge() { return bottomup.getHi(); }
 
    void setEdges(Direction direction, const edge::Strategy& border_lo, const edge::Strategy& border_hi) override;
 
    void setEdge(Direction direction, bool higher, const edge::Strategy& border_to_set) override;
 
    const edge::Strategy& getEdge(Direction direction, bool higher) const override;
 
    void setFrontMaterial(const shared_ptr<Material> material) {
        frontMaterial = material;
        fireChanged(Event::EVENT_EDGES);
    }
 
    shared_ptr<Material> getFrontMaterial() const { return frontMaterial ? frontMaterial : defaultMaterial; }
 
    void setBackMaterial(const shared_ptr<Material> material) {
        backMaterial = material;
        fireChanged(Event::EVENT_EDGES);
    }
 
    shared_ptr<Material> getBackMaterial() const { return backMaterial ? backMaterial : defaultMaterial; }
 
    explicit Geometry2DCartesian(shared_ptr<Extrusion> extrusion = shared_ptr<Extrusion>());
 
    Geometry2DCartesian(shared_ptr<GeometryObjectD<2>> childGeometry, double length);
 
    shared_ptr<GeometryObjectD<2>> getChild() const override;
 
    shared_ptr<GeometryObjectD<2>> getChildUnsafe() const override;
 
    void removeAtUnsafe(std::size_t) override { extrusion->setChildUnsafe(shared_ptr<GeometryObjectD<2>>()); }
 
    shared_ptr<Material> getMaterial(const Vec<2, double>& p) const override;
 
    shared_ptr<Extrusion> getExtrusion() const { return extrusion; }
 
    shared_ptr<GeometryObjectD<3>> getObject3D() const override { return extrusion; }
 
    void setExtrusion(shared_ptr<Extrusion> extrusion);
 
    //     virtual Geometry2DCartesian* getSubspace(const shared_ptr<GeometryObjectD<2>>& object, const PathHints* path
    //     = 0, bool copyEdges = false) const;
 
    //     virtual Geometry2DCartesian* getSubspace(const shared_ptr<GeometryObjectD<2>>& object, const PathHints*
    //     path=nullptr,
    //                                           const std::map<std::string, std::string>& edges=null_borders,
    //                                           const AxisNames& axesNames=AxisNames()) const {
    //         return (Geometry2DCartesian*)GeometryD<2>::getSubspace(object, path, edges, axesNames);
    //     }
 
    CoordsType wrapEdges(CoordsType p) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    shared_ptr<GeometryObject> deepCopy(std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
    void addPointsAlongToSet(std::set<double>& points, Primitive<3>::Direction direction, unsigned = 0, double = 0) const override {
        shared_ptr<GeometryObjectD<2>> child;
        try {
            child = getChild();
        } catch (const NoChildException&) {
            return;
        }
        child->addPointsAlongToSet(points, direction, max_steps, min_step_size);
    }
 
    std::set<double> getPointsAlong(Primitive<3>::Direction direction) const {
        std::set<double> points;
        addPointsAlongToSet(points, direction);
        return points;
    }
 
    void addLineSegmentsToSet(std::set<typename GeometryObjectD<2>::LineSegment>& segments) const {
        shared_ptr<GeometryObjectD<2>> child;
        try {
            child = getChild();
        } catch (const NoChildException&) {
            return;
        }
        child->addLineSegmentsToSet(segments, max_steps, min_step_size);
    }
 
    std::set<typename GeometryObjectD<2>::LineSegment> getLineSegments() const {
        std::set<typename GeometryObjectD<2>::LineSegment> segments;
        addLineSegmentsToSet(segments);
        return segments;
    }
 
    shared_ptr<const GeometryObject> changedVersion(const Changer& changer, Vec<3, double>* translation = 0) const override;
 
    void writeXML(XMLWriter::Element& parent_xml_object, WriteXMLCallback& write_cb, AxisNames axes) const override;
};
 
class PLASK_API Geometry2DCylindrical : public GeometryD<2> {
    shared_ptr<Revolution> revolution;
 
    edge::StrategyPairHolder<Primitive<2>::DIRECTION_TRAN, edge::UniversalStrategy> innerouter;
    edge::StrategyPairHolder<Primitive<2>::DIRECTION_VERT> bottomup;
 
    static void ensureBoundDirIsProper(Direction direction /*, bool hi*/) { Primitive<3>::ensureIsValid2DDirection(direction); }
 
  public:
    static constexpr const char* NAME = "cylindrical";
 
    std::string getTypeName() const override { return NAME; }
 
    void setInnerEdge(const edge::UniversalStrategy& newValue) {
        innerouter.setLo(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::UniversalStrategy& getInnerEdge() { return innerouter.getLo(); }
 
    void setOuterEdge(const edge::UniversalStrategy& newValue) {
        innerouter.setHi(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::UniversalStrategy& getOuterEdge() { return innerouter.getHi(); }
 
    void setBottomEdge(const edge::Strategy& newValue) {
        bottomup.setLo(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getBottomEdge() { return bottomup.getLo(); }
 
    void setUpEdge(const edge::Strategy& newValue) {
        bottomup.setHi(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getUpEdge() { return bottomup.getHi(); }
 
    explicit Geometry2DCylindrical(shared_ptr<Revolution> revolution = shared_ptr<Revolution>());
 
    explicit Geometry2DCylindrical(shared_ptr<GeometryObjectD<2>> childGeometry);
 
    shared_ptr<GeometryObjectD<2>> getChild() const override;
 
    shared_ptr<GeometryObjectD<2>> getChildUnsafe() const override;
 
    void removeAtUnsafe(std::size_t) override { revolution->setChildUnsafe(shared_ptr<GeometryObjectD<2>>()); }
 
    shared_ptr<Material> getMaterial(const Vec<2, double>& p) const override;
 
    shared_ptr<Revolution> getRevolution() const { return revolution; }
 
    shared_ptr<GeometryObjectD<3>> getObject3D() const override { return revolution; }
 
    void setRevolution(shared_ptr<Revolution> revolution);
 
    //     virtual Geometry2DCylindrical* getSubspace(const shared_ptr<GeometryObjectD<2>>& object, const PathHints*
    //     path = 0, bool copyEdges = false) const;
 
    //     virtual Geometry2DCylindrical* getSubspace(const shared_ptr<GeometryObjectD<2>>& object, const PathHints*
    //     path=nullptr,
    //                                             const std::map<std::string, std::string>& edges=null_borders,
    //                                             const AxisNames& axesNames=AxisNames()) const {
    //         return (Geometry2DCylindrical*)GeometryD<2>::getSubspace(object, path, edges, axesNames);
    //     }
 
    void setEdges(Direction direction, const edge::Strategy& border_lo, const edge::Strategy& border_hi) override;
 
    void setEdges(Direction direction, const edge::Strategy& border_to_set) override;
 
    void setEdge(Direction direction, bool higher, const edge::Strategy& border_to_set) override;
 
    const edge::Strategy& getEdge(Direction direction, bool higher) const override;
 
    bool isSymmetric(Direction direction) const override {
        if (direction == DIRECTION_TRAN) return true;
        return getEdge(direction, false).type() == edge::Strategy::MIRROR ||
               getEdge(direction, true).type() == edge::Strategy::MIRROR;
    }
 
    CoordsType wrapEdges(CoordsType p) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    shared_ptr<GeometryObject> deepCopy(std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
    void addPointsAlongToSet(std::set<double>& points, Primitive<3>::Direction direction, unsigned = 0, double = 0) const override {
        shared_ptr<GeometryObjectD<2>> child;
        try {
            child = getChild();
        } catch (const NoChildException&) {
            return;
        }
        child->addPointsAlongToSet(points, direction, max_steps, min_step_size);
    }
 
    std::set<double> getPointsAlong(Primitive<3>::Direction direction) const {
        std::set<double> points;
        addPointsAlongToSet(points, direction);
        return points;
    }
 
    void addLineSegmentsToSet(std::set<typename GeometryObjectD<2>::LineSegment>& segments) const {
        shared_ptr<GeometryObjectD<2>> child;
        try {
            child = getChild();
        } catch (const NoChildException&) {
            return;
        }
        child->addLineSegmentsToSet(segments, max_steps, min_step_size);
    }
 
    std::set<typename GeometryObjectD<2>::LineSegment> getLineSegments() const {
        std::set<typename GeometryObjectD<2>::LineSegment> segments;
        addLineSegmentsToSet(segments);
        return segments;
    }
 
    shared_ptr<const GeometryObject> changedVersion(const Changer& changer, Vec<3, double>* translation = 0) const override;
 
    void writeXML(XMLWriter::Element& parent_xml_object, WriteXMLCallback& write_cb, AxisNames axes) const override;
 
  protected:
    const char* alternativeDirectionName(std::size_t ax, std::size_t orient) const override {
        const char* directions[3][2] = {{"cw", "ccw"}, {"inner", "outer"}, {"bottom", "top"}};
        return directions[ax][orient];
    }
};
 
class PLASK_API Geometry3D : public GeometryD<3> {
    shared_ptr<GeometryObjectD<3>> child;
 
    edge::StrategyPairHolder<Primitive<3>::DIRECTION_LONG> backfront;
    edge::StrategyPairHolder<Primitive<3>::DIRECTION_TRAN> leftright;
    edge::StrategyPairHolder<Primitive<3>::DIRECTION_VERT> bottomup;
 
  public:
    static constexpr const char* NAME = "cartesian" PLASK_GEOMETRY_TYPE_NAME_SUFFIX_3D;
 
    std::string getTypeName() const override { return NAME; }
 
    void setLeftEdge(const edge::Strategy& newValue) {
        leftright.setLo(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getLeftEdge() { return leftright.getLo(); }
 
    void setRightEdge(const edge::Strategy& newValue) {
        leftright.setHi(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getRightEdge() { return leftright.getHi(); }
 
    void setBottomEdge(const edge::Strategy& newValue) {
        bottomup.setLo(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getBottomEdge() { return bottomup.getLo(); }
 
    void setTopEdge(const edge::Strategy& newValue) {
        bottomup.setHi(newValue);
        fireChanged(Event::EVENT_EDGES);
    }
 
    const edge::Strategy& getTopEdge() { return bottomup.getHi(); }
 
    void setEdges(Direction direction, const edge::Strategy& border_lo, const edge::Strategy& border_hi) override;
 
    void setEdges(Direction direction, const edge::Strategy& border_to_set) override;
 
    void setEdge(Direction direction, bool higher, const edge::Strategy& border_to_set) override;
 
    const edge::Strategy& getEdge(Direction direction, bool higher) const override;
 
    explicit Geometry3D(shared_ptr<GeometryObjectD<3>> child = shared_ptr<GeometryObjectD<3>>());
 
    shared_ptr<GeometryObjectD<3>> getChild() const override;
 
    shared_ptr<GeometryObjectD<3>> getChildUnsafe() const override;
 
    void setChildUnsafe(shared_ptr<GeometryObjectD<3>> child) {
        if (child == this->child) return;
        this->child = child;
        this->initNewChild();
    }
 
    void setChild(shared_ptr<GeometryObjectD<3>> child) {
        // this->ensureCanHaveAsChild(*child);
        setChildUnsafe(child);
        fireChildrenChanged();
    }
 
    bool hasChild() const { return this->child != nullptr; }
 
    void removeAtUnsafe(std::size_t) override { setChildUnsafe(shared_ptr<GeometryObjectD<3>>()); }
 
    shared_ptr<GeometryObjectD<3>> getObject3D() const override;
 
    shared_ptr<Material> getMaterial(const Vec<3, double>& p) const override;
 
    CoordsType wrapEdges(CoordsType p) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    shared_ptr<GeometryObject> deepCopy(std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
    void addPointsAlongToSet(std::set<double>& points, Primitive<3>::Direction direction, unsigned = 0, double = 0) const override {
        shared_ptr<GeometryObjectD<3>> child;
        try {
            child = getChild();
        } catch (const NoChildException&) {
            return;
        }
        child->addPointsAlongToSet(points, direction, max_steps, min_step_size);
    }
 
    std::set<double> getPointsAlong(Primitive<3>::Direction direction) const {
        std::set<double> points;
        addPointsAlongToSet(points, direction);
        return points;
    }
 
    void addLineSegmentsToSet(std::set<typename GeometryObjectD<3>::LineSegment>& segments) const {
        shared_ptr<GeometryObjectD<3>> child;
        try {
            child = getChild();
        } catch (const NoChildException&) {
            return;
        }
        child->addLineSegmentsToSet(segments, max_steps, min_step_size);
    }
 
    std::set<typename GeometryObjectD<3>::LineSegment> getLineSegments() const {
        std::set<typename GeometryObjectD<3>::LineSegment> segments;
        addLineSegmentsToSet(segments);
        return segments;
    }
 
    shared_ptr<const GeometryObject> changedVersion(const Changer& changer, Vec<3, double>* translation = 0) const override;
 
    //     virtual Geometry3D* getSubspace(const shared_ptr<GeometryObjectD<3>>& object, const PathHints* path=nullptr,
    //     bool copyEdges=false) const;
};
 
}  // namespace plask
 
#endif  // PLASK__CALCULATION_SPACE_H