remove useless BSP methods

Author: theo-dep

src/thirdparty/bsptree.hpp

@@ -524,246 +524,6 @@ class BspTree
       }
     }
 
-    bool isInside(const point_type & p, const Node * n) const noexcept
-    {
-      coord_type dist = distance(n->plane, p);
-
-      if (dist < 0)
-      {
-        if (n->behind)
-          return isInside(p, n->behind.get());
-        else
-          return true;
-      }
-      else
-      {
-        if (n->infront)
-          return isInside(p, n->infront.get());
-        else
-          return false;
-      }
-    }
-
-    void reCalculatePlanes(Node * n) noexcept
-    {
-        // recalculate plane for this node with the first triangle on this plane
-        n->plane = calculatePlane(
-          get(n->triangles, 0),
-          get(n->triangles, 1),
-          get(n->triangles, 2)
-        );
-
-        // do the two subtrees
-        if (n->infront) return reCalculatePlanes(n->infront.get());
-        if (n->behind) return reCalculatePlanes(n->behind.get());
-    }
-
-    // append vertices
-    void append(C & v, const vertex_type & v1, const vertex_type & v2, const vertex_type & v3) const
-    {
-      container_traits<C>::append(v, v1);
-      container_traits<C>::append(v, v2);
-      container_traits<C>::append(v, v3);
-    }
-
-    // assumes, that the node is not empty
-    bool classifyTriangle(const Node * n, const vertex_type & v1, const vertex_type & v2, const vertex_type & v3, bool inside, bool keepEdge, C & out, bool keepNow) const
-    {
-      if (!n)
-      {
-        if (keepNow)
-        {
-          append(out, v1, v2, v3);
-        }
-
-        return keepNow;
-      }
-
-
-      // this is again a variation of the code in separateTriangles
-
-      // calculate distance of the 3 vertices from the choosen partitioning plane
-      std::array<coord_type, 3> dist
-      {
-        distance(n->plane, vertex_traits<vertex_type>::getPosition(v1)),
-        distance(n->plane, vertex_traits<vertex_type>::getPosition(v2)),
-        distance(n->plane, vertex_traits<vertex_type>::getPosition(v3))
-      };
-
-      // check on which side of the plane the 3 points are
-      std::array<size_type, 3> side { sign(dist[0]), sign(dist[1]), sign(dist[2]) };
-
-      C tmp;
-      std::array<index_type, 3> A;
-
-      if (side[0] * side[1] == -1)
-      {
-        A[0] = container_traits<C>::appendInterpolate(tmp, v1, v2, relation(dist[0], dist[1]));
-      }
-      if (side[1] * side[2] == -1)
-      {
-        A[1] = container_traits<C>::appendInterpolate(tmp, v2, v3, relation(dist[1], dist[2]));
-      }
-      if (side[2] * side[0] == -1)
-      {
-        A[2] = container_traits<C>::appendInterpolate(tmp, v3, v1, relation(dist[2], dist[0]));
-      }
-
-      size_type preAddSize = container_traits<C>::getSize(out);
-      bool complete = true; // is the triangle completely added with all parts that it is split into
-      bool clipped = true;  // is the triangle split at all
-
-      // go over all possible positions of the 3 vertices relative to the plane
-      switch (splitType(side[0], side[1], side[2]))
-      {
-        // all point on one side of the plane (or on the plane)
-        // in this case we simply add the complete triangle
-        // to the proper halve of the subtree
-        case splitType(-1, -1, -1):
-        case splitType(-1, -1,  0):
-        case splitType(-1,  0, -1):
-        case splitType(-1,  0,  0):
-        case splitType( 0, -1, -1):
-        case splitType( 0, -1,  0):
-        case splitType( 0,  0, -1):
-          complete = classifyTriangle(n->behind.get(), v1, v2, v3, inside, keepEdge, out, inside);
-          clipped = false;
-          break;
-
-        default:
-        case splitType( 0,  0,  1):
-        case splitType( 0,  1,  0):
-        case splitType( 0,  1,  1):
-        case splitType( 1,  0,  0):
-        case splitType( 1,  0,  1):
-        case splitType( 1,  1,  0):
-        case splitType( 1,  1,  1):
-          complete = classifyTriangle(n->infront.get(), v1, v2, v3, inside, keepEdge, out, !inside);
-          clipped = false;
-          break;
-
-        // triangle on the dividing plane
-        case splitType( 0,  0,  0):
-          if (keepEdge)
-          {
-            append(out, v1, v2, v3);
-            clipped = false;
-          }
-          break;
-
-        // and now all the ways that the triangle can be cut by the plane
-        case splitType( 1, -1,  0):
-          complete &= classifyTriangle(n->behind.get(),  v2, v3, tmp[A[0]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v3, v1, tmp[A[0]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType(-1,  0,  1):
-          complete &= classifyTriangle(n->behind.get(),  v1, v2, tmp[A[2]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v2, v3, tmp[A[2]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType( 0,  1, -1):
-          complete &= classifyTriangle(n->behind.get(),  v3, v1, tmp[A[1]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v1, v2, tmp[A[1]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType(-1,  1,  0):
-          complete &= classifyTriangle(n->behind.get(),  v3, v1, tmp[A[0]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v2, v3, tmp[A[0]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType( 1,  0, -1):
-          complete &= classifyTriangle(n->behind.get(),  v2, v3, tmp[A[2]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v1, v2, tmp[A[2]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType( 0, -1,  1):
-          complete &= classifyTriangle(n->behind.get(),  v1, v2, tmp[A[1]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v3, v1, tmp[A[1]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType( 1, -1, -1):
-          complete &= classifyTriangle(n->infront.get(), v1, tmp[A[0]], tmp[A[2]], inside, keepEdge, out, !inside);
-          complete &= classifyTriangle(n->behind.get(),  v2, tmp[A[2]], tmp[A[0]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->behind.get(),  v2, v3,        tmp[A[2]], inside, keepEdge, out, inside);
-          break;
-
-        case splitType(-1,  1, -1):
-          complete &= classifyTriangle(n->infront.get(), v2, tmp[A[1]], tmp[A[0]], inside, keepEdge, out, !inside);
-          complete &= classifyTriangle(n->behind.get(),  v3, tmp[A[0]], tmp[A[1]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->behind.get(),  v3, v1,        tmp[A[0]], inside, keepEdge, out, inside);
-          break;
-
-        case splitType(-1, -1,  1):
-          complete &= classifyTriangle(n->infront.get(), v3, tmp[A[2]], tmp[A[1]], inside, keepEdge, out, !inside);
-          complete &= classifyTriangle(n->behind.get(),  v1, tmp[A[1]], tmp[A[2]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->behind.get(),  v1, v2,        tmp[A[1]], inside, keepEdge, out, inside);
-          break;
-
-        case splitType(-1,  1,  1):
-          complete &= classifyTriangle(n->behind.get(),  v1, tmp[A[0]], tmp[A[2]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v2, tmp[A[2]], tmp[A[0]], inside, keepEdge, out, !inside);
-          complete &= classifyTriangle(n->infront.get(), v2, v3,        tmp[A[2]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType( 1, -1,  1):
-          complete &= classifyTriangle(n->behind.get(),  v2, tmp[A[1]], tmp[A[0]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v1, tmp[A[0]], tmp[A[1]], inside, keepEdge, out, !inside);
-          complete &= classifyTriangle(n->infront.get(), v3, v1,        tmp[A[1]], inside, keepEdge, out, !inside);
-          break;
-
-        case splitType( 1,  1, -1):
-          complete &= classifyTriangle(n->behind.get(),  v3, tmp[A[2]], tmp[A[1]], inside, keepEdge, out, inside);
-          complete &= classifyTriangle(n->infront.get(), v1, tmp[A[1]], tmp[A[2]], inside, keepEdge, out, !inside);
-          complete &= classifyTriangle(n->infront.get(), v1, v2,        tmp[A[1]], inside, keepEdge, out, !inside);
-          break;
-
-        default:
-          complete = false;
-          break;
-      }
-
-      if (complete && clipped)
-      {
-        // triangle has been split, but all parts are added to
-        // the output buffer, so remove everything added and add
-        // the whole triangle as a single unit
-        container_traits<C>::resize(out, preAddSize);
-        append(out, v1, v2, v3);
-      }
-
-      return complete;
-    }
-
-    // classify the triangles of the tree given as parameter and keep the
-    // polygons that are choosen and put them into out vector
-    // tree: tree to classify
-    // inside: true: keep inside polygons, else keep outside polygons
-    //    when inside polygons are kept they are automatically flipped
-    // keepEdge: keep faces that are on the edge of the other polyhedron
-    // out: where to put the triangles
-    void classifyTree(const Node * tree, const C & vertices, bool inside, bool keepEdge, C & out) const
-    {
-      if (tree)
-      {
-        size_type i = 0;
-        size_type s = container_traits<I>::getSize(tree->triangles);
-        while (i+2 < s)
-        {
-          auto v1 = getVertIndex(tree->triangles, i  );
-          auto v2 = getVertIndex(tree->triangles, i+1);
-          auto v3 = getVertIndex(tree->triangles, i+2);
-
-          classifyTriangle(root_.get(), v1, v2, v3, inside, keepEdge, out, false);
-
-          i+=3;
-        }
-
-        classifyTree(tree->infront.get(), vertices, inside, keepEdge, out);
-        classifyTree(tree->behind.get(), vertices, inside, keepEdge, out);
-      }
-    }
-
   public:
 
     /// construct the tree, vertices are taken over, indices not
@@ -779,7 +539,6 @@ class BspTree
       root_ = makeTree(indices);
     }
 
-
     /// another constructor that assumes that the vertices given are grouped in
     /// triples that each represents one triangle
     BspTree(C && vertices) : vertices_(std::move(vertices))
@@ -811,69 +570,6 @@ class BspTree
       return out;
     }
 
-    /// check if a point is inside the polyhedron defined by the bsp-tree or outside of
-    /// it. This only works, when you defined all your triangles in counter clockwise
-    /// fashion when seen from the outside and also none of the polytopes that you add
-    /// to the tree may intersect
-    /// \param p position you want to check
-    /// \return true, when inside of one of the polytopes
-    bool isInside(const point_type & p) const noexcept
-    {
-        return isInside(p, root_.get());
-    }
-
-    /// transform the polygon that this tree describes by the given matrix
-    /// \tparam M matrix type, you have to be able to handle whit matrix
-    ///         in the vertex_traits::transform function, otherwise you can use
-    ///         whatever you want
-    template <class M>
-    void transform(const M & m) // TODO could be noexcept, if transform is noexcept
-    {
-        // transform all vertices
-        for (auto & v : vertices_)
-        {
-            vertex_traits<vertex_type>::transform(v, m);
-        }
-
-        // traverse tree and re-calculate all planes
-        reCalculatePlanes(root_.get());
-    }
-
-    /// perform boolean operations on the polyhedra defined by the two trees
-    static BspTree<C, I, E> intersect(const BspTree<C, I, E> & lhs, const BspTree<C, I, E> & rhs)
-    {
-      C result;
-
-      lhs.classifyTree(rhs.root_.get(), rhs.vertices_, true, true, result);
-      rhs.classifyTree(lhs.root_.get(), lhs.vertices_, true, false, result);
-
-      return BspTree<C, I, E>(std::move(result));
-    }
-
-    /// perform boolean operations on the polyhedra defined by the two trees
-    static BspTree<C, I, E> unify(const BspTree<C, I, E> & lhs, const BspTree<C, I, E> & rhs)
-    {
-      C result;
-
-      lhs.classifyTree(rhs.root_.get(), rhs.vertices_, false, true, result);
-      rhs.classifyTree(lhs.root_.get(), lhs.vertices_, false, false, result);
-
-      return BspTree<C, I, E>(std::move(result));
-    }
-
-    /// perform boolean operations on the polyhedra defined by the two trees
-    static BspTree<C, I, E> subtract(const BspTree<C, I, E> & lhs, const BspTree<C, I, E> & rhs)
-    {
-      C result;
-
-      lhs.classifyTree(rhs.root_.get(), rhs.vertices_, true, true, result);
-      rhs.classifyTree(lhs.root_.get(), lhs.vertices_, false, false, result);
-
-      return BspTree<C, I, E>(std::move(result));
-    }
-
 };
 
-
 }
-