politopixAPI.h

Go to the documentation of this file.

// politopix allows to make computations on polytopes such as finding vertices, intersecting, Minkowski sums, ...
//     Copyright (C) 2014-2020 : Delos Vincent
//
//     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, either version 3 of the License, or
//     (at your option) any later version.
//
//     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.
//
//     You should have received a copy of the GNU General Public License
//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// I2M (UMR CNRS 5295 / University of Bordeaux)
 
#ifndef INC_polAPI
#define INC_polAPI
 
#include "polito_Export.h"
#include "Rn.h"
#include "Voronoi_Rn.h"
#include "Polytope_Rn.h"
#include "IO_Polytope.h"
#include "Generator_Rn.h"
#include "HalfSpace_Rn.h"
#include "VolumeOfPolytopes_Rn.h"
#include "DoubleDescription_Rn.h"
#include "PolyhedralAlgorithms_Rn.h"
#include "GeometricObjectIterator_Rn.h"
 
using namespace std;
 
#define TEST_OK 0
#define TEST_KO -1
 
class politopixAPI {
 
 public:
 
  static polito_EXPORT int savePolytope(const string& pathA, boost::shared_ptr<Polytope_Rn>& A);
 
  static polito_EXPORT int savePolyhedralCone(const string& pathA, boost::shared_ptr<PolyhedralCone_Rn>& A);
 
  static polito_EXPORT int loadPolytope(const string& pathA, boost::shared_ptr<Polytope_Rn>& A);
 
  static polito_EXPORT int loadPolyhedralCone(const string& pathA, boost::shared_ptr<PolyhedralCone_Rn>& A);
 
  static polito_EXPORT int addHalfspace(boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<HalfSpace_Rn>& HS);
 
  static polito_EXPORT int addGenerator(boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Generator_Rn>& GN);
 
  static polito_EXPORT int computeDoubleDescription(boost::shared_ptr<Polytope_Rn>& A, double bb_size);
 
  static polito_EXPORT int computeDoubleDescription(boost::shared_ptr<Polytope_Rn>& A) { return computeDoubleDescription(A,1000.); }
 
  static polito_EXPORT int computeDoubleDescriptionWithoutCheck(boost::shared_ptr<Polytope_Rn>& A, double bb_size=1000.);
 
  static polito_EXPORT int computeIntersection(const boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Polytope_Rn>& B, boost::shared_ptr<Polytope_Rn>& C);
 
  static polito_EXPORT int computeIntersection(boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Polytope_Rn>& B);
 
  static polito_EXPORT int computeIntersectionWithoutCheck(boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Polytope_Rn>& B);
 
  static polito_EXPORT bool isIncluded(const boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Polytope_Rn>& B);
 
  static polito_EXPORT int computeMinkowskiSumOfPolytopes(const boost::shared_ptr<Polytope_Rn>& A,const boost::shared_ptr<Polytope_Rn>& B, boost::shared_ptr<Polytope_Rn>& C);
 
  static polito_EXPORT int computeMinkowskiSumOfPolytopes(const std::vector< boost::shared_ptr<Polytope_Rn> >& arrayOfPol, boost::shared_ptr<Polytope_Rn>& C);
 
  static polito_EXPORT int computeMinkowskiSumOfPolytopes(const boost::shared_ptr<Polytope_Rn>& A,
      const boost::shared_ptr<Polytope_Rn>& B,
      boost::shared_ptr<Polytope_Rn>& C,
      const std::vector< std::vector<int> >& genitorsOfGeneratorsA,
      const std::vector< std::vector<int> >& genitorsOfGeneratorsB,
      std::vector< std::vector<int> >& traceGenerators);
 
  static polito_EXPORT int checkEqualityOfPolytopes(const boost::shared_ptr<Polytope_Rn>& A,const boost::shared_ptr<Polytope_Rn>& B, bool getFaceMapping=false);
 
  static polito_EXPORT bool checkEqualityOfVertices(const boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Polytope_Rn>& B);
 
  static polito_EXPORT int checkTopologyAndGeometry(const boost::shared_ptr<PolyhedralCone_Rn>& A, bool check_all=false);
 
  static polito_EXPORT int makeCube(boost::shared_ptr<Polytope_Rn>& A, double M);
 
  static polito_EXPORT int makeBox(boost::shared_ptr<Polytope_Rn>& A, Point_Rn Pmin, Point_Rn Pmax);
 
  static polito_EXPORT int PolarPolytope(const boost::shared_ptr<Polytope_Rn>& original_pol, boost::shared_ptr<Polytope_Rn>& polar_pol);
 
  static polito_EXPORT int Translate(boost::shared_ptr<Polytope_Rn>& pol, const boost::numeric::ublas::vector<double>& v2t);
 
  static polito_EXPORT double computeVolume(const boost::shared_ptr<Polytope_Rn> P);
 
  static polito_EXPORT int pseudoIntersection(
     const boost::shared_ptr<Polytope_Rn>& A,
     const boost::shared_ptr<Polytope_Rn>& B,
     boost::shared_ptr<Polytope_Rn>& C,
     const std::set< unsigned int >& firstOperandCaps,
     const std::set< unsigned int >& secondOperandCaps,
     std::set< unsigned int >& newCaps,
     double bb_size=1000.);
 
  static polito_EXPORT int pseudoSum(
     const boost::shared_ptr<Polytope_Rn>& A,
     const boost::shared_ptr<Polytope_Rn>& B,
     boost::shared_ptr<Polytope_Rn>& C,
     const std::set< unsigned int >& firstOperandCaps,
     const std::set< unsigned int >& secondOperandCaps,
     std::set< unsigned int >& newCaps,
     double bb_size=1000.);
 
  static polito_EXPORT int computeVoronoiDiagram(
     const boost::shared_ptr<Polytope_Rn>& inputSpace,
     const std::vector<Point_Rn>& listOfSeeds,
     std::vector< boost::shared_ptr<Polytope_Rn> >& VoronoiCells,
     Voronoi_Rn::TypeOfAlgorithm vorAlgo=Voronoi_Rn::Incremental);
 
};
 
template<class T> class PolyhedralBody {
 
 public:
 
  static int sum(const boost::shared_ptr<T>& firstBody, const boost::shared_ptr<T>& secondBody, boost::shared_ptr<T>& result) {
    result = firstBody->sum(secondBody); return TEST_OK;
  }
 
  static int sum(const std::vector< boost::shared_ptr<T> >& allBodies, boost::shared_ptr<T>& result) {
    result->sum(allBodies); return TEST_OK;
  }
 
  static int intersect(const boost::shared_ptr<T>& firstBody, const boost::shared_ptr<T>& secondBody, boost::shared_ptr<T>& result) {
    result = firstBody->intersect(secondBody); return TEST_OK;
  }
 
  static int intersect(const std::vector< boost::shared_ptr<T> >& allBodies, boost::shared_ptr<T>& result) {
    result->intersect(allBodies); return TEST_OK;
  }
 
  static bool isIncluded(const boost::shared_ptr<T>& firstBody, const boost::shared_ptr<T>& secondBody) {
    return firstBody->isIncluded(secondBody);
  }
 
  static bool isIncluded(const boost::shared_ptr<T>& firstBody, const boost::shared_ptr<T>& secondBody, double& minmaxDistance) {
    return firstBody->isIncluded(secondBody, minmaxDistance);
  }
 
  static void resetConstantsOfAllHalfSpaces(boost::shared_ptr<T>& body, double cst) {
    body->resetConstantsOfAllHalfSpaces(cst);
  }
 
  static int scalingFactor(boost::shared_ptr<T>& body, double factor) {
    return body->scalingFactor(factor);
  }
 
  static bool checkTopologyAndGeometry(const boost::shared_ptr<T>& body) {
    return body->checkTopologyAndGeometry();
  }
 
  static std::string getName() {
    return T::getName();
  }
 
  static std::string getFileExtension() {
    return T::getFileExtension();
  }
 
  static void save(const std::string& pathA, boost::shared_ptr<T>& body) {
    body->save(pathA);
  }
 
  static void load(const std::string& pathA, boost::shared_ptr<T>& body, double bb_size=10000.) {
    body->load(pathA, bb_size);
  }
 
  static void dump(std::ostream &current_ostream, boost::shared_ptr<T>& body) {
    body->dump(current_ostream);
  }
 
};
 
 
#endif // INC_polAPI