Changes in src/Shapes/ShapeOps.cpp [955b91:c67c65]

File:

• src/Shapes/ShapeOps.cpp (modified) (17 diffs)

src/Shapes/ShapeOps.cpp ¶

@@ -20 +20 @@
 #include "CodePatterns/MemDebug.hpp"
 
+#include <algorithm>
+#include <boost/bind.hpp>
+
 #include "Shapes/ShapeExceptions.hpp"
 #include "Shapes/ShapeOps.hpp"
@@ -34 +37 @@
 ShapeOpsBase_impl::~ShapeOpsBase_impl(){}
 
-bool ShapeOpsBase_impl::isInside(const Vector &point){
+bool ShapeOpsBase_impl::isInside(const Vector &point) const{
   return arg->isInside(translateIn(point));
 }
 
-bool ShapeOpsBase_impl::isOnSurface(const Vector &point){
+bool ShapeOpsBase_impl::isOnSurface(const Vector &point) const{
   return arg->isOnSurface(translateIn(point));
 }
 
-Vector ShapeOpsBase_impl::getNormal(const Vector &point) throw (NotOnSurfaceException){
+Vector ShapeOpsBase_impl::getNormal(const Vector &point) const throw (NotOnSurfaceException){
   Vector helper = translateIn(point);
   if(!arg->isOnSurface(helper)){
@@ -52 +55 @@
 }
 
-LineSegmentSet ShapeOpsBase_impl::getLineIntersections(const Line &line){
+Vector ShapeOpsBase_impl::getCenter() const
+{
+  return arg->getCenter();
+}
+
+double ShapeOpsBase_impl::getRadius() const
+{
+  return translateOutPos(Vector(arg->getRadius(), 0., 0.)).Norm();
+}
+
+
+LineSegmentSet ShapeOpsBase_impl::getLineIntersections(const Line &line) const{
   Line newLine(translateIn(line.getOrigin()),translateIn(line.getDirection()));
   LineSegmentSet res(line);
@@ -71 +85 @@
 }
 
+enum ShapeType ShapeOpsBase_impl::getType() const {
+        return getArg()->getType();
+}
+
 std::vector<Vector> ShapeOpsBase_impl::getHomogeneousPointsOnSurface(const size_t N) const {
-  return getArg()->getHomogeneousPointsOnSurface(N);;
+  return getArg()->getHomogeneousPointsOnSurface(N);
+}
+
+std::vector<Vector> ShapeOpsBase_impl::getHomogeneousPointsInVolume(const size_t N) const {
+  return getArg()->getHomogeneousPointsInVolume(N);
 }
 
@@ -89 +111 @@
 Resize_impl::~Resize_impl(){}
 
-bool Resize_impl::isInside(const Vector& point){
+double Resize_impl::getVolume() const
+{
+        return getArg()->getVolume() * size;
+}
+
+double Resize_impl::getSurfaceArea() const
+{
+        return getArg()->getSurfaceArea() * size;
+}
+
+
+bool Resize_impl::isInside(const Vector& point) const{
   return getArg()->isInside((1/size) * point);
 }
 
-Vector Resize_impl::translateIn(const Vector& point){
+Vector Resize_impl::translateIn(const Vector& point) const{
   return (1/size) * point;
 }
 
-Vector Resize_impl::translateOutPos(const Vector& point){
+Vector Resize_impl::translateOutPos(const Vector& point) const{
   return size * point;
 }
 
-Vector Resize_impl::translateOutNormal(const Vector& point){
+Vector Resize_impl::translateOutNormal(const Vector& point) const{
   return point;
 }
 
-std::string Resize_impl::toString() {
+std::string Resize_impl::toString() const{
   std::stringstream sstr;
   sstr << "resize(" << getArg()->toString() << "," << size << ")";
@@ -113 +146 @@
 std::vector<Vector> Resize_impl::getHomogeneousPointsOnSurface(const size_t N) const {
   std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsOnSurface(N);
-  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
-    *iter *= size;
-  }
-  return PointsOnSurface;
+  std::for_each(PointsOnSurface.begin(), PointsOnSurface.end(),
+                boost::bind(&Vector::operator*, _1, size) );
+  return PointsOnSurface;
+}
+
+std::vector<Vector> Resize_impl::getHomogeneousPointsInVolume(const size_t N) const {
+  std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsInVolume(N);
+  std::for_each(PointsOnSurface.begin(), PointsOnSurface.end(),
+                boost::bind(&Vector::operator*, _1, size) );
+        return std::vector<Vector>();
 }
 
@@ -133 +172 @@
 Translate_impl::~Translate_impl(){}
 
-bool Translate_impl::isInside(const Vector& point){
+bool Translate_impl::isInside(const Vector& point) const{
   return getArg()->isInside(point-offset);
 }
 
-Vector Translate_impl::translateIn(const Vector& point){
+Vector Translate_impl::getCenter() const
+{
+  return getArg()->getCenter()+offset;
+}
+
+double Translate_impl::getRadius() const
+{
+  return getArg()->getRadius();
+}
+
+double Translate_impl::getVolume() const
+{
+        return getArg()->getVolume();
+}
+
+double Translate_impl::getSurfaceArea() const
+{
+        return getArg()->getSurfaceArea();
+}
+
+Vector Translate_impl::translateIn(const Vector& point) const{
   return point-offset;
 }
 
-Vector Translate_impl::translateOutPos(const Vector& point){
+Vector Translate_impl::translateOutPos(const Vector& point) const{
   return point+offset;
 }
 
-Vector Translate_impl::translateOutNormal(const Vector& point){
+Vector Translate_impl::translateOutNormal(const Vector& point) const{
   return point;
 }
 
-std::string Translate_impl::toString() {
+std::string Translate_impl::toString() const{
   std::stringstream sstr;
   sstr << "translate(" << getArg()->toString() << "," << offset << ")";
@@ -157 +216 @@
 std::vector<Vector> Translate_impl::getHomogeneousPointsOnSurface(const size_t N) const {
   std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsOnSurface(N);
-  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
-    *iter += offset;
-  }
+  std::for_each(PointsOnSurface.begin(), PointsOnSurface.end(),
+                boost::bind(&Vector::operator+, _1, offset) );
+  return PointsOnSurface;
+}
+
+std::vector<Vector> Translate_impl::getHomogeneousPointsInVolume(const size_t N) const {
+  std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsInVolume(N);
+  std::for_each(PointsOnSurface.begin(), PointsOnSurface.end(),
+                boost::bind(&Vector::operator+, _1, offset) );
   return PointsOnSurface;
 }
@@ -173 +238 @@
   ShapeOpsBase_impl(_arg),factors(_factors)
 {
-  ASSERT(factors[0]>0,"cannot stretch a shape by a negative amount");
-  ASSERT(factors[1]>0,"cannot stretch a shape by a negative amount");
-  ASSERT(factors[2]>0,"cannot stretch a shape by a negative amount");
   for(int i = NDIM;i--;){
-    reciFactors[i] = 1/factors[i];
+    ASSERT(factors[i]>0.,"cannot stretch a shape by a negative amount");
+    reciFactors[i] = 1./factors[i];
   }
 }
@@ -183 +246 @@
 Stretch_impl::~Stretch_impl(){}
 
-bool Stretch_impl::isInside(const Vector& point){
+double Stretch_impl::getVolume() const
+{
+        // TODO
+        return -1.;
+}
+
+double Stretch_impl::getSurfaceArea() const
+{
+        // TODO
+        return -1.;
+}
+
+bool Stretch_impl::isInside(const Vector& point) const{
   Vector helper=point;
   helper.ScaleAll(reciFactors);
@@ -189 +264 @@
 }
 
-Vector Stretch_impl::translateIn(const Vector& point){
+Vector Stretch_impl::translateIn(const Vector& point) const{
   Vector helper=point;
   helper.ScaleAll(reciFactors);
@@ -195 +270 @@
 }
 
-Vector Stretch_impl::translateOutPos(const Vector& point){
+Vector Stretch_impl::translateOutPos(const Vector& point) const{
   Vector helper=point;
   helper.ScaleAll(factors);
@@ -201 +276 @@
 }
 
-Vector Stretch_impl::translateOutNormal(const Vector& point){
+Vector Stretch_impl::translateOutNormal(const Vector& point) const{
   Vector helper=point;
   // the normalFactors are derived from appearances of the factors
@@ -213 +288 @@
 }
 
-std::string Stretch_impl::toString() {
+std::string Stretch_impl::toString() const{
   std::stringstream sstr;
   sstr << "stretch(" << getArg()->toString() << "," << factors << ")";
@@ -221 +296 @@
 std::vector<Vector> Stretch_impl::getHomogeneousPointsOnSurface(const size_t N) const {
   std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsOnSurface(N);
-  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
-    (*iter).ScaleAll(reciFactors);
-  }
+  std::for_each(PointsOnSurface.begin(), PointsOnSurface.end(),
+                boost::bind( static_cast<void (Vector::*)(const Vector&)>(&Vector::ScaleAll), _1, reciFactors) );
+  return PointsOnSurface;
+}
+
+std::vector<Vector> Stretch_impl::getHomogeneousPointsInVolume(const size_t N) const {
+  std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsInVolume(N);
+  std::for_each(PointsOnSurface.begin(), PointsOnSurface.end(),
+      boost::bind( static_cast<void (Vector::*)(const Vector&)>(&Vector::ScaleAll), _1, reciFactors) );
   return PointsOnSurface;
 }
@@ -242 +323 @@
 Transform_impl::~Transform_impl(){}
 
-bool Transform_impl::isInside(const Vector& point){
+double Transform_impl::getVolume() const
+{
+        return getArg()->getVolume();
+}
+
+double Transform_impl::getSurfaceArea() const
+{
+        return getArg()->getSurfaceArea();
+}
+
+bool Transform_impl::isInside(const Vector& point) const{
   return getArg()->isInside(transformationInv * point);
 }
 
-Vector Transform_impl::translateIn(const Vector& point){
+Vector Transform_impl::translateIn(const Vector& point) const{
   return transformationInv * point;
 }
 
-Vector Transform_impl::translateOutPos(const Vector& point){
+Vector Transform_impl::translateOutPos(const Vector& point) const{
   return transformation * point;
 }
 
-Vector Transform_impl::translateOutNormal(const Vector& point){
+Vector Transform_impl::translateOutNormal(const Vector& point) const
+{
   RealSpaceMatrix mat = transformation.invert().transpose();
   return mat * point;
 }
 
-std::string Transform_impl::toString() {
+std::string Transform_impl::toString() const{
   std::stringstream sstr;
   sstr << "transform(" << getArg()->toString() << "," << transformation << ")";
@@ -267 +359 @@
 std::vector<Vector> Transform_impl::getHomogeneousPointsOnSurface(const size_t N) const {
   std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsOnSurface(N);
-  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
-    *iter = transformation * (*iter);
-  }
+  std::transform( PointsOnSurface.begin(), PointsOnSurface.end(), PointsOnSurface.begin(),
+      boost::bind(static_cast<Vector(*)(const RealSpaceMatrix&,const Vector&)>(operator*), transformation, _1));
+  return PointsOnSurface;
+}
+
+std::vector<Vector> Transform_impl::getHomogeneousPointsInVolume(const size_t N) const {
+  std::vector<Vector> PointsOnSurface = getArg()->getHomogeneousPointsInVolume(N);
+  std::transform( PointsOnSurface.begin(), PointsOnSurface.end(), PointsOnSurface.begin(),
+      boost::bind(static_cast<Vector(*)(const RealSpaceMatrix&,const Vector&)>(operator*), transformation, _1));
   return PointsOnSurface;
 }