DomainShape_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_DOMAINS_DOMAINSHAPE_FWD_HPP_
#define MEDUSA_BITS_DOMAINS_DOMAINSHAPE_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/utils/memutils.hpp>
#include <medusa/bits/types/Vec_fwd.hpp>
#include <iosfwd>
#include <utility>
#include <ostream>
#include <functional>
 
namespace mm {
 
template <class vec_t>
class deep_copy_unique_ptr;
 
template <class vec_t>
class DomainDiscretization;
 
// These must be hidden during a doxygen run due to a bug in processing forward declarations.
// See https://github.com/doxygen/doxygen/issues/8177
#ifndef DOXYGEN_RUN
template <typename vec_t>
class ShapeUnion;
 
template <typename vec_t>
class ShapeDifference;
 
template <typename vec_t>
class TranslatedShape;
 
template <typename vec_t>
class RotatedShape;
#endif
 
template <typename vec_t>
class DomainShape {
  public:
    typedef vec_t vector_t;  
    typedef typename vec_t::Scalar scalar_t;   
    enum {  dim = vec_t::dim };
 
  protected:
    scalar_t margin_;
  public:
    DomainShape() : margin_(1e-10) {}
    virtual ~DomainShape() = default;
 
    scalar_t margin() const { return margin_; }
 
    virtual void setMargin(scalar_t margin) { margin_ = margin; }
    void toggleMargin() { setMargin(-margin()); }
    ShapeUnion<vec_t> add(const DomainShape& other) const;
    ShapeUnion<vec_t> operator+(const DomainShape& other) const { return add(other); }
 
    ShapeDifference<vec_t> subtract(const DomainShape& other) const;
    ShapeDifference<vec_t> operator-(const DomainShape& other) const { return subtract(other); }
 
    virtual std::pair<bool, vec_t> projectPointToBoundary(const vec_t& point,
                                                          const vec_t& unit_normal) const;
 
    virtual bool contains(const vec_t& point) const = 0;
 
    virtual bool hasContains() const { return true; }
 
    virtual std::pair<vec_t, vec_t> bbox() const = 0;
    virtual DomainShape* clone() const = 0;
    virtual std::ostream& print(std::ostream& os) const = 0;
 
    // Two types of discretizations: uniform step and density (will possibly add random later).
 
    // STEP -- calls density by default
    virtual DomainDiscretization<vec_t> discretizeBoundaryWithStep(scalar_t step, int type) const {
        return discretizeBoundaryWithDensity([=](const vec_t&) { return step; }, type);
    }
 
    DomainDiscretization<vec_t> discretizeBoundaryWithStep(scalar_t step) const {
        return this->discretizeBoundaryWithStep(step, 0);
    }
    virtual DomainDiscretization<vec_t> discretizeWithStep(
            scalar_t step, int internal_type, int boundary_type) const {
        return discretizeWithDensity([=](const vec_t&) { return step; }, internal_type,
                                     boundary_type);
    }
 
    DomainDiscretization<vec_t> discretizeWithStep(scalar_t step) const {
        return this->discretizeWithStep(step, 0, 0);
    }
 
    // DENSITY -- calls fill engine in interior
    virtual DomainDiscretization<vec_t> discretizeWithDensity(
            const std::function<scalar_t(vec_t)>& dr, int internal_type, int boundary_type) const;
 
    template <typename func_t, typename fill_t>
    DomainDiscretization<vec_t> discretizeWithDensity(const func_t& dr, const fill_t& fill,
                                                      int internal_type, int boundary_type) const {
        DomainDiscretization<vec_t> domain = discretizeBoundaryWithDensity(dr, boundary_type);
        fill(domain, dr, internal_type);
        return domain;
    }
 
    DomainDiscretization<vec_t> discretizeWithDensity(
            const std::function<scalar_t(vec_t)>& dr) const {
        return discretizeWithDensity(dr, 0, 0);
    }
 
    template <typename func_t, typename fill_t>
    DomainDiscretization<vec_t> discretizeWithDensity(const func_t& dr, const fill_t& fill) const {
        return discretizeWithDensity(dr, fill, 0, 0);
    }
 
    virtual DomainDiscretization<vec_t> discretizeBoundaryWithDensity(
            const std::function<scalar_t(vec_t)>& dr, int type) const = 0;
 
    DomainDiscretization<vec_t> discretizeBoundaryWithDensity(
            const std::function<scalar_t(vec_t)>& dr) const {
        return this->discretizeBoundaryWithDensity(dr, 0);
    }
 
    TranslatedShape<vec_t> translate(const vec_t& a);
 
    RotatedShape<vec_t> rotate(const Eigen::Matrix<scalar_t, dim, dim>& Q);
 
    RotatedShape<vec_t> rotate(scalar_t angle);
 
    template <typename V>
    friend std::ostream& operator<<(std::ostream& os, const DomainShape<V>& shape);
};
 
template <typename V>
std::ostream& operator<<(std::ostream& os, const DomainShape<V>& shape) {
    return shape.print(os);
}
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_DOMAINS_DOMAINSHAPE_FWD_HPP_