operations.hh

Go to the documentation of this file.

//
// Copyright (c) 2016 CNRS
// Authors: Anna Seppala
//
// This file is part of hpp-affordance
// hpp-affordance 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.
//
// hpp-affordance 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 Lesser Public License for more details.  You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-affordance  If not, see
// <http://www.gnu.org/licenses/>.
 
#ifndef HPP_AFFORDANCE_OPERATIONS_HH
#define HPP_AFFORDANCE_OPERATIONS_HH
 
#include <coal/data_types.h>
 
namespace hpp {
namespace affordance {

class OperationBase {
 public:
  OperationBase()
      : zWorld_(0, 0, 1),
        margin_(0.3),
        neighbouringTriangleMargin_(0.3),
        minArea_(0.05),
        affordance_("noAffordance") {}

  explicit OperationBase(const double margin = 0.3,
                         const double nbTriMargin = 0.3,
                         const double minArea = 0.05,
                         const char* affordanceName = "noAffordance")
      : zWorld_(0, 0, 1),
        margin_(margin),
        neighbouringTriangleMargin_(nbTriMargin),
        minArea_(minArea),
        affordance_(affordanceName) {}

  virtual bool requirement(const coal::Vec3s& normal) = 0;
  const coal::Vec3s zWorld_;
  const double margin_;
  const double neighbouringTriangleMargin_;
  const double minArea_;
  const char* affordance_;
};  // class OperationBase

class SupportOperation : public OperationBase {
 public:
  explicit SupportOperation(const double margin = 0.3,
                            const double nbTriMargin = 0.3,
                            const double minArea = 0.05,
                            const char* affordanceName = "Support")
      : OperationBase(margin, nbTriMargin, minArea, affordanceName) {}

  bool requirement(const coal::Vec3s& normal) {
    return ((zWorld_ - normal).squaredNorm() < margin_);
  }
};  // class SupportOperation

class LeanOperation : public OperationBase {
 public:
  explicit LeanOperation(const double margin = 0.3,
                         const double nbTriMargin = 0.3,
                         const double minArea = 0.05,
                         const char* affordanceName = "Lean")
      : OperationBase(margin, nbTriMargin, minArea, affordanceName) {}

  bool requirement(const coal::Vec3s& normal) {
    return (fabs(normal.dot(zWorld_)) < margin_);
  }
};  // class LeanOperation

class Support45Operation : public OperationBase {
 public:
  explicit Support45Operation(const double margin = 0.3,
                              const double nbTriMargin = 0.3,
                              const double minArea = 0.05,
                              const char* affordanceName = "Support45")
      : OperationBase(margin, 0.05, minArea, affordanceName),
        axis45_(coal::Vec3s(1. / sqrt(2.), 0, 1. / sqrt(2.))) {}
 
 private:
  const coal::Vec3s axis45_;

  bool requirement(const coal::Vec3s& normal) {
    coal::Vec3s projectedNormal(0, 0, normal[2]);  // project normal in x,z plan
    projectedNormal[0] = sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
    return ((axis45_ - projectedNormal).squaredNorm() < margin_);
  }
};  // class LeanOperation

}  // namespace affordance
}  // namespace hpp
 
#endif  // HPP_AFFORDANCE_OPERATIONS_HH