Changes in src/Shapes/Shape.cpp [da1e92:955b91]

File:

• src/Shapes/Shape.cpp (modified) (14 diffs)

src/Shapes/Shape.cpp

@@ -26 +26 @@
 #include "Shapes/Shape_impl.hpp"
 #include "Shapes/ShapeExceptions.hpp"
-#include "Shapes/ShapeType.hpp"
-
-#include "Tesselation/ApproximateShapeArea.hpp"
-#include "Tesselation/ApproximateShapeVolume.hpp"
-
-#include <algorithm>
-#include <limits>
+
 #include <string>
 
@@ -54 +48 @@
 }
 
-Vector Shape::getCenter() const{
-  return impl->getCenter();
-}
-
-double Shape::getRadius() const{
-  return impl->getRadius();
-}
-
-/** Returns the volume of the Shape.
- *
- * If the underlying implementation does not have a working implementation,
- * i.e. returns -1., then we use an approximate method to calculate the
- * volume via a mesh of grid points and checking for isInside (basically
- * a Monte-Carlo integration of the volume).
- *
- * \return volume of the shape
- */
-double Shape::getVolume() const
-{
-        const double volume = impl->getVolume();
-        if (volume  != -1.) {
-                return volume;
-        } else {
-                ApproximateShapeVolume Approximator(*this);
-                return Approximator();
-        }
-}
-
-/** Returns the surface area of the Shape.
- *
- * If the underlying implementation does not have a working implementation,
- * i.e. returns -1., then we use the working filling of the shapes surface
- * with points and subsequent tesselation and obtaining the approximate
- * surface area therefrom.
- *
- * @return surface area of the Shape
- */
-double Shape::getSurfaceArea() const
-{
-        const double surfacearea = impl->getSurfaceArea();
-        if (surfacearea != -1.) {
-                return surfacearea;
-        } else {
-                ApproximateShapeArea Approximator(*this);
-                return Approximator();
-        }
-}
-
-LineSegmentSet Shape::getLineIntersections(const Line &line) const{
+LineSegmentSet Shape::getLineIntersections(const Line &line){
   return impl->getLineIntersections(line);
 }
@@ -108 +54 @@
 std::vector<Vector> Shape::getHomogeneousPointsOnSurface(const size_t N) const {
   return impl->getHomogeneousPointsOnSurface(N);
-}
-
-std::vector<Vector> Shape::getHomogeneousPointsInVolume(const size_t N) const {
-        return impl->getHomogeneousPointsInVolume(N);
 }
 
@@ -125 +67 @@
 }
 
-bool Shape::operator==(const Shape &rhs) const{
-        return (this->getType() == rhs.getType());
-}
-
 std::string Shape::toString() const{
   return impl->toString();
-}
-
-enum ShapeType Shape::getType() const{
-        return impl->getType();
 }
 
@@ -168 +102 @@
 AndShape_impl::~AndShape_impl(){}
 
-bool AndShape_impl::isInside(const Vector &point) const{
+bool AndShape_impl::isInside(const Vector &point){
   return lhs->isInside(point) && rhs->isInside(point);
 }
 
-bool AndShape_impl::isOnSurface(const Vector &point) const{
+bool AndShape_impl::isOnSurface(const Vector &point){
   // check the number of surfaces that this point is on
   int surfaces =0;
@@ -204 +138 @@
 }
 
-Vector AndShape_impl::getNormal(const Vector &point) const throw (NotOnSurfaceException){
+Vector AndShape_impl::getNormal(const Vector &point) throw (NotOnSurfaceException){
   Vector res;
   if(!isOnSurface(point)){
@@ -215 +149 @@
 }
 
-Vector AndShape_impl::getCenter() const
-{
-  // calculate closest position on sphere surface to other center ..
-  const Vector rhsDistance = rhs->getCenter() + rhs->getRadius()*((lhs->getCenter() - rhs->getCenter()).getNormalized());
-  const Vector lhsDistance = lhs->getCenter() + lhs->getRadius()*((rhs->getCenter() - lhs->getCenter()).getNormalized());
-  // .. and then it's right in between those two
-  return 0.5*(rhsDistance + lhsDistance);
-}
-
-double AndShape_impl::getRadius() const
-{
-  const double distance = (lhs->getCenter() - rhs->getCenter()).Norm();
-  const double minradii = std::min(lhs->getRadius(), rhs->getRadius());
-  // if no intersection
-  if (distance > (lhs->getRadius() + rhs->getRadius()))
-    return 0.;
-  else // if intersection it can only be the smaller one
-    return minradii;
-}
-
-double AndShape_impl::getVolume() const
-{
-        // TODO
-        return -1.;
-}
-
-double AndShape_impl::getSurfaceArea() const
-{
-        // TODO
-        return -1.;
-}
-
-LineSegmentSet AndShape_impl::getLineIntersections(const Line &line) const{
+LineSegmentSet AndShape_impl::getLineIntersections(const Line &line){
   return intersect(lhs->getLineIntersections(line),rhs->getLineIntersections(line));
 }
 
-std::string AndShape_impl::toString() const{
+std::string AndShape_impl::toString() {
   return std::string("(") + lhs->toString() + std::string("&&") + rhs->toString() + std::string(")");
-}
-
-enum ShapeType AndShape_impl::getType() const{
-        return CombinedType;
 }
 
@@ -276 +174 @@
 }
 
-std::vector<Vector> AndShape_impl::getHomogeneousPointsInVolume(const size_t N) const {
-        ASSERT(0,
-                        "AndShape_impl::getHomogeneousPointsInVolume() - not implemented.");
-        return std::vector<Vector>();
-}
-
 
 Shape operator&&(const Shape &lhs,const Shape &rhs){
@@ -296 +188 @@
 OrShape_impl::~OrShape_impl(){}
 
-bool OrShape_impl::isInside(const Vector &point) const{
+bool OrShape_impl::isInside(const Vector &point){
   return rhs->isInside(point) || lhs->isInside(point);
 }
 
-bool OrShape_impl::isOnSurface(const Vector &point) const{
+bool OrShape_impl::isOnSurface(const Vector &point){
   // check the number of surfaces that this point is on
   int surfaces =0;
@@ -332 +224 @@
 }
 
-Vector OrShape_impl::getNormal(const Vector &point) const throw (NotOnSurfaceException){
+Vector OrShape_impl::getNormal(const Vector &point) throw (NotOnSurfaceException){
   Vector res;
   if(!isOnSurface(point)){
@@ -343 +235 @@
 }
 
-Vector OrShape_impl::getCenter() const
-{
-  // calculate furthest position on sphere surface to other center ..
-  const Vector rhsDistance = rhs->getCenter() + rhs->getRadius()*((rhs->getCenter() - lhs->getCenter()).getNormalized());
-  const Vector lhsDistance = lhs->getCenter() + lhs->getRadius()*((lhs->getCenter() - rhs->getCenter()).getNormalized());
-  // .. and then it's right in between those two
-  return .5*(rhsDistance + lhsDistance);
-}
-
-double OrShape_impl::getRadius() const
-{
-  const Vector rhsDistance = rhs->getCenter() + rhs->getRadius()*((rhs->getCenter() - lhs->getCenter()).getNormalized());
-  const Vector lhsDistance = lhs->getCenter() + lhs->getRadius()*((lhs->getCenter() - rhs->getCenter()).getNormalized());
-  return .5*(rhsDistance - lhsDistance).Norm();
-}
-
-double OrShape_impl::getVolume() const
-{
-        // TODO
-        return -1.;
-}
-
-double OrShape_impl::getSurfaceArea() const
-{
-        // TODO
-        return -1.;
-}
-
-LineSegmentSet OrShape_impl::getLineIntersections(const Line &line) const{
+LineSegmentSet OrShape_impl::getLineIntersections(const Line &line){
   return merge(lhs->getLineIntersections(line),rhs->getLineIntersections(line));
 }
 
-std::string OrShape_impl::toString() const{
+std::string OrShape_impl::toString() {
   return std::string("(") + lhs->toString() + std::string("||") + rhs->toString() + std::string(")");
-}
-
-enum ShapeType OrShape_impl::getType() const{
-        return CombinedType;
 }
 
@@ -400 +260 @@
 }
 
-std::vector<Vector> OrShape_impl::getHomogeneousPointsInVolume(const size_t N) const {
-        ASSERT(0,
-                        "OrShape_impl::getHomogeneousPointsInVolume() - not implemented.");
-        return std::vector<Vector>();
-}
-
 Shape operator||(const Shape &lhs,const Shape &rhs){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new OrShape_impl(getShapeImpl(lhs),getShapeImpl(rhs)));
@@ -419 +273 @@
 NotShape_impl::~NotShape_impl(){}
 
-bool NotShape_impl::isInside(const Vector &point) const{
+bool NotShape_impl::isInside(const Vector &point){
   return !arg->isInside(point);
 }
 
-bool NotShape_impl::isOnSurface(const Vector &point) const{
+bool NotShape_impl::isOnSurface(const Vector &point){
   return arg->isOnSurface(point);
 }
 
-Vector NotShape_impl::getNormal(const Vector &point) const throw(NotOnSurfaceException){
+Vector NotShape_impl::getNormal(const Vector &point) throw(NotOnSurfaceException){
   return -1.*arg->getNormal(point);
 }
 
-Vector NotShape_impl::getCenter() const
-{
-  return arg->getCenter();
-}
-
-double NotShape_impl::getRadius() const
-{
-  return std::numeric_limits<double>::infinity();
-}
-
-double NotShape_impl::getVolume() const
-{
-        // TODO
-        return -1.; //-arg->getVolume();
-}
-
-double NotShape_impl::getSurfaceArea() const
-{
-        // TODO
-        return -1.; // -arg->getSurfaceArea();
-}
-
-LineSegmentSet NotShape_impl::getLineIntersections(const Line &line) const{
+LineSegmentSet NotShape_impl::getLineIntersections(const Line &line){
   return invert(arg->getLineIntersections(line));
 }
 
-std::string NotShape_impl::toString() const{
+std::string NotShape_impl::toString(){
   return std::string("!") + arg->toString();
-}
-
-enum ShapeType NotShape_impl::getType() const{
-        return CombinedType;
 }
 
@@ -468 +296 @@
   // surfaces are the same, only normal direction is different
   return arg->getHomogeneousPointsOnSurface(N);
-}
-
-std::vector<Vector> NotShape_impl::getHomogeneousPointsInVolume(const size_t N) const {
-        ASSERT(0,
-                        "NotShape_impl::getHomogeneousPointsInVolume() - not implemented.");
-        return std::vector<Vector>();
 }