stack.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_STACK_H
#define PLASK__GEOMETRY_STACK_H
 
#include "primitives.hpp"
#include "container.hpp"
#include <deque>
 
namespace plask {
 
template <int dim, typename Primitive<dim>::Direction growingDirection = Primitive<dim>::DIRECTION_VERT>
struct PLASK_API StackContainerBaseImpl: public GeometryObjectContainer<dim> {
 
    typedef GeometryObjectContainer<dim> BaseClass;
 
    static constexpr typename Primitive<dim>::Direction GROWING_DIR = growingDirection;
 
    typedef typename BaseClass::DVec DVec;
 
    typedef typename BaseClass::Box Box;
 
    typedef typename BaseClass::ChildType ChildType;
 
    typedef typename BaseClass::TranslationT TranslationT;
 
    typedef typename BaseClass::TranslationVector TranslationVector;
 
    using BaseClass::children;
 
    explicit StackContainerBaseImpl(const double baseHeight = 0.0) {
        stackHeights.push_back(baseHeight);
    }
 
    double getBaseHeight() const { return stackHeights.front(); }
 
    void setBaseHeight(double newBaseHeight);
 
    void setZeroBefore(std::size_t index);
 
    void setZeroBefore(const shared_ptr<ChildType>& object, const PathHints* path = 0) {
        setZeroBefore(this->getChildIndex(object, path));
    }
 
    void setZeroBefore(const shared_ptr<ChildType>& object, const PathHints& path) {
        setZeroBefore(this->getChildIndex(object, path));
    }
 
    void alignZeroOn(std::size_t index, double pos = 0.);
 
    void alignZeroOn(const shared_ptr<ChildType>& object, const PathHints* path = 0, double pos = 0.) {
        alignZeroOn(this->getChildIndex(object, path), pos);
    }
 
    void alignZeroOn(const shared_ptr<ChildType>& object, const PathHints& path, double pos = 0.) {
        alignZeroOn(this->getChildIndex(object, path), pos);
    }
 
    std::size_t getInsertionIndexForHeight(double height) const;
 
    const shared_ptr<TranslationT> getChildForHeight(double height, shared_ptr<TranslationT>& sec_candidate) const;
 
    const shared_ptr<TranslationT> getChildForHeight(double height) const {
        shared_ptr<TranslationT> to_ignore;
        return getChildForHeight(height, to_ignore);
    }
 
    bool contains(const DVec& p) const override;
 
    shared_ptr<Material> getMaterial(const DVec& p) const override;
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool all=false) const override;
 
    bool removeIfTUnsafe(const std::function<bool(const shared_ptr<TranslationT>& c)>& predicate) override;
 
    void removeAtUnsafe(std::size_t index) override;
 
    void onChildChanged(const GeometryObject::Event& evt) override;
 
    double getHeight() const {
        return stackHeights.back() - stackHeights.front();
    }
 
  protected:
 
    std::vector<double> stackHeights;
 
    void calcHeight(const Box& elBoudingBox, double prev_height, double& el_translation, double& next_height) {
        el_translation = prev_height - elBoudingBox.lower[growingDirection];
        next_height = elBoudingBox.upper[growingDirection] + el_translation;
    }
 
    void calcHeight(const shared_ptr<ChildType>& el, double prev_height, double& el_translation, double& next_height) {
        calcHeight(el->getBoundingBox(), prev_height, el_translation, next_height);
    }
 
    void updateHeight(std::size_t child_index) {
        calcHeight(children[child_index]->getChild(),
                   stackHeights[child_index],
                   children[child_index]->translation[growingDirection],
                   stackHeights[child_index+1]);
    }
 
    void updateAllHeights(std::size_t first_child_index);
 
    void updateAllHeights();
 
    void rebuildStackHeights(std::size_t first_child_index = 0);
 
    void writeXMLAttr(XMLWriter::Element &dest_xml_object, const AxisNames &axes) const override;
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(StackContainerBaseImpl<2, Primitive<2>::DIRECTION_VERT>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(StackContainerBaseImpl<3, Primitive<3>::DIRECTION_VERT>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(StackContainerBaseImpl<2, Primitive<2>::DIRECTION_TRAN>)
 
struct PLASK_API ShelfContainer2D: public StackContainerBaseImpl<2, Primitive<2>::DIRECTION_TRAN> {
 
    typedef StackContainerBaseImpl<2, Primitive<2>::DIRECTION_TRAN> BaseClass;
 
    typedef typename BaseClass::ChildType ChildType;
 
    typedef typename BaseClass::TranslationT TranslationT;
 
private:
    //TODO use it, support in remove
    shared_ptr<TranslationT> resizableGap;
 
public:
 
    ShelfContainer2D(double baseH = 0.0): BaseClass(baseH) {}
 
    static const char* NAME;
 
    std::string getTypeName() const override { return NAME; }
 
    bool isFlat() const;
 
    void ensureFlat() const {
        if (!isFlat()) throw Exception("not all items in the shelf have the same height "
                                       "(correct heights or set 'flat' to false)");
    }
 
    PathHints::Hint add(const shared_ptr<ChildType> &el) {
        if (el) this->ensureCanHaveAsChild(*el);
        return addUnsafe(el);
    }
 
    PathHints::Hint addGap(double size);
 
    /*
     * Try to resize gap which have given index.
     * @param gap_index
     */
    //void resizeGap(std::size_t gap_index, double new_size);
 
    PathHints::Hint push_back(const shared_ptr<ChildType> &el) { return add(el); }
 
    PathHints::Hint addUnsafe(const shared_ptr<ChildType>& el);
 
    PathHints::Hint insertUnsafe(const shared_ptr<ChildType>& el, const std::size_t pos);
 
    PathHints::Hint insert(const shared_ptr<ChildType>& el, const std::size_t pos) {
        if (el) this->ensureCanHaveAsChild(*el);
        return insertUnsafe(el, pos);
    }
 
    PathHints::Hint push_front(const shared_ptr<ChildType>& el) {
        if (el) this->ensureCanHaveAsChild(*el);
        return insertUnsafe(el, 0);
    }
 
    shared_ptr<GeometryObject> changedVersionForChildren(std::vector<std::pair<shared_ptr<ChildType>, Vec<3, double>>>& children_after_change, Vec<3, double>* recomended_translation) const override;
 
    void writeXMLAttr(XMLWriter::Element &dest_xml_object, const AxisNames &) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    shared_ptr<GeometryObject> deepCopy(std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
};
 
template <int dim>
using StackContainerChildAligner =
    typename chooseType<dim-2, align::Aligner<Primitive<3>::DIRECTION_TRAN>, align::Aligner<Primitive<3>::DIRECTION_LONG, Primitive<3>::DIRECTION_TRAN> >::type;
 
//TODO copy constructor
//TODO remove some redundant code and use one from WithAligners
template <int dim>
struct PLASK_API StackContainer: public WithAligners< StackContainerBaseImpl<dim>, StackContainerChildAligner<dim> > {
 
    typedef StackContainerChildAligner<dim> ChildAligner;
    static const ChildAligner& DefaultAligner();
 
    typedef typename StackContainerBaseImpl<dim>::ChildType ChildType;
    typedef typename StackContainerBaseImpl<dim>::TranslationT TranslationT;
 
    typedef typename StackContainerBaseImpl<dim>::Box Box;
 
    using StackContainerBaseImpl<dim>::shared_from_this;
    using StackContainerBaseImpl<dim>::children;
    using StackContainerBaseImpl<dim>::stackHeights;
 
    static const char* NAME;
 
    std::string getTypeName() const override { return NAME; }
 
    ChildAligner default_aligner;
 
  private:
 
    typedef WithAligners< StackContainerBaseImpl<dim>, StackContainerChildAligner<dim> > ParentClass;
 
    shared_ptr<TranslationT> newTranslation(const shared_ptr<ChildType>& el, const ChildAligner& aligner, double up_trans, const Box& elBB) const;
 
    shared_ptr<TranslationT> newTranslation(const shared_ptr<ChildType>& el, const ChildAligner& aligner, double up_trans) const;
 
  public:
 
    explicit StackContainer(const double baseHeight = 0.0, const ChildAligner& aligner=DefaultAligner()):
        ParentClass(baseHeight), default_aligner(aligner) {}
 
    void onChildChanged(const GeometryObject::Event& evt) override;
 
    PathHints::Hint insertUnsafe(const shared_ptr<ChildType>& el, const std::size_t pos, const ChildAligner& aligner);
 
    PathHints::Hint insertUnsafe(const shared_ptr<ChildType>& el, const std::size_t pos) {
        return insertUnsafe(el, pos, default_aligner);
    }
 
    PathHints::Hint insert(const shared_ptr<ChildType>& el, const std::size_t pos, const ChildAligner& aligner) {
        if (el) this->ensureCanHaveAsChild(*el);
        return insertUnsafe(el, pos, aligner);
    }
 
    PathHints::Hint insert(const shared_ptr<ChildType>& el, const std::size_t pos) {
        return insert(el, pos, default_aligner);
    }
 
    PathHints::Hint addUnsafe(const shared_ptr<ChildType>& el, const ChildAligner& aligner);
 
    PathHints::Hint addUnsafe(const shared_ptr<ChildType>& el) {
        return addUnsafe(el, default_aligner);
    }
 
    PathHints::Hint add(const shared_ptr<ChildType> &el, const ChildAligner& aligner) {
        if (el) this->ensureCanHaveAsChild(*el);
        return addUnsafe(el, aligner);
    }
 
    PathHints::Hint add(const shared_ptr<ChildType>& el) {
        return add(el, default_aligner);
    }
 
    PathHints::Hint push_back(const shared_ptr<ChildType> &el, const ChildAligner& aligner) {
        return add(el, aligner);
    }
 
    PathHints::Hint push_back(const shared_ptr<ChildType> &el) {
        return push_back(el, default_aligner);
    }
 
    PathHints::Hint push_front(const shared_ptr<ChildType>& el, const ChildAligner& aligner) {
        if (el) this->ensureCanHaveAsChild(*el);
        return insertUnsafe(el, 0, aligner);
    }
 
    PathHints::Hint push_front(const shared_ptr<ChildType>& el) {
        return push_front(el, default_aligner);
    }
 
     const ChildAligner& getAlignerAt(std::size_t child_no) const {
        this->ensureIsValidChildNr(child_no, "getAlignerAt");
        return this->aligners[child_no];
    }
 
    /*
     * Set new aligner.
     * @param child_no (real) child number for which aligner will be set
     * @param aligner new aligner for given child, this pointer will be delete by this stack and it can be used only in one stack, for one child
     */
    /*void setAlignerAtMove(std::size_t child_no, Aligner* aligner) {
        this->ensureIsValidChildNr(child_no, "setAlignerAtMove");
        if (aligners[child_no] == aligner) return; //protected for self assign
        aligners[child_no] = aligner;
        aligners[child_no]->align(*children[child_no]);
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }*/
 
    bool removeIfTUnsafe(const std::function<bool(const shared_ptr<TranslationT>& c)>& predicate) override;
 
    void removeAtUnsafe(std::size_t index) override;
 
    //add in reverse order
    void writeXML(XMLWriter::Element& parent_xml_object, GeometryObject::WriteXMLCallback& write_cb, AxisNames parent_axes) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    shared_ptr<GeometryObject> deepCopy(std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
protected:
    void writeXMLChildAttr(XMLWriter::Element &dest_xml_child_tag, std::size_t child_index, const AxisNames &axes) const override;
 
    shared_ptr<GeometryObject> changedVersionForChildren(std::vector<std::pair<shared_ptr<ChildType>, Vec<3, double>>>& children_after_change, Vec<3, double>* recomended_translation) const override;
 
};
 
template <> const StackContainer<2>::ChildAligner& StackContainer<2>::DefaultAligner();
template <> const StackContainer<3>::ChildAligner& StackContainer<3>::DefaultAligner();
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(StackContainer<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(StackContainer<3>)
 
 
template <typename UpperClass>
class PLASK_API MultiStackContainer: public UpperClass {
 
    static const int DIM = UpperClass::DIM;
 
    /*
     * @param a, divider
     * @return \f$a - \floor{a / divider} * divider\f$
     */
    /*static double modulo(double a, double divider) {
        return a - static_cast<double>( static_cast<int>( a / divider ) ) * divider;
    }*/
 
  public:
    using UpperClass::getChildForHeight;
    using UpperClass::stackHeights;
    using UpperClass::children;
 
    typedef typename StackContainerBaseImpl<DIM>::ChildType ChildType;
    typedef typename StackContainerBaseImpl<DIM>::TranslationT TranslationT;
 
    typedef typename UpperClass::DVec DVec;
 
    typedef typename UpperClass::Box Box;
 
  protected:
 
    /*
     * Get number of all children.
     * @return number of all children
     */
    //std::size_t size() const { return children.size() * repeat_count; }
 
    /*
     * Get child with translation.
     * @param index index of child
     * @return child with given index
     */
    //typename UpperClass::TranslationT& operator[] (std::size_t index) { return children[index % children.size()]; }
 
    bool reduceHeight(double& height) const;
 
  public:
 
    unsigned repeat_count;
 
    template <typename... UpperCtrArgs>
    explicit MultiStackContainer(unsigned repeat_count, UpperCtrArgs&&... upperCtrArgs):
        UpperClass(std::forward<UpperCtrArgs>(upperCtrArgs)...), repeat_count(repeat_count) {}
 
    //this is not used but, just for case redefine UpperClass::getChildForHeight
    /*const shared_ptr<TranslationT> getChildForHeight(double height) const {
        if (!reduceHeight(height)) return nullptr;
        return UpperClass::getChildForHeight(height);
    }*/
 
    //TODO good but unused
    //virtual bool intersects(const Box& area) const;
 
    Box getBoundingBox() const override;
 
    Box getRealBoundingBox() const override;
 
    void getBoundingBoxesToVec(const GeometryObject::Predicate& predicate, std::vector<Box>& dest, const PathHints* path = 0) const override;
 
    void getObjectsToVec(const GeometryObject::Predicate& predicate, std::vector< shared_ptr<const GeometryObject> >& dest, const PathHints* path = 0) const override;
 
    void getPositionsToVec(const GeometryObject::Predicate& predicate, std::vector<DVec>& dest, const PathHints* path = 0) const override;
 
    // void extractToVec(const GeometryObject::Predicate &predicate, std::vector< shared_ptr<const GeometryObjectD<dim> > >& dest, const PathHints *path = 0) const;
 
    GeometryObject::Subtree getPathsTo(const GeometryObject& el, const PathHints* path = 0) const override;
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool all=false) const override;
 
    bool contains(const DVec& p) const override;
 
    shared_ptr<Material> getMaterial(const DVec& p) const override;
 
    std::size_t getChildrenCount() const override { return children.size() * repeat_count; }
 
    shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const override;
 
    std::size_t getRealChildrenCount() const override;
 
    shared_ptr<GeometryObject> getRealChildNo(std::size_t child_no) const override;
 
    unsigned getRepeatCount() const { return repeat_count; }
 
    void setRepeatCount(unsigned new_repeat_count) {
        if (repeat_count == new_repeat_count) return;
        repeat_count = new_repeat_count;
        this->fireChildrenChanged();    //TODO should this be called? or simple change?
    }
 
    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 max_steps,
                        double min_step_size) const override;
 
    void addLineSegmentsToSet(std::set<typename GeometryObjectD<UpperClass::DIM>::LineSegment>& segments,
                              unsigned max_steps,
                              double min_step_size) const override;
 
protected:
    void writeXMLAttr(XMLWriter::Element &dest_xml_object, const AxisNames &axes) const override;
 
    shared_ptr<GeometryObject> changedVersionForChildren(std::vector<std::pair<shared_ptr<ChildType>, Vec<3, double>>>& children_after_change, Vec<3, double>* recomended_translation) const override;
 
};
 
 
}   // namespace plask
 
 
#endif // STACK_H