Boundary.h

Go to the documentation of this file.

#ifndef PMPL_BOUNDARY_H_
#define PMPL_BOUNDARY_H_
 
#include <cstddef>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "Vector.h"
using namespace mathtool;
 
#include "Range.h"
#include "Utilities/IOUtils.h"
 
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/Polyhedron_incremental_builder_3.h>
 
class Cfg;
class GMSPolyhedron;
class XMLNode;
 
 
class Boundary {
 
  public:
 
 
    enum Space {Workspace, CSpace};
 
 
    virtual ~Boundary() noexcept;
 
    static std::unique_ptr<Boundary> Factory(XMLNode& _node);
 
    virtual std::unique_ptr<Boundary> Clone() const = 0;
 
 
    virtual Space Type() const noexcept = 0;
 
    virtual std::string Name() const noexcept = 0;
 
    virtual size_t GetDimension() const noexcept = 0;
 
    virtual double GetMaxDist(const double _r1 = 2., const double _r2 = .5)
        const = 0;
 
    virtual const Range<double>& GetRange(const size_t _i) const = 0;
 
    virtual const std::vector<double>& GetCenter() const noexcept = 0;
 
    virtual double GetVolume() const noexcept = 0;
 
 
    virtual std::vector<double> GetRandomPoint() const = 0;
 
    virtual void PushInside(std::vector<double>& _point) const noexcept = 0;
 
 
    virtual void ScalePoint(std::vector<double>& _point) const noexcept;
 
    virtual void UnscalePoint(std::vector<double>& _point) const noexcept;
 
 
    virtual bool InBoundary(const Vector3d& _p) const;
 
    virtual bool InBoundary(const std::vector<double>& _v) const = 0;
 
    virtual bool InBoundary(const Cfg& _c) const = 0;
 
 
    virtual double GetClearance(const Vector3d& _p) const = 0;
 
    virtual Vector3d GetClearancePoint(const Vector3d& _p) const = 0;
 
 
    virtual void SetCenter(const std::vector<double>& _c) noexcept = 0;
 
    virtual void Translate(const Vector3d& _v) = 0;
 
    virtual void Translate(const std::vector<double>& _t) = 0;
 
    virtual void ResetBoundary(const std::vector<std::pair<double, double>>& _bbx,
        const double _margin) = 0;
 
 
    virtual void Read(std::istream& _is, CountingStreamBuffer& _cbs) = 0;
 
    virtual void Write(std::ostream& _os) const = 0;
 
 
    typedef CGAL::Exact_predicates_exact_constructions_kernel CGALKernel;
    typedef CGAL::Polyhedron_3<CGALKernel> CGALPolyhedron;
 
    virtual CGALPolyhedron CGAL() const;
 
    virtual GMSPolyhedron MakePolyhedron() const;
 
 
  protected:
 
 
    bool InWorkspace(const Cfg& _c) const;
 
    bool InCSpace(const Cfg& _c) const;
 
 
#ifdef _PARALLEL
  public:
 
    void define_type(stapl::typer&) { }
#endif
 
};
 
/*----------------------------------- I/O ------------------------------------*/
 
std::ostream& operator<<(std::ostream& _os, const Boundary& _b);
 
//std::istream& operator>>(std::istream& _is, const Boundary& _b);
 
/*----------------------------------------------------------------------------*/
 
#endif