Constraint.h

Go to the documentation of this file.

// This file is part of ShapeOp, a lightweight C++ library
// for static and dynamic geometry processing.
//
// Copyright (C) 2014 Sofien Bouaziz <sofien.bouaziz@gmail.com>, Bailin Deng <bailin.deng@epfl.ch>, Mario Deuss <mario.deuss@epfl.ch>
// Copyright (C) 2014 LGG EPFL
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef CONSTRAINT_H
#define CONSTRAINT_H
#include "Types.h"
#include <memory>
#include <cmath>

#ifndef M_PI

#define M_PI 3.14159265358979323846
#endif

namespace ShapeOp {

class SHAPEOP_API Constraint {
 public:
  static std::shared_ptr<Constraint> shapeConstraintFactory(const std::string &ConstraintType, const std::vector<int> &idI, Scalar weight, const Matrix3X &positions);
  Constraint(const std::vector<int> &idI, Scalar weight);
  virtual ~Constraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const = 0;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const = 0;
  std::size_t nIndices() const { return idI_.size(); }
 protected:
  std::vector<int> idI_;
  Scalar weight_;
  mutable int idO_;
};

class SHAPEOP_API EdgeStrainConstraint : public Constraint {
 public:
  EdgeStrainConstraint(const std::vector<int> &idI,
                       Scalar weight,
                       const Matrix3X &positions,
                       Scalar rangeMin = 1.0,
                       Scalar rangeMax = 1.0);
  virtual ~EdgeStrainConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setEdgeLength(Scalar length);
  void setRangeMin(Scalar rMin) { rangeMin_ = rMin; }
  void setRangeMax(Scalar rMax) { rangeMax_ = rMax; }
 private:
  Scalar rest_;
  Scalar rangeMin_;
  Scalar rangeMax_;
};

class SHAPEOP_API TriangleStrainConstraint : public Constraint {
 public:
  TriangleStrainConstraint(const std::vector<int> &idI,
                           Scalar weight,
                           const Matrix3X &positions,
                           Scalar rangeMin = 1.0,
                           Scalar rangeMax = 1.0);
  virtual ~TriangleStrainConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setRangeMin(Scalar rMin) { rangeMin_ = rMin; }
  void setRangeMax(Scalar rMax) { rangeMax_ = rMax; }
 private:
  Matrix22 rest_;
  Scalar rangeMin_;
  Scalar rangeMax_;
};

class SHAPEOP_API TetrahedronStrainConstraint : public Constraint {
 public:
  TetrahedronStrainConstraint(const std::vector<int> &idI,
                              Scalar weight,
                              const Matrix3X &positions,
                              Scalar rangeMin = 1.0,
                              Scalar rangeMax = 1.0);
  virtual ~TetrahedronStrainConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setRangeMin(Scalar rMin) { rangeMin_ = rMin; }
  void setRangeMax(Scalar rMax) { rangeMax_ = rMax; }
 private:
  Matrix33 rest_;
  Scalar rangeMin_;
  Scalar rangeMax_;
};

class SHAPEOP_API AreaConstraint : public Constraint {
 public:
  AreaConstraint(const std::vector<int> &idI,
                 Scalar weight,
                 const Matrix3X &positions,
                 Scalar rangeMin = 1.0,
                 Scalar rangeMax = 1.0);
  virtual ~AreaConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setRangeMin(Scalar rMin) { rangeMin_ = rMin; }
  void setRangeMax(Scalar rMax) { rangeMax_ = rMax; }
 private:
  Matrix22 rest_;
  Scalar rangeMin_;
  Scalar rangeMax_;
};

class SHAPEOP_API VolumeConstraint : public Constraint {
 public:
  VolumeConstraint(const std::vector<int> &idI,
                   Scalar weight,
                   const Matrix3X &positions,
                   Scalar rangeMin = 1.0,
                   Scalar rangeMax = 1.0);
  virtual ~VolumeConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setRangeMin(Scalar rMin) { rangeMin_ = rMin; }
  void setRangeMax(Scalar rMax) { rangeMax_ = rMax; }
 private:
  Matrix33 rest_;
  Scalar rangeMin_;
  Scalar rangeMax_;
};

class SHAPEOP_API BendingConstraint : public Constraint {
 public:
  BendingConstraint(const std::vector<int> &idI,
                    Scalar weight,
                    const Matrix3X &positions,
                    Scalar rangeMin = 1.0,
                    Scalar rangeMax = 1.0);
  virtual ~BendingConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setRangeMin(Scalar rMin) { rangeMin_ = rMin; }
  void setRangeMax(Scalar rMax) { rangeMax_ = rMax; }
 private:
  VectorX w_;
  Scalar n_;
  Scalar rangeMin_;
  Scalar rangeMax_;
};

class SHAPEOP_API ClosenessConstraint : public Constraint {
 public:
  ClosenessConstraint(const std::vector<int> &idI,
                      Scalar weight,
                      const Matrix3X &positions);
  virtual ~ClosenessConstraint() {}
  virtual void project(const Matrix3X & /*positions*/, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setPosition(const Vector3 &position);
  Vector3 getPosition() const;
 private:
  Vector3 rest_;
};

class SHAPEOP_API LineConstraint : public Constraint {
 public:
  LineConstraint(const std::vector<int> &idI,
                 Scalar weight,
                 const Matrix3X &positions);
  virtual ~LineConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
 private:
  mutable Matrix3X input;
};

class SHAPEOP_API PlaneConstraint : public Constraint {
 public:
  PlaneConstraint(const std::vector<int> &idI,
                  Scalar weight,
                  const Matrix3X &positions);
  virtual ~PlaneConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
 private:
  mutable Matrix3X input;
};

class SHAPEOP_API CircleConstraint : public Constraint {
 public:
  CircleConstraint(const std::vector<int> &idI,
                   Scalar weight,
                   const Matrix3X &positions);
  virtual ~CircleConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
 private:
  mutable Matrix3X input;
};

class SHAPEOP_API SphereConstraint : public Constraint {
 public:
  SphereConstraint(const std::vector<int> &idI,
                   Scalar weight,
                   const Matrix3X &positions);
  virtual ~SphereConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
 private:
  mutable Matrix3X input;
};

class SHAPEOP_API SimilarityConstraint : public Constraint {
 public:
  SimilarityConstraint(const std::vector<int> &idI,
                       Scalar weight,
                       const Matrix3X &positions,
                       bool scaling = true,
                       bool rotate = true,
                       bool flip = true);
  virtual ~SimilarityConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setShapes( const std::vector<Matrix3X> &shapes );
 private:
  void testCandidates(Scalar &min_error) const;
  mutable Matrix3X input;
  mutable Matrix3X candidate;
  mutable Matrix3X output;
  std::vector<Matrix3X>  shapes_;
  bool scaling_;
  bool rotate_;
  bool flip_;
  mutable Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic> permutation_;
  Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic> rotateMatrix_;
  Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic> flipMatrix_;
};

class SHAPEOP_API RectangleConstraint : public Constraint {
 public:
  RectangleConstraint(const std::vector<int> &idI,
                      Scalar weight,
                      const Matrix3X &positions);
  virtual ~RectangleConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
};

class SHAPEOP_API ParallelogramConstraint : public Constraint {
 public:
  ParallelogramConstraint(const std::vector<int> &idI,
                          Scalar weight,
                          const Matrix3X &positions);
  virtual ~ParallelogramConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
 private:
  MatrixT<8, 8> parallelogramMatrix;
};

class SHAPEOP_API UniformLaplacianConstraint : public Constraint {
 public:
  UniformLaplacianConstraint(const std::vector<int> &idI,
                             Scalar weight,
                             const Matrix3X &positions,
                             bool displacement_lap);
  virtual ~UniformLaplacianConstraint() {}
  virtual void project(const Matrix3X & /*positions*/, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
 private:
  Vector3 weighted_rest_;
};

class SHAPEOP_API AngleConstraint : public Constraint {
 public:
  AngleConstraint(const std::vector<int> &idI,
                  Scalar weight,
                  const Matrix3X &positions,
                  Scalar minAngle = 0.0,
                  Scalar maxAngle = M_PI);
  virtual ~AngleConstraint() {}
  virtual void project(const Matrix3X &positions, Matrix3X &projections) const override final;
  virtual void addConstraint(std::vector<Triplet> &triplets, int &idO) const override final;
  void setMinAngle(Scalar minAngle);
  void setMaxAngle(Scalar maxAngle);
 private:
  Scalar minAngle_;
  Scalar maxAngle_;
  Scalar minAngleCos_;
  Scalar maxAngleCos_;
};
} // namespace ShapeOp
#ifdef SHAPEOP_HEADER_ONLY
#include "Constraint.cpp"
#endif
#endif // CONSTRAINT_H

---

Generated on Thu Apr 2 2015 02:37:05 for ShapeOp by   1.8.9.1