Changes in src/Shapes/ShapeOps.cpp [5e588b5:79dd0e]

File:

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

src/Shapes/ShapeOps.cpp

@@ -11 +11 @@
 #include "Helpers/Assert.hpp"
 
+/*************** Base case ***********************/
+
+ShapeOpsBase_impl::ShapeOpsBase_impl(const Shape::impl_ptr &_arg) :
+  arg(_arg){}
+
+ShapeOpsBase_impl::~ShapeOpsBase_impl(){}
+
+bool ShapeOpsBase_impl::isInside(const Vector &point){
+  return arg->isInside(translateIn(point));
+}
+
+bool ShapeOpsBase_impl::isOnSurface(const Vector &point){
+  return arg->isOnSurface(translateIn(point));
+}
+
+Vector ShapeOpsBase_impl::getNormal(const Vector &point) throw (NotOnSurfaceException){
+  Vector helper = translateIn(point);
+  if(!arg->isOnSurface(helper)){
+    throw NotOnSurfaceException(__FILE__,__LINE__);
+  }
+  return translateOutNormal(arg->getNormal(helper));
+}
+
+Shape::impl_ptr ShapeOpsBase_impl::getArg(){
+  return arg;
+}
+
 /********************* Resize ********************/
 
 Resize_impl::Resize_impl(const Shape::impl_ptr &_arg,double _size) :
-  arg(_arg), size(_size)
+  ShapeOpsBase_impl(_arg), size(_size)
 {
   ASSERT(size>0,"Cannot resize a Shape to size zero or below");
@@ -21 +48 @@
 Resize_impl::~Resize_impl(){}
 
-bool Resize_impl::isInside(const Vector& point){
-  return arg->isInside((1/size) * point);
+Vector Resize_impl::translateIn(const Vector& point){
+  return (1/size) * point;
+}
+
+Vector Resize_impl::translateOutPos(const Vector& point){
+  return size * point;
+}
+
+Vector Resize_impl::translateOutNormal(const Vector& point){
+  return point;
+}
+
+string Resize_impl::toString(){
+  stringstream sstr;
+  sstr << "resize(" << getArg()->toString() << "," << size << ")";
+  return sstr.str();
 }
 
@@ -33 +74 @@
 
 Translate_impl::Translate_impl(const Shape::impl_ptr &_arg, const Vector &_offset) :
-  arg(_arg),offset(_offset)
+  ShapeOpsBase_impl(_arg),offset(_offset)
 {}
 
 Translate_impl::~Translate_impl(){}
 
-bool Translate_impl::isInside(const Vector& point){
-  return arg->isInside(point-offset);
+Vector Translate_impl::translateIn(const Vector& point){
+  return point-offset;
+}
+
+Vector Translate_impl::translateOutPos(const Vector& point){
+  return point+offset;
+}
+
+Vector Translate_impl::translateOutNormal(const Vector& point){
+  return point;
+}
+
+string Translate_impl::toString(){
+  stringstream sstr;
+  sstr << "translate(" << getArg()->toString() << "," << offset << ")";
+  return sstr.str();
 }
 
@@ -50 +105 @@
 
 Stretch_impl::Stretch_impl(const Shape::impl_ptr &_arg, const Vector &_factors) :
-  arg(_arg),factors(_factors)
+  ShapeOpsBase_impl(_arg),factors(_factors)
 {
   ASSERT(factors[0]>0,"cannot stretch a shape by a negative amount");
@@ -62 +117 @@
 Stretch_impl::~Stretch_impl(){}
 
-bool Stretch_impl::isInside(const Vector& point){
+Vector Stretch_impl::translateIn(const Vector& point){
   Vector helper=point;
   helper.ScaleAll(reciFactors);
-  return arg->isInside(helper);
+  return helper;
+}
+
+Vector Stretch_impl::translateOutPos(const Vector& point){
+  Vector helper=point;
+  helper.ScaleAll(factors);
+  return helper;
+}
+
+Vector Stretch_impl::translateOutNormal(const Vector& point){
+  Vector helper=point;
+  // the normalFactors are derived from appearances of the factors
+  // with in the vectorproduct
+  Vector normalFactors;
+  normalFactors[0]=factors[1]*factors[2];
+  normalFactors[1]=factors[0]*factors[2];
+  normalFactors[2]=factors[0]*factors[1];
+  helper.ScaleAll(normalFactors);
+  return helper;
+}
+
+string Stretch_impl::toString(){
+  stringstream sstr;
+  sstr << "stretch(" << getArg()->toString() << "," << factors << ")";
+  return sstr.str();
 }
 
@@ -76 +155 @@
 
 Transform_impl::Transform_impl(const Shape::impl_ptr &_arg, const Matrix &_transformation) :
-  arg(_arg),transformation(_transformation)
+  ShapeOpsBase_impl(_arg),transformation(_transformation)
 {
   transformationInv = transformation.invert();
@@ -83 +162 @@
 Transform_impl::~Transform_impl(){}
 
-bool Transform_impl::isInside(const Vector& point){
-  return arg->isInside(transformationInv * point);
+Vector Transform_impl::translateIn(const Vector& point){
+  return transformationInv * point;
+}
+
+Vector Transform_impl::translateOutPos(const Vector& point){
+  return transformation * point;
+}
+
+Vector Transform_impl::translateOutNormal(const Vector& point){
+  Matrix mat = transformation.determinant() * transformation.invert().transpose();
+  return mat * point;
+}
+
+string Transform_impl::toString(){
+  stringstream sstr;
+  sstr << "transform(" << getArg()->toString() << "," << transformation << ")";
+  return sstr.str();
 }