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-2017 : Delos Vincent
//
//     This program is free software: you can redistribute it and/or modify
//     it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
//
//     You should have received a copy of the GNU Lesser 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)  throw (ios_base::failure);

  static polito_EXPORT int savePolyhedralCone(const string& pathA, boost::shared_ptr<PolyhedralCone_Rn>& A)  throw (ios_base::failure);

  static polito_EXPORT int loadPolytope(const string& pathA, boost::shared_ptr<Polytope_Rn>& A)  throw (ios_base::failure);

  static polito_EXPORT int loadPolyhedralCone(const string& pathA, boost::shared_ptr<PolyhedralCone_Rn>& A)  throw (ios_base::failure);

  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=1000.) 
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT int computeDoubleDescriptionWithoutCheck(boost::shared_ptr<Polytope_Rn>& A, double bb_size=1000.) 
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  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)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT int computeIntersection(boost::shared_ptr<Polytope_Rn>& A, const boost::shared_ptr<Polytope_Rn>& B)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT int computeIntersectionWithoutCheck(boost::shared_ptr<Polytope_Rn>& A,
                                                           const boost::shared_ptr<Polytope_Rn>& B) 
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT bool isIncluded(const boost::shared_ptr<Polytope_Rn>& A,
      const boost::shared_ptr<Polytope_Rn>& B)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  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)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT int computeMinkowskiSumOfPolytopes(
      const std::vector< boost::shared_ptr<Polytope_Rn> >& arrayOfPol,
      boost::shared_ptr<Polytope_Rn>& C)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  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)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT int checkEqualityOfPolytopes(const boost::shared_ptr<Polytope_Rn>& A,
      const boost::shared_ptr<Polytope_Rn>& B,
      bool getFaceMapping=false)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT bool checkEqualityOfVertices(const boost::shared_ptr<Polytope_Rn>& A,
      const boost::shared_ptr<Polytope_Rn>& B)
    throw (invalid_argument, out_of_range, ios_base::failure, logic_error);

  static polito_EXPORT int checkTopologyAndGeometry(const boost::shared_ptr<PolyhedralCone_Rn>& A);

  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)
    throw (invalid_argument, out_of_range, ios_base::failure);

  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.) throw (invalid_argument,out_of_range,ios_base::failure,logic_error);

  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.) throw (invalid_argument,out_of_range,ios_base::failure,logic_error);

  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) throw (std::invalid_argument);


};

#endif // INC_polAPI