From d243bfb61ef6c906f446085e5ae1993263aa85a8 Mon Sep 17 00:00:00 2001 From: Alexander Ewering Date: Fri, 28 Oct 2005 20:17:27 +0000 Subject: New files from new booleans --- intern/boolop/Makefile | 59 ++ intern/boolop/extern/BOP_Interface.h | 53 + intern/boolop/intern/BOP_BBox.cpp | 62 ++ intern/boolop/intern/BOP_BBox.h | 96 ++ intern/boolop/intern/BOP_BSPNode.cpp | 671 +++++++++++++ intern/boolop/intern/BOP_BSPNode.h | 104 ++ intern/boolop/intern/BOP_BSPTree.cpp | 212 ++++ intern/boolop/intern/BOP_BSPTree.h | 75 ++ intern/boolop/intern/BOP_Chrono.h | 52 + intern/boolop/intern/BOP_Edge.cpp | 81 ++ intern/boolop/intern/BOP_Edge.h | 55 + intern/boolop/intern/BOP_Face.cpp | 416 ++++++++ intern/boolop/intern/BOP_Face.h | 105 ++ intern/boolop/intern/BOP_Face2Face.cpp | 1270 ++++++++++++++++++++++++ intern/boolop/intern/BOP_Face2Face.h | 44 + intern/boolop/intern/BOP_Indexs.h | 41 + intern/boolop/intern/BOP_Interface.cpp | 603 +++++++++++ intern/boolop/intern/BOP_Material.cpp | 176 ++++ intern/boolop/intern/BOP_Material.h | 80 ++ intern/boolop/intern/BOP_MaterialContainer.cpp | 242 +++++ intern/boolop/intern/BOP_MaterialContainer.h | 72 ++ intern/boolop/intern/BOP_MathUtils.cpp | 419 ++++++++ intern/boolop/intern/BOP_MathUtils.h | 72 ++ intern/boolop/intern/BOP_Merge.cpp | 796 +++++++++++++++ intern/boolop/intern/BOP_Merge.h | 74 ++ intern/boolop/intern/BOP_Mesh.cpp | 835 ++++++++++++++++ intern/boolop/intern/BOP_Mesh.h | 97 ++ intern/boolop/intern/BOP_Segment.cpp | 247 +++++ intern/boolop/intern/BOP_Segment.h | 73 ++ intern/boolop/intern/BOP_Splitter.cpp | 193 ++++ intern/boolop/intern/BOP_Splitter.h | 44 + intern/boolop/intern/BOP_Tag.cpp | 142 +++ intern/boolop/intern/BOP_Tag.h | 145 +++ intern/boolop/intern/BOP_Triangulator.cpp | 515 ++++++++++ intern/boolop/intern/BOP_Triangulator.h | 44 + intern/boolop/intern/BOP_Vertex.cpp | 94 ++ intern/boolop/intern/BOP_Vertex.h | 60 ++ intern/boolop/intern/Makefile | 48 + 38 files changed, 8467 insertions(+) create mode 100644 intern/boolop/Makefile create mode 100644 intern/boolop/extern/BOP_Interface.h create mode 100644 intern/boolop/intern/BOP_BBox.cpp create mode 100644 intern/boolop/intern/BOP_BBox.h create mode 100644 intern/boolop/intern/BOP_BSPNode.cpp create mode 100644 intern/boolop/intern/BOP_BSPNode.h create mode 100644 intern/boolop/intern/BOP_BSPTree.cpp create mode 100644 intern/boolop/intern/BOP_BSPTree.h create mode 100644 intern/boolop/intern/BOP_Chrono.h create mode 100644 intern/boolop/intern/BOP_Edge.cpp create mode 100644 intern/boolop/intern/BOP_Edge.h create mode 100644 intern/boolop/intern/BOP_Face.cpp create mode 100644 intern/boolop/intern/BOP_Face.h create mode 100644 intern/boolop/intern/BOP_Face2Face.cpp create mode 100644 intern/boolop/intern/BOP_Face2Face.h create mode 100644 intern/boolop/intern/BOP_Indexs.h create mode 100644 intern/boolop/intern/BOP_Interface.cpp create mode 100644 intern/boolop/intern/BOP_Material.cpp create mode 100644 intern/boolop/intern/BOP_Material.h create mode 100644 intern/boolop/intern/BOP_MaterialContainer.cpp create mode 100644 intern/boolop/intern/BOP_MaterialContainer.h create mode 100644 intern/boolop/intern/BOP_MathUtils.cpp create mode 100644 intern/boolop/intern/BOP_MathUtils.h create mode 100644 intern/boolop/intern/BOP_Merge.cpp create mode 100644 intern/boolop/intern/BOP_Merge.h create mode 100644 intern/boolop/intern/BOP_Mesh.cpp create mode 100644 intern/boolop/intern/BOP_Mesh.h create mode 100644 intern/boolop/intern/BOP_Segment.cpp create mode 100644 intern/boolop/intern/BOP_Segment.h create mode 100644 intern/boolop/intern/BOP_Splitter.cpp create mode 100644 intern/boolop/intern/BOP_Splitter.h create mode 100644 intern/boolop/intern/BOP_Tag.cpp create mode 100644 intern/boolop/intern/BOP_Tag.h create mode 100644 intern/boolop/intern/BOP_Triangulator.cpp create mode 100644 intern/boolop/intern/BOP_Triangulator.h create mode 100644 intern/boolop/intern/BOP_Vertex.cpp create mode 100644 intern/boolop/intern/BOP_Vertex.h create mode 100644 intern/boolop/intern/Makefile (limited to 'intern/boolop') diff --git a/intern/boolop/Makefile b/intern/boolop/Makefile new file mode 100644 index 00000000000..85e6754132e --- /dev/null +++ b/intern/boolop/Makefile @@ -0,0 +1,59 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program 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 Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): Hans Lambermont +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# bsp main makefile. +# + +include nan_definitions.mk + +LIBNAME = boolop +SOURCEDIR = intern/$(LIBNAME) +DIR = $(OCGDIR)/$(SOURCEDIR) +DIRS = intern +# not yet TESTDIRS = test + +include nan_subdirs.mk + +install: all debug + @[ -d $(NAN_BOOLOP) ] || mkdir $(NAN_BOOLOP) + @[ -d $(NAN_BOOLOP)/include ] || mkdir $(NAN_BOOLOP)/include + @[ -d $(NAN_BOOLOP)/lib ] || mkdir $(NAN_BOOLOP)/lib + @[ -d $(NAN_BOOLOP)/lib/debug ] || mkdir $(NAN_BOOLOP)/lib/debug + @../tools/cpifdiff.sh $(DIR)/libboolop.a $(NAN_BOOLOP)/lib/ + @../tools/cpifdiff.sh $(DIR)/debug/libboolop.a $(NAN_BOOLOP)/lib/debug/ +ifeq ($(OS),darwin) + ranlib $(NAN_BOOLOP)/lib/libboolop.a + ranlib $(NAN_BOOLOP)/lib/debug/libboolop.a +endif + @../tools/cpifdiff.sh extern/*.h $(NAN_BOOLOP)/include/ + + + + diff --git a/intern/boolop/extern/BOP_Interface.h b/intern/boolop/extern/BOP_Interface.h new file mode 100644 index 00000000000..446dd1b79f7 --- /dev/null +++ b/intern/boolop/extern/BOP_Interface.h @@ -0,0 +1,53 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_INTERFACE_H +#define BOP_INTERFACE_H + +#include "../../bsp/intern/BSP_CSGMesh.h" + +typedef enum EnumBoolOpState {BOP_OK, BOP_NO_SOLID, BOP_ERROR} BoolOpState; +typedef enum EnumBoolOpType {BOP_INTERSECTION=e_csg_intersection, BOP_UNION=e_csg_union, BOP_DIFFERENCE=e_csg_difference} BoolOpType; + +// extern interpolator. +typedef int (*CSG_InterpolateUserFaceVertexDataFunc)(void *d1, void * d2, void *dnew, float epsilon); + +BoolOpState BOP_performBooleanOperation(BoolOpType opType, + CSG_MeshPropertyDescriptor outputProps, + BSP_CSGMesh** outputMesh, + CSG_MeshPropertyDescriptor obAProps, + CSG_FaceIteratorDescriptor obAFaces, + CSG_VertexIteratorDescriptor obAVertices, + CSG_MeshPropertyDescriptor obBProps, + CSG_FaceIteratorDescriptor obBFaces, + CSG_VertexIteratorDescriptor obBVertices, + CSG_InterpolateUserFaceVertexDataFunc interpFunc); + +#endif diff --git a/intern/boolop/intern/BOP_BBox.cpp b/intern/boolop/intern/BOP_BBox.cpp new file mode 100644 index 00000000000..767847e1e09 --- /dev/null +++ b/intern/boolop/intern/BOP_BBox.cpp @@ -0,0 +1,62 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_BBox.h" + +#include "MT_Scalar.h" + +/** + * Constructs a nwe bounding box. + */ +BOP_BBox::BOP_BBox() +{ + m_minX = MT_INFINITY; + m_minY = MT_INFINITY; + m_minZ = MT_INFINITY; + m_maxX = -MT_INFINITY; + m_maxY = -MT_INFINITY; + m_maxZ = -MT_INFINITY; +} + +/** + * Constructs a new bounding box using three points. + * @param p1 first point + * @param p2 second point + * @param p3 third point + */ +BOP_BBox::BOP_BBox(const MT_Point3& p1,const MT_Point3& p2,const MT_Point3& p3) +{ + m_minX = BOP_MIN(BOP_MIN(p1[0],p2[0]),p3[0]); + m_minY = BOP_MIN(BOP_MIN(p1[1],p2[1]),p3[1]); + m_minZ = BOP_MIN(BOP_MIN(p1[2],p2[2]),p3[2]); + m_maxX = BOP_MAX(BOP_MAX(p1[0],p2[0]),p3[0]); + m_maxY = BOP_MAX(BOP_MAX(p1[1],p2[1]),p3[1]); + m_maxZ = BOP_MAX(BOP_MAX(p1[2],p2[2]),p3[2]); +} diff --git a/intern/boolop/intern/BOP_BBox.h b/intern/boolop/intern/BOP_BBox.h new file mode 100644 index 00000000000..473a9828a1a --- /dev/null +++ b/intern/boolop/intern/BOP_BBox.h @@ -0,0 +1,96 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_BBOX_H +#define BOP_BBOX_H + +#include "MT_Point3.h" +#include "BOP_MathUtils.h" + +#define BOP_MAX(a, b) ((a > b) ? a : b) +#define BOP_MIN(a, b) ((a < b) ? a : b) +#define BOP_ABS(a) ((a < 0) ? -(a) : a) + +class BOP_BBox +{ +public: + MT_Scalar m_minX; + MT_Scalar m_minY; + MT_Scalar m_minZ; + MT_Scalar m_maxX; + MT_Scalar m_maxY; + MT_Scalar m_maxZ; + MT_Scalar m_centerX; + MT_Scalar m_centerY; + MT_Scalar m_centerZ; + MT_Scalar m_extentX; + MT_Scalar m_extentY; + MT_Scalar m_extentZ; + +public: + BOP_BBox(); + BOP_BBox(const MT_Point3& p1,const MT_Point3& p2,const MT_Point3& p3); + inline void add(const MT_Point3& p) + { + m_minX = BOP_MIN(m_minX,p[0]); + m_minY = BOP_MIN(m_minY,p[1]); + m_minZ = BOP_MIN(m_minZ,p[2]); + m_maxX = BOP_MAX(m_maxX,p[0]); + m_maxY = BOP_MAX(m_maxY,p[1]); + m_maxZ = BOP_MAX(m_maxZ,p[2]); + }; + + inline const MT_Scalar getCenterX() const {return m_centerX;}; + inline const MT_Scalar getCenterY() const {return m_centerY;}; + inline const MT_Scalar getCenterZ() const {return m_centerZ;}; + + inline const MT_Scalar getExtentX() const {return m_extentX;}; + inline const MT_Scalar getExtentY() const {return m_extentY;}; + inline const MT_Scalar getExtentZ() const {return m_extentZ;}; + + inline void compute() { + m_extentX = (m_maxX-m_minX)/2.0f; + m_extentY = (m_maxY-m_minY)/2.0f; + m_extentZ = (m_maxZ-m_minZ)/2.0f; + m_centerX = m_minX+m_extentX; + m_centerY = m_minY+m_extentY; + m_centerZ = m_minZ+m_extentZ; + }; + + inline const bool intersect(const BOP_BBox& b) const { + return (!((BOP_comp(m_maxX,b.m_minX)<0) || (BOP_comp(b.m_maxX,m_minX)<0) || + (BOP_comp(m_maxY,b.m_minY)<0) || (BOP_comp(b.m_maxY,m_minY)<0) || + (BOP_comp(m_maxZ,b.m_minZ)<0) || (BOP_comp(b.m_maxZ,m_minZ)<0))); + }; + + +}; + +#endif diff --git a/intern/boolop/intern/BOP_BSPNode.cpp b/intern/boolop/intern/BOP_BSPNode.cpp new file mode 100644 index 00000000000..afe48586d33 --- /dev/null +++ b/intern/boolop/intern/BOP_BSPNode.cpp @@ -0,0 +1,671 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_MathUtils.h" +#include "BOP_BSPNode.h" +#include "MT_assert.h" +#include "MT_MinMax.h" +#include +using namespace std; + +/** + * Constructs a new BSP node. + * @param plane split plane. + */ +BOP_BSPNode::BOP_BSPNode(const MT_Plane3& plane) +{ + m_plane = plane; + m_inChild = NULL; + m_outChild = NULL; + m_deep = 1; +} + +/** + * Destroys a BSP tree. + */ +BOP_BSPNode::~BOP_BSPNode() +{ + if (m_inChild!=NULL) delete m_inChild; + if (m_outChild!=NULL) delete m_outChild; +} + +/** + * Adds a new face to this BSP tree. + * @param p1 first face point. + * @param p2 second face point. + * @param p3 third face point. + * @param plane face plane. + */ +unsigned int BOP_BSPNode::addFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) +{ + unsigned int newDeep = 0; + BOP_TAG tag = BOP_createTAG(testPoint(p1), testPoint(p2), testPoint(p3)); + if ((tag & IN_IN_IN) != 0) { + if (m_inChild != NULL) + newDeep = m_inChild->addFace(p1, p2, p3, plane) + 1; + else { + m_inChild = new BOP_BSPNode(plane); + newDeep = 2; + } + } + + if ((tag & OUT_OUT_OUT) != 0){ + if (m_outChild != NULL) + newDeep = max(newDeep, m_outChild->addFace(p1, p2, p3, plane) + 1); + else { + m_outChild = new BOP_BSPNode(plane); + newDeep = max(newDeep,(unsigned int)2); + } + } + + // update the deep attribute + m_deep = MT_max(m_deep,newDeep); + + return m_deep; +} + +/** + * Tests the point situation respect the node plane. + * @param p point to test. + * @return TAG result: IN, OUT or ON. + */ +BOP_TAG BOP_BSPNode::testPoint(const MT_Point3& p) const +{ + return BOP_createTAG(BOP_classify(p,m_plane)); + +} + +/** + * Classifies a face using its coordinates and plane. + * @param p1 first point. + * @param p2 second point. + * @param p3 third point. + * @param plane face plane. + * @return TAG result: IN, OUT or IN&OUT. + */ +BOP_TAG BOP_BSPNode::classifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + // local variables + MT_Point3 auxp1, auxp2; + BOP_TAG auxtag1, auxtag2, auxtag3; + + switch(BOP_createTAG(testPoint(p1),testPoint(p2),testPoint(p3))) { + // Classify the face on the IN side + case IN_IN_IN : + return classifyFaceIN(p1, p2, p3, plane); + case IN_IN_ON : + case IN_ON_IN : + case ON_IN_IN : + case IN_ON_ON : + case ON_IN_ON : + case ON_ON_IN : + return BOP_addON(classifyFaceIN(p1, p2, p3, plane)); + + // Classify the face on the OUT side + case OUT_OUT_OUT : + return classifyFaceOUT(p1, p2, p3, plane); + case OUT_OUT_ON : + case OUT_ON_OUT : + case ON_OUT_OUT : + case ON_ON_OUT : + case ON_OUT_ON : + case OUT_ON_ON : + return BOP_addON(classifyFaceOUT(p1, p2, p3, plane)); + + // Classify the ON face depending on it plane normal + case ON_ON_ON : + if (hasSameOrientation(plane)) + return BOP_addON(classifyFaceIN(p1, p2, p3, plane)); + else + return BOP_addON(classifyFaceOUT(p1, p2, p3, plane)); + + // Classify the face IN/OUT and one vertex ON + // becouse only one ON, only one way to subdivide the face + case IN_OUT_ON : + auxp1 = BOP_intersectPlane(m_plane, p1, p2); + auxtag1 = classifyFaceIN( p1, auxp1 , p3, plane); + auxtag2 = classifyFaceOUT(auxp1, p2, p3, plane); + return (BOP_compTAG(auxtag1,auxtag2)?BOP_addON(auxtag1):INOUT); + + case OUT_IN_ON : + auxp1 = BOP_intersectPlane(m_plane, p1, p2); + auxtag1 = classifyFaceOUT(p1, auxp1, p3, plane); + auxtag2 = classifyFaceIN( auxp1, p2, p3, plane); + return (BOP_compTAG(auxtag1,auxtag2)?BOP_addON(auxtag1):INOUT); + + case IN_ON_OUT : + auxp1 = BOP_intersectPlane(m_plane, p1, p3); + auxtag1 = classifyFaceIN( p1, p2, auxp1, plane); + auxtag2 = classifyFaceOUT(p2, p3, auxp1, plane); + return (BOP_compTAG(auxtag1,auxtag2)?BOP_addON(auxtag1):INOUT); + + case OUT_ON_IN : + auxp1 = BOP_intersectPlane(m_plane, p1, p3); + auxtag1 = classifyFaceOUT(p1, p2, auxp1, plane); + auxtag2 = classifyFaceIN( p2, p3, auxp1, plane); + return (BOP_compTAG(auxtag1,auxtag2)?BOP_addON(auxtag1):INOUT); + + case ON_IN_OUT : + auxp1 = BOP_intersectPlane(m_plane, p2, p3); + auxtag1 = classifyFaceIN( p1, p2, auxp1, plane); + auxtag2 = classifyFaceOUT(auxp1, p3, p1, plane); + return (BOP_compTAG(auxtag1,auxtag2)?BOP_addON(auxtag1):INOUT); + + case ON_OUT_IN : + auxp1 = BOP_intersectPlane(m_plane, p2, p3); + auxtag1 = classifyFaceOUT(p1, p2, auxp1, plane); + auxtag2 = classifyFaceIN( auxp1, p3, p1, plane); + return (BOP_compTAG(auxtag1,auxtag2)?BOP_addON(auxtag1):INOUT); + + // Classify IN/OUT face without ON vertices. + // Two ways to divide the triangle, + // will chose the least degenerated sub-triangles. + case IN_OUT_OUT : + auxp1 = BOP_intersectPlane(m_plane, p1, p2); + auxp2 = BOP_intersectPlane(m_plane, p1, p3); + + // f1: p1 auxp1 , auxp1 auxp2 + auxtag1 = classifyFaceIN(p1, auxp1, auxp2, plane); + + // f2: auxp1 p2 , p2 auxp2; f3: p2 p3 , p3 auxp2 || + // f2: auxp1 p3, p3 auxp2; f3: p2 p3 , p3 auxp1 + if (BOP_isInsideCircle(p2, p3, auxp1, auxp2)) { + auxtag2 = classifyFaceOUT(auxp1, p2, auxp2, plane); + auxtag3 = classifyFaceOUT(p2, p3, auxp2, plane); + } + else { + auxtag2 = classifyFaceOUT(auxp1, p3, auxp2, plane); + auxtag3 = classifyFaceOUT(p2, p3, auxp1, plane); + } + return (BOP_compTAG(auxtag1,auxtag2)&&BOP_compTAG(auxtag2,auxtag3)?auxtag1:INOUT); + + case OUT_IN_IN : + auxp1 = BOP_intersectPlane(m_plane, p1, p2); + auxp2 = BOP_intersectPlane(m_plane, p1, p3); + + // f1: p1 auxp1 , auxp1 auxp2 + auxtag1 = classifyFaceOUT(p1, auxp1, auxp2, plane); + + // f2: auxp1 p2 , p2 auxp2; f3: p2 p3 , p3 auxp2 || + // f2: auxp1 p3, p3 auxp2; f3: p2 p3 , p3 auxp1 + if (BOP_isInsideCircle(p2, p3, auxp1, auxp2)) { + auxtag2 = classifyFaceIN(auxp1, p2, auxp2, plane); + auxtag3 = classifyFaceIN(p2, p3, auxp2, plane); + } + else { + auxtag2 = classifyFaceIN(auxp1, p3, auxp2, plane); + auxtag3 = classifyFaceIN(p2, p3, auxp1, plane); + } + return (BOP_compTAG(auxtag1,auxtag2)&&BOP_compTAG(auxtag2,auxtag3)?auxtag1:INOUT); + + case OUT_IN_OUT : + auxp1 = BOP_intersectPlane(m_plane, p2, p1); + auxp2 = BOP_intersectPlane(m_plane, p2, p3); + + // f1: auxp1 p2 , p2 auxp2 + auxtag1 = classifyFaceIN(auxp1, p2, auxp2, plane); + + // f2: p1 auxp1 , auxp1 auxp2; f3: p1 auxp2 , auxp2 p3 || + // f2: p3 auxp1, auxp1 auxp2 f3:p1 auxp1, auxp1 p3 + if (BOP_isInsideCircle(p1, p3, auxp1, auxp2)) { + auxtag2 = classifyFaceOUT(p1, auxp1, auxp2, plane); + auxtag3 = classifyFaceOUT(p1, auxp2, p3, plane); + } + else { + auxtag2 = classifyFaceOUT(p3, auxp1, auxp2, plane); + auxtag3 = classifyFaceOUT(p1, auxp1, p3, plane); + } + return (BOP_compTAG(auxtag1,auxtag2)&&BOP_compTAG(auxtag2,auxtag3)?auxtag1:INOUT); + + case IN_OUT_IN : + auxp1 = BOP_intersectPlane(m_plane, p2, p1); + auxp2 = BOP_intersectPlane(m_plane, p2, p3); + + // f1: auxp1 p2 , p2 auxp2 + auxtag1 = classifyFaceOUT(auxp1, p2, auxp2, plane); + + // f2: p1 auxp1 , auxp1 auxp2; f3: p1 auxp2 , auxp2 p3 || + // f2: p3 auxp1, auxp1 auxp2 f3:p1 auxp1, auxp1 p3 + if (BOP_isInsideCircle(p1, p3, auxp1, auxp2)) { + auxtag2 = classifyFaceIN(p1, auxp1, auxp2, plane); + auxtag3 = classifyFaceIN(p1, auxp2, p3, plane); + } + else { + auxtag2 = classifyFaceIN(p3, auxp1, auxp2, plane); + auxtag3 = classifyFaceIN(p1, auxp1, p3, plane); + } + return (BOP_compTAG(auxtag1,auxtag2)&&BOP_compTAG(auxtag2,auxtag3)?auxtag1:INOUT); + + case OUT_OUT_IN : + auxp1 = BOP_intersectPlane(m_plane, p3, p1); + auxp2 = BOP_intersectPlane(m_plane, p3, p2); + + // f1: auxp1 auxp2 , auxp2 p3 + auxtag1 = classifyFaceIN(auxp1, auxp2, p3, plane); + + // f2: p1 p2 , p2 auxp2; f3:p1 auxp2 , auxp2 auxp1 || + // f2: p1 p2, p2 auxp1; f3:p2 auxp2, auxp2 auxp1 + if (BOP_isInsideCircle(p1, p2, auxp1, auxp2)) { + auxtag2 = classifyFaceOUT(p1, p2, auxp2, plane); + auxtag3 = classifyFaceOUT(p1, auxp2, auxp1, plane); + } + else { + auxtag2 = classifyFaceOUT(p1, p2, auxp1, plane); + auxtag3 = classifyFaceOUT(p2, auxp2, auxp1, plane); + } + return (BOP_compTAG(auxtag1,auxtag2)&&BOP_compTAG(auxtag2,auxtag3)?auxtag1:INOUT); + + case IN_IN_OUT : + auxp1 = BOP_intersectPlane(m_plane, p3, p1); + auxp2 = BOP_intersectPlane(m_plane, p3, p2); + + // f1: auxp1 auxp2 , auxp2 p3 + auxtag1 = classifyFaceOUT(auxp1, auxp2, p3, plane); + + // f2: p1 p2 , p2 auxp2; f3:p1 auxp2 , auxp2 auxp1 || + // f2: p1 p2, p2 auxp1; f3:p2 auxp2, auxp2 auxp1 + if (BOP_isInsideCircle(p1, p2, auxp1, auxp2)) { + auxtag2 = classifyFaceIN(p1, p2, auxp2, plane); + auxtag3 = classifyFaceIN(p1, auxp2, auxp1, plane); + } + else { + auxtag2 = classifyFaceIN(p1, p2, auxp1, plane); + auxtag3 = classifyFaceIN(p2, auxp2, auxp1, plane); + } + return (BOP_compTAG(auxtag1,auxtag2)&&BOP_compTAG(auxtag2,auxtag3)?auxtag1:INOUT); + + default: + return UNCLASSIFIED; + } +} + +/** + * Classifies a face through IN subtree. + * @param p1 firts face vertex. + * @param p2 second face vertex. + * @param p3 third face vertex. + * @param plane face plane. + */ +BOP_TAG BOP_BSPNode::classifyFaceIN(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + if (m_inChild != NULL) + return m_inChild->classifyFace(p1, p2, p3, plane); + else + return IN; +} + +/** + * Classifies a face through OUT subtree. + * @param p1 firts face vertex. + * @param p2 second face vertex. + * @param p3 third face vertex. + * @param plane face plane. + */ +BOP_TAG BOP_BSPNode::classifyFaceOUT(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + if (m_outChild != NULL) + return m_outChild->classifyFace(p1, p2, p3, plane); + else + return OUT; +} + +/** + * Simplified classification (optimized but requires that the face is not + * INOUT; only works correctly with faces completely IN or OUT). + * @param p1 firts face vertex. + * @param p2 second face vertex. + * @param p3 third face vertex. + * @param plane face plane. + * @return TAG result: IN or OUT. + */ +BOP_TAG BOP_BSPNode::simplifiedClassifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + MT_Point3 ret[3]; + + BOP_TAG tag = BOP_createTAG(testPoint(p1),testPoint(p2),testPoint(p3)); + + if ((tag & IN_IN_IN) != 0) { + if ((tag & OUT_OUT_OUT) != 0) { + if (splitTriangle(ret,m_plane,p1,p2,p3,tag)<0) + return simplifiedClassifyFaceIN(ret[0],ret[1],ret[2],plane); + else + return simplifiedClassifyFaceOUT(ret[0],ret[1],ret[2],plane); + } + else { + return simplifiedClassifyFaceIN(p1,p2,p3,plane); + } + } + else { + if ((tag & OUT_OUT_OUT) != 0) { + return simplifiedClassifyFaceOUT(p1,p2,p3,plane); + } + else { + if (hasSameOrientation(plane)) { + return simplifiedClassifyFaceIN(p1,p2,p3,plane); + } + else { + return simplifiedClassifyFaceOUT(p1,p2,p3,plane); + } + } + } + + return IN; +} + +/** + * Simplified classify through IN subtree. + * @param p1 firts face vertex. + * @param p2 second face vertex. + * @param p3 third face vertex. + * @param plane face plane. + */ +BOP_TAG BOP_BSPNode::simplifiedClassifyFaceIN(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + if (m_inChild != NULL) + return m_inChild->simplifiedClassifyFace(p1, p2, p3, plane); + else + return IN; +} + +/** + * Simplified classify through OUT subtree. + * @param p1 firts face vertex. + * @param p2 second face vertex. + * @param p3 third face vertex. + * @param plane face plane. + */ +BOP_TAG BOP_BSPNode::simplifiedClassifyFaceOUT(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + if (m_outChild != NULL) + return m_outChild->simplifiedClassifyFace(p1, p2, p3, plane); + else + return OUT; +} + +/** + * Determine if the input plane have the same orientation of the node plane. + * @param plane plane to test. + * @return TRUE if have the same orientation, FALSE otherwise. + */ +bool BOP_BSPNode::hasSameOrientation(const MT_Plane3& plane) const +{ + return (BOP_orientation(m_plane,plane)>0); +} + +/** + * Comparation between both childrens. + * @return 0 equal deep, 1 inChild more deep than outChild and -1 otherwise. + */ +int BOP_BSPNode::compChildren() const +{ + unsigned int deep1 = (m_inChild == NULL?0:m_inChild->getDeep()); + unsigned int deep2 = (m_outChild == NULL?0:m_outChild->getDeep()); + + if (deep1 == deep2) + return 0; + else if (deep1 < deep2) + return -1; + else + return 1; +} + +/** + * Extract a subtriangle from input triangle, is used for simplified classification. + * The subtriangle is obtained spliting the input triangle by input plane. + * @param res output subtriangle result. + * @param plane spliter plane. + * @param p1 first triangle point. + * @param p2 second triangle point. + * @param p3 third triangle point. + * @param tag triangle orientation respect the plane. + */ +int BOP_BSPNode::splitTriangle(MT_Point3* res, + const MT_Plane3& plane, + const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const BOP_TAG tag) const +{ + switch (tag) { + case IN_OUT_ON : + if (compChildren()<0) { + // f1: p1 new p3 || new = splitedge(p1,p2) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p1, p2 ); + res[2] = p3; + return -1; + }else{ + // f1: p2 new p3 || new = splitedge(p1,p2) + res[0] = p2; + res[1] = p3; + res[2] = BOP_intersectPlane( plane, p1, p2 ); + return 1; + } + case OUT_IN_ON : + if (compChildren()<0) { + // f1: p2 new p3 || new = splitedge(p1,p2) + res[0] = p2; + res[1] = p3; + res[2] = BOP_intersectPlane( plane, p1, p2 ); + return -1; + }else{ + // f1: p1 new p3 || new = splitedge(p1,p2) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p1, p2 ); + res[2] = p3; + return 1; + } + case IN_ON_OUT : + if (compChildren()<0) { + // f1: p1 p2 new || new = splitedge(p1,p3) + res[0] = p1; + res[1] = p2; + res[2] = BOP_intersectPlane( plane, p1, p3 ); + return -1; + }else{ + // f1: p2 p3 new || new = splitedge(p1,p3) + res[0] = p2; + res[1] = p3; + res[2] = BOP_intersectPlane( plane, p1, p3 ); + return 1; + } + case OUT_ON_IN : + if (compChildren()<0) { + // f1: p2 p3 new || new = splitedge(p1,p3) + res[0] = p2; + res[1] = p3; + res[2] = BOP_intersectPlane( plane, p1, p3 ); + return -1; + }else{ + // f1: p1 p2 new || new = splitedge(p1,p3) + res[0] = p1; + res[1] = p2; + res[2] = BOP_intersectPlane( plane, p1, p3 ); + return 1; + } + case ON_IN_OUT : + if (compChildren()<0) { + // f1: p1 p2 new || new = splitedge(p2,p3) + res[0] = p1; + res[1] = p2; + res[2] = BOP_intersectPlane( plane, p2, p3 ); + return -1; + }else{ + // f1: p1 p3 new || new = splitedge(p2,p3) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p2, p3 ); + res[2] = p3; + return 1; + } + case ON_OUT_IN : + if (compChildren()<0) { + // f1: p1 p2 new || new = splitedge(p2,p3) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p2, p3 ); + res[2] = p3; + return -1; + }else{ + // f1: p1 p2 new || new = splitedge(p2,p3) + res[0] = p1; + res[1] = p2; + res[2] = BOP_intersectPlane( plane, p2, p3 ); + return 1; + } + case IN_OUT_OUT : + if (compChildren()<=0) { + // f1: p1 new1 new2 || new1 = splitedge(p1,p2) new2 = splitedge(p1,p3) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p1, p2 ); + res[2] = BOP_intersectPlane( plane, p1, p3 ); + return -1; + }else{ + // f1: p1 new1 new2 || new1 = splitedge(p1,p2) new2 = splitedge(p1,p3) + res[0] = BOP_intersectPlane( plane, p1, p2 ); + res[1] = p2; + res[2] = p3; + return 1; + } + case OUT_IN_IN : + if (compChildren()<0) { + // f1: p1 new1 new2 || new1 = splitedge(p1,p2) new2 = splitedge(p1,p3) + res[0] = BOP_intersectPlane( plane, p1, p2 ); + res[1] = p2; + res[2] = p3; + return -1; + }else { + // f1: p1 new1 new2 || new1 = splitedge(p1,p2) new2 = splitedge(p1,p3) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p1, p2 ); + res[2] = BOP_intersectPlane( plane, p1, p3 ); + return 1; + } + case OUT_IN_OUT : + if (compChildren()<=0) { + // f1: new1 p2 new2 || new1 = splitedge(p2,p1) new2 = splitedge(p2,p3) + res[0] = BOP_intersectPlane( plane, p2, p1 ); + res[1] = p2; + res[2] = BOP_intersectPlane( plane, p2, p3 ); + return -1; + }else { + // f1: new1 p2 new2 || new1 = splitedge(p2,p1) new2 = splitedge(p2,p3) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p2, p1 ); + res[2] = BOP_intersectPlane( plane, p2, p3 ); + return 1; + } + case IN_OUT_IN : + if (compChildren()<0) { + // f1: new1 p2 new2 || new1 = splitedge(p2,p1) new2 = splitedge(p2,p3) + res[0] = p1; + res[1] = BOP_intersectPlane( plane, p2, p1 ); + res[2] = BOP_intersectPlane( plane, p2, p3 ); + return -1; + }else{ + // f1: new1 p2 new2 || new1 = splitedge(p2,p1) new2 = splitedge(p2,p3) + res[0] = BOP_intersectPlane( plane, p2, p1 ); + res[1] = p2; + res[2] = BOP_intersectPlane( plane, p2, p3 ); + return 1; + } + case OUT_OUT_IN : + if (compChildren()<=0) { + // f1: new1 new2 p2 || new1 = splitedge(p3,p1) new2 = splitedge(p3,p2) + res[0] = BOP_intersectPlane( plane, p3, p1 ); + res[1] = BOP_intersectPlane( plane, p3, p2 ); + res[2] = p3; + return -1; + }else{ + // f1: new1 new2 p2 || new1 = splitedge(p3,p1) new2 = splitedge(p3,p2) + res[0] = BOP_intersectPlane( plane, p3, p1 ); + res[1] = p1; + res[2] = p2; + return 1; + } + case IN_IN_OUT : + if (compChildren()<0) { + // f1: new1 new2 p2 || new1 = splitedge(p3,p1) new2 = splitedge(p3,p2) + res[0] = BOP_intersectPlane( plane, p3, p1 ); + res[1] = p1; + res[2] = p2; + return -1; + }else{ + // f1: new1 new2 p2 || new1 = splitedge(p3,p1) new2 = splitedge(p3,p2) + res[0] = BOP_intersectPlane( plane, p3, p1 ); + res[1] = BOP_intersectPlane( plane, p3, p2 ); + res[2] = p3; + return 1; + } + default: + return 0; + } +} + +/** + * Debug info. + */ +void BOP_BSPNode::print(unsigned int deep) +{ + for (unsigned int i = 0; i < deep; ++i) + cout << " "; + + cout << m_plane.x() << ", "; + cout << m_plane.y() << ", "; + cout << m_plane.z() << ", "; + cout << m_plane.w() << endl; + if (m_inChild != NULL) { + cout << "IN:"; + m_inChild->print(deep + 1); + } + if (m_outChild != NULL) { + cout << "OUT:"; + m_outChild->print(deep + 1); + } +} diff --git a/intern/boolop/intern/BOP_BSPNode.h b/intern/boolop/intern/BOP_BSPNode.h new file mode 100644 index 00000000000..d4f7f1c28a1 --- /dev/null +++ b/intern/boolop/intern/BOP_BSPNode.h @@ -0,0 +1,104 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_BSPNODE_H +#define BOP_BSPNODE_H + +#include "MT_Plane3.h" +#include "BOP_Tag.h" +#include "BOP_Face.h" + +class BOP_BSPNode +{ +protected: + BOP_BSPNode* m_inChild; + BOP_BSPNode* m_outChild; + MT_Plane3 m_plane; + unsigned int m_deep; + +public: + // Construction methods + BOP_BSPNode(const MT_Plane3& plane); + ~BOP_BSPNode(); + unsigned int addFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane); + BOP_TAG classifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + BOP_TAG simplifiedClassifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + +protected: + BOP_TAG testPoint(const MT_Point3& p) const; + BOP_TAG classifyFaceIN(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + BOP_TAG classifyFaceOUT(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + BOP_TAG simplifiedClassifyFaceIN(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + BOP_TAG simplifiedClassifyFaceOUT(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + bool hasSameOrientation(const MT_Plane3& plane) const; + int compChildren() const; + int splitTriangle(MT_Point3* res, + const MT_Plane3& plane, + const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const BOP_TAG tag) const; + +public: + // Inline acces methods + inline void setInChild(BOP_BSPNode* inChild) { m_inChild=inChild; }; + inline void setOutChild(BOP_BSPNode* outChild) { m_outChild=outChild; }; + inline BOP_BSPNode* getInChild() { return m_inChild; }; + inline BOP_BSPNode* getOutChild() { return m_outChild; }; + inline bool isLeaf() const { return !m_inChild && !m_outChild; }; + inline void setPlane(const MT_Plane3& plane) {m_plane=plane;}; + inline MT_Plane3& getPlane() { return m_plane; }; + + inline unsigned int getDeep() const {return m_deep;}; + void print(unsigned int deep); +}; + +#endif diff --git a/intern/boolop/intern/BOP_BSPTree.cpp b/intern/boolop/intern/BOP_BSPTree.cpp new file mode 100644 index 00000000000..4e5c171bc83 --- /dev/null +++ b/intern/boolop/intern/BOP_BSPTree.cpp @@ -0,0 +1,212 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_BSPTree.h" +#include +#include +using namespace std; + +/** + * Constructs a new BSP tree. + */ +BOP_BSPTree::BOP_BSPTree() +{ + m_root = NULL; + m_bspBB = NULL; +} + +/** + * Destroys a BSP tree. + */ +BOP_BSPTree::~BOP_BSPTree() +{ + if (m_root!=NULL) delete m_root; + if (m_bspBB!=NULL) delete m_bspBB; +} + +/** + * Adds all mesh faces to BSP tree. + * @param mesh mesh to add. + * @param facesList face list to add. + */ +void BOP_BSPTree::addMesh(BOP_Mesh* mesh, BOP_Faces& facesList) +{ + for (BOP_IT_Faces it = facesList.begin(); it != facesList.end(); ++it) { + addFace( mesh, *it ); + } + +} + +/** + * Adds a new face into bsp tree. + * @param mesh Input data for BSP tree. + * @param face index to mesh face. + */ +void BOP_BSPTree::addFace(BOP_Mesh* mesh, BOP_Face* face) +{ + addFace(mesh->getVertex(face->getVertex(0))->getPoint(), + mesh->getVertex(face->getVertex(1))->getPoint(), + mesh->getVertex(face->getVertex(2))->getPoint(), + face->getPlane()); +} + +/** + * Adds new facee to the bsp-tree. + * @param p1 first face point. + * @param p2 second face point. + * @param p3 third face point. + * @param plane face plane. + */ +void BOP_BSPTree::addFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) +{ + if (m_root == NULL) + m_root = new BOP_BSPNode(plane); + else + m_root->addFace(p1,p2,p3,plane); + + // update bounding box + m_bbox.add(p1); + m_bbox.add(p2); + m_bbox.add(p3); +} + +/** + * Tests face vs bsp-tree (returns where is the face respect bsp planes). + * @param p1 first face triangle point. + * @param p2 secons face triangle point. + * @param p3 third face triangle point. + * @param plane face plane. + * @return BSP_IN, BSP_OUT or BSP_IN_OUT + */ +BOP_TAG BOP_BSPTree::classifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + if ( m_root != NULL ) + return m_root->classifyFace(p1, p2, p3, plane); + else + return OUT; +} + +/** + * Filters a face using the BSP bounding infomation. + * @param p1 first face triangle point. + * @param p2 secons face triangle point. + * @param p3 third face triangle point. + * @param face face to test. + * @return UNCLASSIFIED, BSP_IN, BSP_OUT or BSP_IN_OUT + */ +BOP_TAG BOP_BSPTree::filterFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + BOP_Face* face) +{ + if ( m_bspBB != NULL ) { + return m_bspBB->classifyFace(p1,p2,p3,face->getPlane()); + } + else + return UNCLASSIFIED; +} + +/** + * Tests face vs bsp-tree (returns where is the face respect bsp planes). + * @param p1 first face triangle point. + * @param p2 secons face triangle point. + * @param p3 third face triangle point. + * @param plane face plane. + * @return BSP_IN, BSP_OUT or BSP_IN_OUT + */ +BOP_TAG BOP_BSPTree::simplifiedClassifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const +{ + if ( m_root != NULL ) + return m_root->simplifiedClassifyFace(p1, p2, p3, plane); + else + return OUT; +} + +/** + * Returns the deep of this BSP tree. + * @return tree deep + */ +unsigned int BOP_BSPTree::getDeep() const +{ + if ( m_root != NULL ) + return m_root->getDeep(); + else + return 0; +} + +/** + * Computes the bounding BSP data. + */ +void BOP_BSPTree::computeBox() +{ + if ( m_root != NULL ) { + MT_Point3 p1(m_bbox.m_minX,m_bbox.m_minY,m_bbox.m_minZ); + MT_Point3 p2(m_bbox.m_maxX,m_bbox.m_minY,m_bbox.m_minZ); + MT_Point3 p3(m_bbox.m_maxX,m_bbox.m_maxY,m_bbox.m_minZ); + MT_Point3 p4(m_bbox.m_minX,m_bbox.m_maxY,m_bbox.m_minZ); + MT_Point3 p5(m_bbox.m_minX,m_bbox.m_minY,m_bbox.m_maxZ); + MT_Point3 p6(m_bbox.m_maxX,m_bbox.m_minY,m_bbox.m_maxZ); + MT_Point3 p7(m_bbox.m_maxX,m_bbox.m_maxY,m_bbox.m_maxZ); + MT_Point3 p8(m_bbox.m_minX,m_bbox.m_maxY,m_bbox.m_maxZ); + + MT_Plane3 plane1(p3,p2,p1); + MT_Plane3 plane2(p5,p6,p7); + MT_Plane3 plane3(p1,p2,p6); + MT_Plane3 plane4(p8,p7,p3); + MT_Plane3 plane5(p2,p3,p7); + MT_Plane3 plane6(p1,p5,p8); + + BOP_BSPNode bsp(plane1); + bsp.addFace(p5,p6,p7,plane2); + bsp.addFace(p1,p2,p6,plane3); + bsp.addFace(p8,p7,p3,plane4); + bsp.addFace(p2,p3,p7,plane5); + bsp.addFace(p1,p5,p8,plane6); + } +} + +/** + * Prints debug information. + */ +void BOP_BSPTree::print() +{ + if ( m_root != NULL ) + m_root->print( 0 ); +} + diff --git a/intern/boolop/intern/BOP_BSPTree.h b/intern/boolop/intern/BOP_BSPTree.h new file mode 100644 index 00000000000..7e5b5a4fa76 --- /dev/null +++ b/intern/boolop/intern/BOP_BSPTree.h @@ -0,0 +1,75 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_BSPTREE_H +#define BOP_BSPTREE_H + +#include "BOP_BSPNode.h" +#include "BOP_Mesh.h" +#include "BOP_Tag.h" +#include "BOP_BBox.h" + +class BOP_BSPTree +{ +protected: + BOP_BSPNode* m_root; + BOP_BSPNode* m_bspBB; + BOP_BBox m_bbox; +public: + // Construction methods + BOP_BSPTree(); + virtual ~BOP_BSPTree(); + void addMesh(BOP_Mesh* mesh, BOP_Faces& facesList); + void addFace(BOP_Mesh* mesh, BOP_Face* face); + virtual void addFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane); + BOP_TAG classifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + BOP_TAG filterFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + BOP_Face* face); + BOP_TAG simplifiedClassifyFace(const MT_Point3& p1, + const MT_Point3& p2, + const MT_Point3& p3, + const MT_Plane3& plane) const; + unsigned int getDeep() const; + void computeBox(); + void print(); + inline void setRoot(BOP_BSPNode* root) {m_root=root;}; + inline BOP_BSPNode* getRoot() const {return m_root;}; +}; + +#endif + diff --git a/intern/boolop/intern/BOP_Chrono.h b/intern/boolop/intern/BOP_Chrono.h new file mode 100644 index 00000000000..5ce64f7a57c --- /dev/null +++ b/intern/boolop/intern/BOP_Chrono.h @@ -0,0 +1,52 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_CHRONO_H +#define BOP_CHRONO_H + +#include + +class BOP_Chrono +{ +private: + clock_t m_begin; +public: + BOP_Chrono(){}; + void start() {m_begin = clock();}; + float stamp() { + clock_t c = clock(); + clock_t stmp = c - m_begin; + m_begin = c; + float t = ((float) stmp / (float) CLOCKS_PER_SEC)*1000.0f; + return t; + }; +}; + +#endif diff --git a/intern/boolop/intern/BOP_Edge.cpp b/intern/boolop/intern/BOP_Edge.cpp new file mode 100644 index 00000000000..31411133878 --- /dev/null +++ b/intern/boolop/intern/BOP_Edge.cpp @@ -0,0 +1,81 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Edge.h" + +/** + * Constructs a new edge. + * @param v1 vertex index + * @param v2 vertex index + */ +BOP_Edge::BOP_Edge(BOP_Index v1, BOP_Index v2) +{ + m_vertexs[0] = v1; + m_vertexs[1] = v2; +} + +/** + * Adds a new face index to this edge. + * @param i face index + */ +void BOP_Edge::addFace(BOP_Index i) +{ + if (!containsFace(i)) + m_faces.push_back(i); +} + +/** + * Returns if this edge contains the specified face index. + * @param i face index + * @return true if this edge contains the specified face index, false otherwise + */ +bool BOP_Edge::containsFace(BOP_Index i) +{ + int pos=0; + for(BOP_IT_Indexs it = m_faces.begin();it!=m_faces.end();pos++,it++) { + if ((*it) == i) + return true; + } + + return false; +} + +/** + * Replaces an edge vertex index. + * @param oldIndex old vertex index + * @param newIndex new vertex index + */ +void BOP_Edge::replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex) +{ + if (m_vertexs[0] == oldIndex) m_vertexs[0] = newIndex; + else if (m_vertexs[1] == oldIndex) m_vertexs[1] = newIndex; +} + + diff --git a/intern/boolop/intern/BOP_Edge.h b/intern/boolop/intern/BOP_Edge.h new file mode 100644 index 00000000000..abf5dd0a8c8 --- /dev/null +++ b/intern/boolop/intern/BOP_Edge.h @@ -0,0 +1,55 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_EDGE_H +#define BOP_EDGE_H + +#include "BOP_Indexs.h" + +class BOP_Edge +{ +private: + BOP_Index m_vertexs[2]; + BOP_Indexs m_faces; + + bool containsFace(BOP_Index i); + +public: + BOP_Edge(BOP_Index v1, BOP_Index v2); + inline BOP_Index getVertex1() { return m_vertexs[0];}; + inline BOP_Index getVertex2() { return m_vertexs[1];}; + void replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex); + inline BOP_Index getFace(unsigned int i){return m_faces[i];}; + inline unsigned int getNumFaces(){return m_faces.size();}; + inline BOP_Indexs &getFaces(){return m_faces;}; + void addFace(BOP_Index face); +}; + +#endif diff --git a/intern/boolop/intern/BOP_Face.cpp b/intern/boolop/intern/BOP_Face.cpp new file mode 100644 index 00000000000..80c917f2838 --- /dev/null +++ b/intern/boolop/intern/BOP_Face.cpp @@ -0,0 +1,416 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Face.h" + +/******************************************************************************/ +/*** BOP_Face ***/ +/******************************************************************************/ + +/** + * Constructs a new face. + * @param plane face plane + * @param originalFace index of the original face + */ +BOP_Face::BOP_Face(MT_Plane3 plane, BOP_Index originalFace) +{ + m_plane = plane; + m_tag = UNCLASSIFIED; + m_originalFace = originalFace; +} + +/** + * Inverts this face. + */ +void BOP_Face::invert() +{ + getPlane().Invert(); + BOP_Index aux = m_indexs[0]; + m_indexs[0] = m_indexs[2]; + m_indexs[2] = aux; +} + +/******************************************************************************/ +/*** BOP_Face ***/ +/******************************************************************************/ + +/** + * Constructs a new triangle face. + * @param v1 vertex index + * @param v2 vertex index + * @param v3 vertex index + * @param plane face plane + * @param originalFace index of the original face + */ +BOP_Face3::BOP_Face3(BOP_Index v1, BOP_Index v2, BOP_Index v3, MT_Plane3 plane, BOP_Index originalFace): BOP_Face(plane,originalFace) +{ + m_indexs[0] = v1; + m_indexs[1] = v2; + m_indexs[2] = v3; + m_size = 3; +} + +/** + * Returns the relative edge index (1,2,3) for the specified vertex indexs. + * @param v1 vertex index + * @param v2 vertex index + * @param e relative edge index (1,2,3) + * @return true if (v1,v2) is an edge of this face, false otherwise + */ +bool BOP_Face3::getEdgeIndex(BOP_Index v1, BOP_Index v2, unsigned int &e) +{ + if (m_indexs[0] == v1) { + if (m_indexs[1] == v2) { + e = 1; + } + else if (m_indexs[2] == v2) { + e = 3; + } + else + return false; + } + else if (m_indexs[1] == v1) { + if (m_indexs[0] == v2) { + e = 1; + } + else if (m_indexs[2] == v2) { + e = 2; + } + else + return false; + } + else if (m_indexs[2] == v1) { + if (m_indexs[0] == v2) { + e = 3; + } + else if (m_indexs[1] == v2) { + e = 2; + } + else + return false; + }else { + return false; + } + + return true; +} + +/** + * Returns if this face contains the specified vertex index. + * @param v vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face3::containsVertex(BOP_Index v) +{ + return (m_indexs[0] == v || m_indexs[1] == v || m_indexs[2] == v); +} + +/** + * Returns the neighbours of the specified vertex index. + * @param v vertex index + * @param prev previous vertex index + * @param next next vertex index + * @return true if this face contains the vertex index v, false otherwise + */ +bool BOP_Face3::getNeighbours(BOP_Index v, BOP_Index &prev, BOP_Index &next) +{ + if (m_indexs[0] == v) { + prev = m_indexs[2]; + next = m_indexs[1]; + } + else if (m_indexs[1] == v) { + prev = m_indexs[0]; + next = m_indexs[2]; + } + else if (m_indexs[2] == v) { + prev = m_indexs[1]; + next = m_indexs[0]; + } + else return false; + + return true; +} + +/** + * Returns the previous neighbour of the specified vertex index. + * @param v vertex index + * @param w previous vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face3::getPreviousVertex(BOP_Index v, BOP_Index &w) +{ + if (m_indexs[0] == v) w = m_indexs[2]; + else if (m_indexs[1] == v) w = m_indexs[0]; + else if (m_indexs[2] == v) w = m_indexs[1]; + else return false; + + return true; +} + +/** + * Returns the next neighbour of the specified vertex index. + * @param v vertex index + * @param w vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face3::getNextVertex(BOP_Index v, BOP_Index &w) +{ + if (m_indexs[0] == v) w = m_indexs[1]; + else if (m_indexs[1] == v) w = m_indexs[2]; + else if (m_indexs[2] == v) w = m_indexs[0]; + else return false; + + return true; +} + +/** + * Replaces a face vertex index. + * @param oldIndex old vertex index + * @param newIndex new vertex index + */ +void BOP_Face3::replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex) +{ + if (m_indexs[0] == oldIndex) m_indexs[0] = newIndex; + else if (m_indexs[1] == oldIndex) m_indexs[1] = newIndex; + else if (m_indexs[2] == oldIndex) m_indexs[2] = newIndex; +} + +/******************************************************************************/ +/*** BOP_Face4 ***/ +/******************************************************************************/ + +/** + * Constructs a new quad face. + * @param v1 vertex index + * @param v2 vertex index + * @param v3 vertex index + * @param v4 vertex index + * @param plane face plane + * @param originalFace index of the original face + */ +BOP_Face4::BOP_Face4(BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, MT_Plane3 plane, + BOP_Index originalFace): + BOP_Face(plane,originalFace) +{ + m_indexs[0] = v1; + m_indexs[1] = v2; + m_indexs[2] = v3; + m_indexs[3] = v4; + + m_size = 4; +} + +/** + * Returns if this face contains the specified vertex index. + * @param v vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face4::containsVertex(BOP_Index v) +{ + return (m_indexs[0] == v || m_indexs[1] == v || m_indexs[2] == v || m_indexs[3]==v); +} + +/** + * Returns the neighbours of the specified vertex index. + * @param v vertex index + * @param prev previous vertex index + * @param next next vertex index + * @param opp opposite vertex index + * @return true if this face contains the vertex index v, false otherwise + */ +bool BOP_Face4::getNeighbours(BOP_Index v, BOP_Index &prev, BOP_Index &next, BOP_Index &opp) +{ + if (m_indexs[0] == v) { + prev = m_indexs[3]; + next = m_indexs[1]; + opp = m_indexs[2]; + } + else if (m_indexs[1] == v) { + prev = m_indexs[0]; + next = m_indexs[2]; + opp = m_indexs[3]; + } + else if (m_indexs[2] == v) { + prev = m_indexs[1]; + next = m_indexs[3]; + opp = m_indexs[0]; + } + else if (m_indexs[3] == v) { + prev = m_indexs[2]; + next = m_indexs[0]; + opp = m_indexs[1]; + } + else return false; + + return true; +} + +/** + * Returns the previous neighbour of the specified vertex index. + * @param v vertex index + * @param w previous vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face4::getPreviousVertex(BOP_Index v, BOP_Index &w) +{ + if (m_indexs[0] == v) w = m_indexs[3]; + else if (m_indexs[1] == v) w = m_indexs[0]; + else if (m_indexs[2] == v) w = m_indexs[1]; + else if (m_indexs[3] == v) w = m_indexs[2]; + else return false; + + return true; +} + +/** + * Returns the next neighbour of the specified vertex index. + * @param v vertex index + * @param w next vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face4::getNextVertex(BOP_Index v, BOP_Index &w) +{ + if (m_indexs[0] == v) w = m_indexs[1]; + else if (m_indexs[1] == v) w = m_indexs[2]; + else if (m_indexs[2] == v) w = m_indexs[3]; + else if (m_indexs[3] == v) w = m_indexs[0]; + else return false; + + return true; +} + +/** + * Returns the opposite neighbour of the specified vertex index. + * @param v vertex index + * @param w opposite vertex index + * @return true if this face contains the specified vertex index, false otherwise + */ +bool BOP_Face4::getOppositeVertex(BOP_Index v, BOP_Index &w) +{ + if (m_indexs[0] == v) + w = m_indexs[2]; + else if (m_indexs[1] == v) + w = m_indexs[3]; + else if (m_indexs[2] == v) + w = m_indexs[0]; + else if (m_indexs[3] == v) + w = m_indexs[1]; + else + return false; + + return true; +} + +/** + * Replaces a face vertex index. + * @param oldIndex old vertex index + * @param newIndex new vertex index + */ +void BOP_Face4::replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex) +{ + if (m_indexs[0] == oldIndex) m_indexs[0] = newIndex; + else if (m_indexs[1] == oldIndex) m_indexs[1] = newIndex; + else if (m_indexs[2] == oldIndex) m_indexs[2] = newIndex; + else if (m_indexs[3] == oldIndex) m_indexs[3] = newIndex; +} + +/** + * Returns the relative edge index (1,2,3,4) for the specified vertex indexs. + * @param v1 vertex index + * @param v2 vertex index + * @param e relative edge index (1,2,3,4) + * @return true if (v1,v2) is an edge of this face, false otherwise + */ +bool BOP_Face4::getEdgeIndex(BOP_Index v1, BOP_Index v2, unsigned int &e) +{ + if (m_indexs[0] == v1) { + if (m_indexs[1] == v2) { + e = 1; + } + else if (m_indexs[3] == v2) { + e = 4; + } + else + return false; + } + else if (m_indexs[1] == v1) { + if (m_indexs[0] == v2) { + e = 1; + } + else if (m_indexs[2] == v2) { + e = 2; + } + else + return false; + } + else if (m_indexs[2] == v1) { + if (m_indexs[1] == v2) { + e = 2; + } + else if (m_indexs[3] == v2) { + e = 3; + } + else + return false; + } + else if (m_indexs[3] == v1) { + if (m_indexs[2] == v2) { + e = 3; + } + else if (m_indexs[0] == v2) { + e = 4; + } + else + return false; + } + else return false; + + return true; +} + +/** + * Implements operator <<. + */ +ostream &operator<<(ostream &stream, BOP_Face *f) +{ + char aux[20]; + BOP_stringTAG(f->m_tag,aux); + if (f->size()==3) { + stream << "Face[" << f->getVertex(0) << "," << f->getVertex(1) << ","; + stream << f->getVertex(2) << "] (" << aux << ") <-- " << f->m_originalFace; + } + else { + stream << "Face[" << f->getVertex(0) << "," << f->getVertex(1) << ","; + stream << f->getVertex(2) << "," << f->getVertex(3) << "] (" << aux; + stream << ") <-- " << f->m_originalFace; + } + + return stream; +} diff --git a/intern/boolop/intern/BOP_Face.h b/intern/boolop/intern/BOP_Face.h new file mode 100644 index 00000000000..7db5ab1fe5c --- /dev/null +++ b/intern/boolop/intern/BOP_Face.h @@ -0,0 +1,105 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_FACE_H +#define BOP_FACE_H + +#include "BOP_Tag.h" +#include "MT_Plane3.h" +#include "BOP_Indexs.h" +#include +#include +using namespace std; + +class BOP_Face; + +typedef vector BOP_Faces; +typedef vector::iterator BOP_IT_Faces; + +class BOP_Face +{ +private: + BOP_TAG m_tag; + MT_Plane3 m_plane; + BOP_Index m_originalFace; + +protected: + BOP_Index m_indexs[4]; + unsigned int m_size; + +public: + BOP_Face(MT_Plane3 plane, BOP_Index originalFace); + virtual ~BOP_Face(){}; + inline MT_Plane3 getPlane() const {return m_plane;}; + inline void setPlane(const MT_Plane3 plane) {m_plane = plane;}; + inline BOP_TAG getTAG() const {return m_tag;}; + inline void setTAG(const BOP_TAG t) {m_tag = t;}; + inline BOP_Index getOriginalFace() const {return m_originalFace;}; + inline void setOriginalFace(const BOP_Index originalFace) {m_originalFace=originalFace;}; + inline BOP_Index getVertex(unsigned int i) const {return m_indexs[i];}; + inline void setVertex(const BOP_Index idx, const BOP_Index i) {m_indexs[idx]=i;}; + void invert(); + inline unsigned int size() const {return m_size;}; + + virtual bool getEdgeIndex(BOP_Index v1, BOP_Index v2, unsigned int &e) = 0; + virtual void replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex) = 0; + virtual bool containsVertex(BOP_Index v) = 0; + + friend ostream &operator<<(ostream &stream, BOP_Face *f); +}; + +class BOP_Face3: public BOP_Face +{ +public: + BOP_Face3(BOP_Index i, BOP_Index j, BOP_Index k, MT_Plane3 p, BOP_Index originalFace); + bool getEdgeIndex(BOP_Index v1, BOP_Index v2, unsigned int &e); + void replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex); + bool containsVertex(BOP_Index v); + + bool getNeighbours(BOP_Index v, BOP_Index &prev, BOP_Index &next); + bool getPreviousVertex(BOP_Index v, BOP_Index &w); + bool getNextVertex(BOP_Index v, BOP_Index &w); +}; + +class BOP_Face4: public BOP_Face +{ +public: + BOP_Face4(BOP_Index i, BOP_Index j, BOP_Index k, BOP_Index l, MT_Plane3 p, BOP_Index originalFace); + bool getEdgeIndex(BOP_Index v1, BOP_Index v2, unsigned int &e); + void replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex); + bool containsVertex(BOP_Index v); + + bool getNeighbours(BOP_Index v, BOP_Index &prev, BOP_Index &next, BOP_Index &opp); + bool getPreviousVertex(BOP_Index v, BOP_Index &w); + bool getNextVertex(BOP_Index v, BOP_Index &w); + bool getOppositeVertex(BOP_Index v, BOP_Index &w); +}; + +#endif diff --git a/intern/boolop/intern/BOP_Face2Face.cpp b/intern/boolop/intern/BOP_Face2Face.cpp new file mode 100644 index 00000000000..6d7c671870d --- /dev/null +++ b/intern/boolop/intern/BOP_Face2Face.cpp @@ -0,0 +1,1270 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Face2Face.h" +#include "BOP_BBox.h" + +// TAGS for segment classification in x-segment creation +// sA -> point of sA +// sB -> point of sB +// sX -> point of sA and SB +#define sA_sB 12 +#define sB_sA 21 +#define sX_sA 31 +#define sA_sX 13 +#define sX_sB 32 +#define sB_sX 23 +#define sX_sX 33 + +#define sA_sA_sB 112 +#define sB_sB_sA 221 +#define sB_sA_sA 211 +#define sA_sB_sB 122 +#define sA_sB_sA 121 +#define sB_sA_sB 212 +#define sA_sX_sB 132 +#define sB_sX_sA 231 +#define sX_sA_sB 312 +#define sX_sB_sA 321 +#define sA_sB_sX 123 +#define sB_sA_sX 213 + +#define sA_sA_sB_sB 1122 +#define sB_sB_sA_sA 2211 +#define sA_sB_sA_sB 1212 +#define sB_sA_sB_sA 2121 +#define sA_sB_sB_sA 1221 +#define sB_sA_sA_sB 2112 + +void BOP_intersectCoplanarFaces(BOP_Mesh* mesh, + BOP_Faces* facesB, + BOP_Face* faceA, + BOP_Face* faceB, + bool invert); + +void BOP_intersectCoplanarFaces(BOP_Mesh* mesh, + BOP_Faces* facesB, + BOP_Face* faceB, + BOP_Segment sA, + MT_Plane3 planeA, + bool invert); + +void BOP_intersectNonCoplanarFaces(BOP_Mesh* mesh, + BOP_Faces* facesA, + BOP_Faces* facesB, + BOP_Face* faceA, + BOP_Face* faceB); + +void BOP_getPoints(BOP_Mesh* mesh, + BOP_Face* faceA, + BOP_Segment& sA, + MT_Plane3 planeB, + MT_Point3* points, + unsigned int* faces, + unsigned int& size, + unsigned int faceValue); + +void BOP_mergeSort(MT_Point3 *points, unsigned int *face, unsigned int &size, bool &invertA, bool &invertB); + +void BOP_createXS(BOP_Mesh* mesh, + BOP_Face* faceA, + BOP_Face* faceB, + BOP_Segment sA, + BOP_Segment sB, + bool invert, + BOP_Segment* segments); + +void BOP_createXS(BOP_Mesh* mesh, + BOP_Face* faceA, + BOP_Face* faceB, + MT_Plane3 planeA, + MT_Plane3 planeB, + BOP_Segment sA, + BOP_Segment sB, + bool invert, + BOP_Segment* segments); + +BOP_Index BOP_getVertexIndex(BOP_Mesh* mesh, + MT_Point3 point, + unsigned int cfgA, + unsigned int cfgB, + BOP_Index vA, + BOP_Index vB, + bool invert); + +BOP_Index BOP_getVertexIndex(BOP_Mesh *mesh, MT_Point3 point, unsigned int cfg, BOP_Index v); + +void triangulate(BOP_Mesh *mesh, BOP_Faces *faces, BOP_Face *face, BOP_Segment s); + +BOP_Face *BOP_getOppositeFace(BOP_Mesh* mesh, + BOP_Faces* faces, + BOP_Face* face, + BOP_Edge* edge); + +bool BOP_overlap(MT_Vector3 normal, + MT_Point3 p1, + MT_Point3 p2, + MT_Point3 p3, + MT_Point3 q1, + MT_Point3 q2, + MT_Point3 q3); + +void BOP_mergeVertexs(BOP_Mesh *mesh, unsigned int firstFace); + + +/** + * Computes intersections between faces of both lists. + * @param mesh mesh that contains the faces, edges and vertices + * @param facesA set of faces from object A + * @param facesB set of faces from object B + */ +void BOP_Face2Face(BOP_Mesh *mesh, BOP_Faces *facesA, BOP_Faces *facesB) +{ + for(unsigned int idxFaceA=0;idxFaceAsize();idxFaceA++) { + BOP_Face *faceA = (*facesA)[idxFaceA]; + MT_Plane3 planeA = faceA->getPlane(); + MT_Point3 p1 = mesh->getVertex(faceA->getVertex(0))->getPoint(); + MT_Point3 p2 = mesh->getVertex(faceA->getVertex(1))->getPoint(); + MT_Point3 p3 = mesh->getVertex(faceA->getVertex(2))->getPoint(); + + BOP_BBox boxA(p1,p2,p3); + + for(unsigned int idxFaceB=0; + idxFaceBsize() && (faceA->getTAG() != BROKEN) && (faceA->getTAG() != PHANTOM);) { + BOP_Face *faceB = (*facesB)[idxFaceB]; + if ((faceB->getTAG() != BROKEN) && (faceB->getTAG() != PHANTOM)) { + BOP_BBox boxB(mesh->getVertex(faceB->getVertex(0))->getPoint(), + mesh->getVertex(faceB->getVertex(1))->getPoint(), + mesh->getVertex(faceB->getVertex(2))->getPoint()); + if (boxA.intersect(boxB)) { + + MT_Plane3 planeB = faceB->getPlane(); + if (BOP_containsPoint(planeB,p1) && + BOP_containsPoint(planeB,p2) && + BOP_containsPoint(planeB,p3)) { + if (BOP_orientation(planeB,planeA)>0) { + BOP_intersectCoplanarFaces(mesh,facesB,faceA,faceB,false); + } + } + else { + BOP_intersectNonCoplanarFaces(mesh,facesA,facesB,faceA,faceB); + } + } + } + if (faceB->getTAG()==BROKEN){ + facesB->erase(facesB->begin()+idxFaceB); + }else + idxFaceB++; + } + } + + + // Clean broken faces from facesA + BOP_IT_Faces it; + it = facesA->begin(); + while (it != facesA->end()) { + BOP_Face *face = *it; + if (face->getTAG() == BROKEN) it = facesA->erase(it); + else it++; + } + /* + it = facesB->begin(); + while (it != facesB->end()) { + BOP_Face *face = *it; + if (face->getTAG() == BROKEN) it = facesB->erase(it); + else it++; + } + */ +} + +/** + * Computes intesections of coplanars faces from object A with faces from object B. + * @param mesh mesh that contains the faces, edges and vertices + * @param facesA set of faces from object A + * @param facesB set of faces from object B + */ +void BOP_sew(BOP_Mesh *mesh, BOP_Faces *facesA, BOP_Faces *facesB) +{ + for(unsigned int idxFaceB = 0; idxFaceB < facesB->size(); idxFaceB++) { + BOP_Face *faceB = (*facesB)[idxFaceB]; + MT_Plane3 planeB = faceB->getPlane(); + MT_Point3 p1 = mesh->getVertex(faceB->getVertex(0))->getPoint(); + MT_Point3 p2 = mesh->getVertex(faceB->getVertex(1))->getPoint(); + MT_Point3 p3 = mesh->getVertex(faceB->getVertex(2))->getPoint(); + + for(unsigned int idxFaceA = 0; + idxFaceA < facesA->size() && + faceB->getTAG() != BROKEN && + faceB->getTAG() != PHANTOM; + idxFaceA++) { + BOP_Face *faceA = (*facesA)[idxFaceA]; + if ((faceA->getTAG() != BROKEN)&&(faceA->getTAG() != PHANTOM)) { + MT_Plane3 planeA = faceA->getPlane(); + if (BOP_containsPoint(planeA,p1) && + BOP_containsPoint(planeA,p2) && + BOP_containsPoint(planeA,p3)) { + if (BOP_orientation(planeA,planeB) > 0) { + BOP_intersectCoplanarFaces(mesh,facesA,faceB,faceA,true); + } + } + } + } + } +} + +/** + * Triangulates faceB using edges of faceA that both are complanars. + * @param mesh mesh that contains the faces, edges and vertices + * @param facesB set of faces from object B + * @param faceA face from object A + * @param faceB face from object B + * @param invert indicates if faceA has priority over faceB + */ +void BOP_intersectCoplanarFaces(BOP_Mesh* mesh, + BOP_Faces* facesB, + BOP_Face* faceA, + BOP_Face* faceB, + bool invert) +{ + unsigned int oldSize = facesB->size(); + unsigned int originalFaceB = faceB->getOriginalFace(); + + MT_Point3 p1 = mesh->getVertex(faceA->getVertex(0))->getPoint(); + MT_Point3 p2 = mesh->getVertex(faceA->getVertex(1))->getPoint(); + MT_Point3 p3 = mesh->getVertex(faceA->getVertex(2))->getPoint(); + + MT_Vector3 normal(faceA->getPlane().x(),faceA->getPlane().y(),faceA->getPlane().z()); + + MT_Vector3 p1p2 = p2-p1; + + MT_Plane3 plane1((p1p2.cross(normal).normalized()),p1); + + BOP_Segment sA; + sA.m_cfg1 = BOP_Segment::createVertexCfg(1); + sA.m_v1 = faceA->getVertex(0); + sA.m_cfg2 = BOP_Segment::createVertexCfg(2); + sA.m_v2 = faceA->getVertex(1); + + BOP_intersectCoplanarFaces(mesh,facesB,faceB,sA,plane1,invert); + + MT_Vector3 p2p3 = p3-p2; + MT_Plane3 plane2((p2p3.cross(normal).normalized()),p2); + + sA.m_cfg1 = BOP_Segment::createVertexCfg(2); + sA.m_v1 = faceA->getVertex(1); + sA.m_cfg2 = BOP_Segment::createVertexCfg(3); + sA.m_v2 = faceA->getVertex(2); + + if (faceB->getTAG() == BROKEN) { + for(unsigned int idxFace = oldSize; idxFace < facesB->size(); idxFace++) { + BOP_Face *face = (*facesB)[idxFace]; + if (face->getTAG() != BROKEN && originalFaceB == face->getOriginalFace()) + BOP_intersectCoplanarFaces(mesh,facesB,face,sA,plane2,invert); + } + } + else { + BOP_intersectCoplanarFaces(mesh,facesB,faceB,sA,plane2,invert); + } + + MT_Vector3 p3p1 = p1-p3; + MT_Plane3 plane3((p3p1.cross(normal).normalized()),p3); + + sA.m_cfg1 = BOP_Segment::createVertexCfg(3); + sA.m_v1 = faceA->getVertex(2); + sA.m_cfg2 = BOP_Segment::createVertexCfg(1); + sA.m_v2 = faceA->getVertex(0); + + if (faceB->getTAG() == BROKEN) { + for(unsigned int idxFace = oldSize; idxFace < facesB->size(); idxFace++) { + BOP_Face *face = (*facesB)[idxFace]; + if (face->getTAG() != BROKEN && originalFaceB == face->getOriginalFace()) + BOP_intersectCoplanarFaces(mesh,facesB,face,sA,plane3,invert); + } + } + else { + BOP_intersectCoplanarFaces(mesh,facesB,faceB,sA,plane3,invert); + } +} + +/** + * Triangulates faceB using segment sA and planeA. + * @param mesh mesh that contains the faces, edges and vertices + * @param facesB set of faces from object B + * @param faceB face from object B + * @param sA segment to intersect with faceB + * @param planeA plane to intersect with faceB + * @param invert indicates if sA has priority over faceB + */ +void BOP_intersectCoplanarFaces(BOP_Mesh* mesh, + BOP_Faces* facesB, + BOP_Face* faceB, + BOP_Segment sA, + MT_Plane3 planeA, + bool invert) +{ + BOP_Segment sB = BOP_splitFace(planeA,mesh,faceB); + + if (BOP_Segment::isDefined(sB.m_cfg1)) { + BOP_Segment xSegment[2]; + BOP_createXS(mesh,NULL,faceB,planeA,MT_Plane3(),sA,sB,invert,xSegment); + if (BOP_Segment::isDefined(xSegment[1].m_cfg1)) { + unsigned int sizefaces = mesh->getNumFaces(); + triangulate(mesh,facesB,faceB,xSegment[1]); + BOP_mergeVertexs(mesh,sizefaces); + } + } +} + +/** + * Triangulates faceB using edges of faceA that both are not complanars. + * @param mesh mesh that contains the faces, edges and vertices + * @param facesB set of faces from object B + * @param faceA face from object A + * @param faceB face from object B + */ +void BOP_intersectNonCoplanarFaces(BOP_Mesh *mesh, + BOP_Faces *facesA, + BOP_Faces *facesB, + BOP_Face *faceA, + BOP_Face *faceB) +{ + // Obtain segments of faces A and B from the intersection with their planes + BOP_Segment sA = BOP_splitFace(faceB->getPlane(),mesh,faceA); + BOP_Segment sB = BOP_splitFace(faceA->getPlane(),mesh,faceB); + + if (BOP_Segment::isDefined(sA.m_cfg1) && BOP_Segment::isDefined(sB.m_cfg1)) { + // There is an intesection, build the X-segment + BOP_Segment xSegment[2]; + BOP_createXS(mesh,faceA,faceB,sA,sB,false,xSegment); + + unsigned int sizefaces = mesh->getNumFaces(); + triangulate(mesh,facesA,faceA,xSegment[0]); + BOP_mergeVertexs(mesh,sizefaces); + + sizefaces = mesh->getNumFaces(); + triangulate(mesh,facesB,faceB,xSegment[1]); + BOP_mergeVertexs(mesh,sizefaces); + } +} + +/** + * Tests if faces since firstFace have all vertexs non-coincident of colinear, otherwise repairs the mesh. + * @param mesh mesh that contains the faces, edges and vertices + * @param firstFace first face index to be tested + */ +void BOP_mergeVertexs(BOP_Mesh *mesh, unsigned int firstFace) +{ + unsigned int numFaces = mesh->getNumFaces(); + for(unsigned int idxFace = firstFace; idxFace < numFaces; idxFace++) { + BOP_Face *face = mesh->getFace(idxFace); + if ((face->getTAG() != BROKEN) && (face->getTAG() != PHANTOM)) { + BOP_Index v1 = face->getVertex(0); + BOP_Index v2 = face->getVertex(1); + BOP_Index v3 = face->getVertex(2); + MT_Point3 vertex1 = mesh->getVertex(v1)->getPoint(); + MT_Point3 vertex2 = mesh->getVertex(v2)->getPoint(); + MT_Point3 vertex3 = mesh->getVertex(v3)->getPoint(); + int dist12 = BOP_comp(vertex1,vertex2); + int dist13 = BOP_comp(vertex1,vertex3); + int dist23 = BOP_comp(vertex2,vertex3); + + if (dist12 == 0) { + if (dist13 == 0) { + // v1 ~= v2 , v1 ~= v3 , v2 ~= v3 + mesh->replaceVertexIndex(v2,v1); + mesh->replaceVertexIndex(v3,v1); + } + else { + if (dist23 == 0) { + mesh->replaceVertexIndex(v1,v2); + mesh->replaceVertexIndex(v3,v2); + } + else { + mesh->replaceVertexIndex(v1,v2); + } + } + } + else { + if (dist13 == 0) { + // v1 ~= v3 + if (dist23 == 0) { + mesh->replaceVertexIndex(v1,v3); + mesh->replaceVertexIndex(v2,v3); + } + else { + mesh->replaceVertexIndex(v1,v3); + } + } + else { + if (dist23 == 0) { + // v2 ~= v3 + mesh->replaceVertexIndex(v2,v3); + } else { + // all differents + if (BOP_collinear(vertex1,vertex2,vertex3)) { + // collinear triangle + face->setTAG(PHANTOM); + } + } + } + } + } + } +} + +/** + * Obtains the points of the segment created from the intersection between faceA and planeB. + * @param mesh mesh that contains the faces, edges and vertices + * @param faceA intersected face + * @param sA segment of the intersection between faceA and planeB + * @param planeB intersected plane + * @param points array of points where the new points are saved + * @param faces array of relative face index to the points + * @param size size of arrays points and faces + * @param faceValue relative face index of new points + */ +void BOP_getPoints(BOP_Mesh* mesh, + BOP_Face* faceA, + BOP_Segment& sA, + MT_Plane3 planeB, + MT_Point3* points, + unsigned int* faces, + unsigned int& size, + unsigned int faceValue) +{ + MT_Point3 p1,p2; + + if (BOP_Segment::isDefined(sA.m_cfg1)) { + if (BOP_Segment::isEdge(sA.m_cfg1)) { + // the new point becomes of split faceA edge + p1 = BOP_splitEdge(planeB,mesh,faceA,BOP_Segment::getEdge(sA.m_cfg1)); + } + else if (BOP_Segment::isVertex(sA.m_cfg1)) { + // the new point becomes of vertex faceA + p1 = mesh->getVertex(BOP_Segment::getVertex(sA.m_v1))->getPoint(); + } + + if (BOP_Segment::isDefined(sA.m_cfg2)) { + if (BOP_Segment::isEdge(sA.m_cfg2)) { + p2 = BOP_splitEdge(planeB,mesh,faceA,BOP_Segment::getEdge(sA.m_cfg2)); + } + else if (BOP_Segment::isVertex(sA.m_cfg2)) { + p2 = mesh->getVertex(BOP_Segment::getVertex(sA.m_v2))->getPoint(); + } + points[size] = p1; + points[size+1] = p2; + faces[size] = faceValue; + faces[size+1] = faceValue; + size += 2; + } + + else { + points[size] = p1; + faces[size] = faceValue; + size++; + } + } +} + +/** + * Sorts the colinear points and relative face indices. + * @param points array of points where the new points are saved + * @param faces array of relative face index to the points + * @param size size of arrays points and faces + * @param invertA indicates if points of same relative face had been exchanged + */ +void BOP_mergeSort(MT_Point3 *points, unsigned int *face, unsigned int &size, bool &invertA, bool &invertB) { + MT_Point3 sortedPoints[4]; + unsigned int sortedFaces[4]; + unsigned int position[4]; + if (size == 2) { + + // Trivial case, only test the merge ... + if (BOP_comp(0,points[0].distance(points[1]))==0) { + face[0] = 3; + size--; + } + } + else { + // size is 3 or 4 + // Get segment extreme points + MT_Scalar maxDistance = -1; + for(unsigned int i=0;i maxDistance){ + maxDistance = distance; + position[0] = i; + position[size-1] = j; + } + } + } + + // Get segment inner points + position[1] = position[2] = size; + for(unsigned int i=0;i d2) { + unsigned int aux = position[1]; + position[1] = position[2]; + position[2] = aux; + } + } + + // Sort data + for(unsigned int i=0;i 0 && sB.m_cfg1 > 0 . + * @param mesh mesh that contains the faces, edges and vertices + * @param faceA face of object A + * @param faceB face of object B + * @param sA segment of intersection between faceA and planeB + * @param sB segment of intersection between faceB and planeA + * @param invert indicates if faceA has priority over faceB + * @param segmemts array of the output x-segments + */ +void BOP_createXS(BOP_Mesh* mesh, + BOP_Face* faceA, + BOP_Face* faceB, + BOP_Segment sA, + BOP_Segment sB, + bool invert, + BOP_Segment* segments) { + return BOP_createXS(mesh, faceA, faceB, faceA->getPlane(), faceB->getPlane(), + sA, sB, invert, segments); +} + +/** + * Computes the x-segment of two segments (the shared interval). The segments needs to have sA.m_cfg1 > 0 && sB.m_cfg1 > 0 . + * @param mesh mesh that contains the faces, edges and vertices + * @param faceA face of object A + * @param faceB face of object B + * @param planeA plane of faceA + * @param planeB plane of faceB + * @param sA segment of intersection between faceA and planeB + * @param sB segment of intersection between faceB and planeA + * @param invert indicates if faceA has priority over faceB + * @param segmemts array of the output x-segments + */ +void BOP_createXS(BOP_Mesh* mesh, + BOP_Face* faceA, + BOP_Face* faceB, + MT_Plane3 planeA, + MT_Plane3 planeB, + BOP_Segment sA, + BOP_Segment sB, + bool invert, + BOP_Segment* segments) +{ + MT_Point3 points[4]; // points of the segments + unsigned int face[4]; // relative face indexs (1 => faceA, 2 => faceB) + unsigned int size = 0; // size of points and relative face indexs + + BOP_getPoints(mesh, faceA, sA, planeB, points, face, size, 1); + BOP_getPoints(mesh, faceB, sB, planeA, points, face, size, 2); + + bool invertA = false; + bool invertB = false; + BOP_mergeSort(points,face,size,invertA,invertB); + + if (invertA) sA.invert(); + if (invertB) sB.invert(); + + // Compute the configuration label + unsigned int label = 0; + for(unsigned int i =0; i < size; i++) { + label = face[i]+label*10; + } + + if (size == 1) { + // Two coincident points + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg1; + + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[0], sA.m_cfg1, sB.m_cfg1, + sA.m_v1, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + segments[0].m_cfg2 = segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + } + else if (size == 2) { + switch(label) { + // Two non-coincident points + case sA_sB: + case sB_sA: + segments[0].m_cfg1 = + segments[1].m_cfg1 = + segments[0].m_cfg2 = + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + // Two coincident points and one non-coincident of sA + case sA_sX: + segments[0].m_cfg1 = sA.m_cfg2; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[1], sA.m_cfg2, sB.m_cfg1, + sA.m_v2, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + case sX_sA: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[0], sA.m_cfg1, sB.m_cfg1, + sA.m_v1, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + // Two coincident points and one non-coincident of sB + case sB_sX: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg2; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[1], sA.m_cfg1, sB.m_cfg2, + sA.m_v1, sB.m_v2, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + case sX_sB: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[0], sA.m_cfg1, sB.m_cfg1, + sA.m_v1, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + // coincident points 2-2 + case sX_sX: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[0], sA.m_cfg1, sB.m_cfg1, + sA.m_v1, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.m_cfg2; + segments[1].m_cfg2 = sB.m_cfg2; + segments[0].m_v2 = BOP_getVertexIndex(mesh, points[1], sA.m_cfg2, sB.m_cfg2, + sA.m_v2, sB.m_v2, invert); + segments[1].m_v2 = segments[0].m_v2; + break; + + default: + break; + } + } + else if (size == 3) { + switch(label) { + case sA_sA_sB: + case sB_sA_sA: + case sA_sB_sB: + case sB_sB_sA: + segments[0].m_cfg1 = + segments[1].m_cfg1 = + segments[0].m_cfg2 = + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case sA_sB_sA: + segments[1].m_v1 = BOP_getVertexIndex(mesh,points[1],sB.m_cfg1,sB.m_v1); + segments[1].m_cfg1 = sB.m_cfg1; + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[0].m_cfg1 = sA.getConfig(); + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[0].m_v1 = segments[1].m_v1; + break; + + case sB_sA_sB: + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sA.m_cfg1,sA.m_v1); + segments[0].m_cfg1 = sA.m_cfg1; + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg1 = sB.getConfig(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_v1 = segments[0].m_v1; + break; + + case sA_sX_sB: + segments[0].m_cfg1 = sA.m_cfg2; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[1], sA.m_cfg2, sB.m_cfg1, + sA.m_v2, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case sB_sX_sA: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg2; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[1], sA.m_cfg1, sB.m_cfg2, + sA.m_v1, sB.m_v2, invert); + segments[1].m_v1 = segments[0].m_v1; + segments[0].m_cfg2 = BOP_Segment::createUndefinedCfg(); + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case sX_sA_sB: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[0], sA.m_cfg1, sB.m_cfg1, + sA.m_v1, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.m_cfg2; + segments[1].m_cfg2 = sB.getConfig(); + segments[0].m_v2 = BOP_getVertexIndex(mesh, points[1], sA.m_cfg2, sA.m_v2); + segments[1].m_v2 = segments[0].m_v2; + break; + + case sX_sB_sA: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh, points[0], sA.m_cfg1, sB.m_cfg1, + sA.m_v1, sB.m_v1, invert); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.getConfig(); + segments[1].m_cfg2 = sB.m_cfg2; + segments[0].m_v2 = BOP_getVertexIndex(mesh,points[1],sB.m_cfg2,sB.m_v2); + segments[1].m_v2 = segments[0].m_v2; + break; + + case sA_sB_sX: + segments[0].m_cfg1 = sA.getConfig(); + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sB.m_cfg1,sB.m_v1); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.m_cfg2; + segments[1].m_cfg2 = sB.m_cfg2; + segments[0].m_v2 = BOP_getVertexIndex(mesh, points[2], sA.m_cfg2, sB.m_cfg2, + sA.m_v2, sB.m_v2, invert); + segments[1].m_v2 = segments[0].m_v2; + break; + + case sB_sA_sX: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.getConfig(); + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sA.m_cfg1,sA.m_v1); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.m_cfg2; + segments[1].m_cfg2 = sB.m_cfg2; + segments[0].m_v2 = BOP_getVertexIndex(mesh, points[2], sA.m_cfg2, sB.m_cfg2, + sA.m_v2, sB.m_v2, invert); + segments[1].m_v2 = segments[0].m_v2; + break; + + default: + break; + } + } + else { + // 4! + switch(label) { + case sA_sA_sB_sB: + case sB_sB_sA_sA: + segments[0].m_cfg1 = + segments[1].m_cfg1 = + segments[0].m_cfg2 = + segments[1].m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case sA_sB_sA_sB: + segments[0].m_cfg1 = sA.getConfig(); + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sB.m_cfg1,sB.m_v1); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.m_cfg2; + segments[1].m_cfg2 = sB.getConfig(); + segments[0].m_v2 = BOP_getVertexIndex(mesh,points[2],sA.m_cfg2,sA.m_v2); + segments[1].m_v2 = segments[0].m_v2; + break; + + case sB_sA_sB_sA: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.getConfig(); + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sA.m_cfg1,sA.m_v1); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.getConfig(); + segments[1].m_cfg2 = sB.m_cfg2; + segments[0].m_v2 = BOP_getVertexIndex(mesh,points[2],sB.m_cfg2,sB.m_v2); + segments[1].m_v2 = segments[0].m_v2; + break; + + case sA_sB_sB_sA: + segments[0].m_cfg1 = sA.getConfig(); + segments[1].m_cfg1 = sB.m_cfg1; + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sB.m_cfg1,sB.m_v1); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = segments[0].m_cfg1; + segments[1].m_cfg2 = sB.m_cfg2; + segments[0].m_v2 = BOP_getVertexIndex(mesh,points[2],sB.m_cfg2,sB.m_v2); + segments[1].m_v2 = segments[0].m_v2; + break; + + case sB_sA_sA_sB: + segments[0].m_cfg1 = sA.m_cfg1; + segments[1].m_cfg1 = sB.getConfig(); + segments[0].m_v1 = BOP_getVertexIndex(mesh,points[1],sA.m_cfg1,sA.m_v1); + segments[1].m_v1 = segments[0].m_v1; + + segments[0].m_cfg2 = sA.m_cfg2; + segments[1].m_cfg2 = segments[1].m_cfg1; + segments[0].m_v2 = BOP_getVertexIndex(mesh,points[2],sA.m_cfg2,sA.m_v2); + segments[1].m_v2 = segments[0].m_v2; + break; + + default: + break; + } + } + + segments[0].sort(); + segments[1].sort(); +} + +/** + * Computes the vertex index of a point. + * @param mesh mesh that contains the faces, edges and vertices + * @param point input point + * @param cfgA configuration of point on faceA + * @param cfgB configuration of point on faceB + * @param vA vertex index of point on faceA + * @param vB vertex index of point on faceB + * @param invert indicates if vA has priority over vB + * @return final vertex index in the mesh + */ +BOP_Index BOP_getVertexIndex(BOP_Mesh* mesh, + MT_Point3 point, + unsigned int cfgA, + unsigned int cfgB, + BOP_Index vA, + BOP_Index vB, + bool invert) +{ + if (BOP_Segment::isVertex(cfgA)) { // exists vertex index on A + if (BOP_Segment::isVertex(cfgB)) { // exists vertex index on B + // unify vertex indexs + if (invert) + return mesh->replaceVertexIndex(vA,vB); + else + return mesh->replaceVertexIndex(vB,vA); + } + else + return vA; + } + else {// does not exist vertex index on A + if (BOP_Segment::isVertex(cfgB)) // exists vertex index on B + return vB; + else {// does not exist vertex index on B + return mesh->addVertex(point); + } + } +} + +/** + * Computes the vertex index of a point. + * @param mesh mesh that contains the faces, edges and vertices + * @param cfg configuration of point + * @param v vertex index of point + * @return final vertex index in the mesh + */ +BOP_Index BOP_getVertexIndex(BOP_Mesh *mesh, MT_Point3 point, unsigned int cfg, BOP_Index v) +{ + if (BOP_Segment::isVertex(cfg)) // vertex existent + return v; + else { + return mesh->addVertex(point); + } +} + +/******************************************************************************/ +/*** TRIANGULATE ***/ +/******************************************************************************/ + +/** + * Triangulates the input face according to the specified segment. + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains the original face and the new triangulated faces + * @param face face to be triangulated + * @param s segment used to triangulate face + */ +void triangulate(BOP_Mesh *mesh, BOP_Faces *faces, BOP_Face *face, BOP_Segment s) +{ + if (BOP_Segment::isUndefined(s.m_cfg1)) { + // Nothing to do + } + else if (BOP_Segment::isVertex(s.m_cfg1)) { + // VERTEX(v1) + VERTEX(v2) => nothing to do + } + else if (BOP_Segment::isEdge(s.m_cfg1)) { + if (BOP_Segment::isVertex(s.m_cfg2) || BOP_Segment::isUndefined(s.m_cfg2)) { + // EDGE(v1) + VERTEX(v2) + BOP_Edge *edge = mesh->getEdge(face,BOP_Segment::getEdge(s.m_cfg1)); + BOP_triangulateA(mesh,faces,face,s.m_v1,BOP_Segment::getEdge(s.m_cfg1)); + BOP_Face *opposite = BOP_getOppositeFace(mesh,faces,face,edge); + if (opposite != NULL) { + unsigned int e; + opposite->getEdgeIndex(edge->getVertex1(), edge->getVertex2(),e); + BOP_triangulateA(mesh, faces, opposite, s.m_v1, e); + } + } + else { + // EDGE(v1) + EDGE(v2) + if (BOP_Segment::getEdge(s.m_cfg1) == BOP_Segment::getEdge(s.m_cfg2)) { + // EDGE(v1) == EDGE(v2) + BOP_Edge *edge = mesh->getEdge(face,BOP_Segment::getEdge(s.m_cfg1)); + BOP_triangulateD(mesh, faces, face, s.m_v1, s.m_v2, + BOP_Segment::getEdge(s.m_cfg1)); + BOP_Face *opposite = BOP_getOppositeFace(mesh,faces,face,edge); + if (opposite != NULL) { + unsigned int e; + opposite->getEdgeIndex(edge->getVertex1(), edge->getVertex2(),e); + BOP_triangulateD(mesh, faces, opposite, s.m_v1, s.m_v2, e); + } + } + else { // EDGE(v1) != EDGE(v2) + BOP_Edge *edge1 = mesh->getEdge(face,BOP_Segment::getEdge(s.m_cfg1)); + BOP_Edge *edge2 = mesh->getEdge(face,BOP_Segment::getEdge(s.m_cfg2)); + BOP_triangulateE(mesh, faces, face, s.m_v1, s.m_v2, + BOP_Segment::getEdge(s.m_cfg1), + BOP_Segment::getEdge(s.m_cfg2)); + BOP_Face *opposite = BOP_getOppositeFace(mesh,faces,face,edge1); + if (opposite != NULL) { + unsigned int e; + opposite->getEdgeIndex(edge1->getVertex1(), edge1->getVertex2(),e); + BOP_triangulateA(mesh, faces, opposite, s.m_v1, e); + } + opposite = BOP_getOppositeFace(mesh,faces,face,edge2); + if (opposite != NULL) { + unsigned int e; + opposite->getEdgeIndex(edge2->getVertex1(), edge2->getVertex2(),e); + BOP_triangulateA(mesh, faces, opposite, s.m_v2, e); + } + } + } + } + else if (BOP_Segment::isIn(s.m_cfg1)) { + if (BOP_Segment::isVertex(s.m_cfg2) || BOP_Segment::isUndefined(s.m_cfg2)) { + // IN(v1) + VERTEX(v2) + BOP_triangulateB(mesh,faces,face,s.m_v1); + } + else if (BOP_Segment::isEdge(s.m_cfg2)) { + // IN(v1) + EDGE(v2) + BOP_Edge *edge = mesh->getEdge(face,BOP_Segment::getEdge(s.m_cfg2)); + BOP_triangulateF(mesh,faces,face,s.m_v1,s.m_v2,BOP_Segment::getEdge(s.m_cfg2)); + BOP_Face *opposite = BOP_getOppositeFace(mesh,faces,face,edge); + if (opposite != NULL) { + unsigned int e; + opposite->getEdgeIndex(edge->getVertex1(), edge->getVertex2(),e); + BOP_triangulateA(mesh, faces, opposite, s.m_v2, e); + } + } + else // IN(v1) + IN(v2) + BOP_triangulateC(mesh,faces,face,s.m_v1,s.m_v2); + } +} + +/** + * Returns if a face is in the set of faces. + * @param faces set of faces + * @param face face to be searched + * @return if the face is inside faces + */ +bool BOP_containsFace(BOP_Faces *faces, BOP_Face *face) +{ + const BOP_IT_Faces facesEnd = faces->end(); + for(BOP_IT_Faces it=faces->begin();it!=facesEnd;it++) + { + if (*it == face) + return true; + } + + return false; +} + +/** + * Returns the first face of faces that shares the input edge of face. + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces + * @param face input face + * @param edge face's edge + * @return first face that shares the edge of input face + */ +BOP_Face *BOP_getOppositeFace(BOP_Mesh* mesh, + BOP_Faces* faces, + BOP_Face* face, + BOP_Edge* edge) +{ + if (edge == NULL) + return NULL; + + BOP_Indexs auxfaces = edge->getFaces(); + const BOP_IT_Indexs auxfacesEnd = auxfaces.end(); + for(BOP_IT_Indexs it = auxfaces.begin(); it != auxfacesEnd; it++) { + BOP_Face *auxface = mesh->getFace(*it); + if ((auxface != face) && (auxface->getTAG()!=BROKEN) && + BOP_containsFace(faces,auxface)) { + return auxface; + } + } + + return NULL; +} + +/******************************************************************************/ +/*** OVERLAPPING ***/ +/******************************************************************************/ + +/** + * Removes faces from facesB that are overlapped with anyone from facesA. + * @param mesh mesh that contains the faces, edges and vertices + * @param facesA set of faces from object A + * @param facesB set of faces from object B + */ +void BOP_removeOverlappedFaces(BOP_Mesh *mesh, BOP_Faces *facesA, BOP_Faces *facesB) +{ + for(unsigned int i=0;isize();i++) { + BOP_Face *faceI = (*facesA)[i]; + if (faceI->getTAG()==BROKEN) continue; + bool overlapped = false; + MT_Point3 p1 = mesh->getVertex(faceI->getVertex(0))->getPoint(); + MT_Point3 p2 = mesh->getVertex(faceI->getVertex(1))->getPoint(); + MT_Point3 p3 = mesh->getVertex(faceI->getVertex(2))->getPoint(); + for(unsigned int j=0;jsize();) { + BOP_Face *faceJ = (*facesB)[j]; + if (faceJ->getTAG()!=BROKEN) { + MT_Plane3 planeJ = faceJ->getPlane(); + if (BOP_containsPoint(planeJ,p1) && BOP_containsPoint(planeJ,p2) + && BOP_containsPoint(planeJ,p3)) { + MT_Point3 q1 = mesh->getVertex(faceJ->getVertex(0))->getPoint(); + MT_Point3 q2 = mesh->getVertex(faceJ->getVertex(1))->getPoint(); + MT_Point3 q3 = mesh->getVertex(faceJ->getVertex(2))->getPoint(); + if (BOP_overlap(MT_Vector3(planeJ.x(),planeJ.y(),planeJ.z()), + p1,p2,p3,q1,q2,q3)) { + facesB->erase(facesB->begin()+j,facesB->begin()+(j+1)); + faceJ->setTAG(BROKEN); + overlapped = true; + } + else j++; + } + else j++; + }else j++; + } + if (overlapped) faceI->setTAG(OVERLAPPED); + } +} + +/** + * Computes if triangle p1,p2,p3 is overlapped with triangle q1,q2,q3. + * @param normal normal of the triangle p1,p2,p3 + * @param p1 point of first triangle + * @param p2 point of first triangle + * @param p3 point of first triangle + * @param q1 point of second triangle + * @param q2 point of second triangle + * @param q3 point of second triangle + * @return if there is overlapping between both triangles + */ +bool BOP_overlap(MT_Vector3 normal, MT_Point3 p1, MT_Point3 p2, MT_Point3 p3, + MT_Point3 q1, MT_Point3 q2, MT_Point3 q3) +{ + MT_Vector3 p1p2 = p2-p1; + MT_Plane3 plane1(p1p2.cross(normal),p1); + + MT_Vector3 p2p3 = p3-p2; + MT_Plane3 plane2(p2p3.cross(normal),p2); + + MT_Vector3 p3p1 = p1-p3; + MT_Plane3 plane3(p3p1.cross(normal),p3); + + BOP_TAG tag1 = BOP_createTAG(BOP_classify(q1,plane1)); + BOP_TAG tag2 = BOP_createTAG(BOP_classify(q1,plane2)); + BOP_TAG tag3 = BOP_createTAG(BOP_classify(q1,plane3)); + BOP_TAG tagQ1 = BOP_createTAG(tag1,tag2,tag3); + if (tagQ1 == IN_IN_IN) return true; + + tag1 = BOP_createTAG(BOP_classify(q2,plane1)); + tag2 = BOP_createTAG(BOP_classify(q2,plane2)); + tag3 = BOP_createTAG(BOP_classify(q2,plane3)); + BOP_TAG tagQ2 = BOP_createTAG(tag1,tag2,tag3); + if (tagQ2 == IN_IN_IN) return true; + + tag1 = BOP_createTAG(BOP_classify(q3,plane1)); + tag2 = BOP_createTAG(BOP_classify(q3,plane2)); + tag3 = BOP_createTAG(BOP_classify(q3,plane3)); + BOP_TAG tagQ3 = BOP_createTAG(tag1,tag2,tag3); + if (tagQ3 == IN_IN_IN) return true; + + if ((tagQ1 & OUT_OUT_OUT) == 0 && (tagQ2 & OUT_OUT_OUT) == 0 && + (tagQ3 & OUT_OUT_OUT) == 0) return true; + else return false; +} diff --git a/intern/boolop/intern/BOP_Face2Face.h b/intern/boolop/intern/BOP_Face2Face.h new file mode 100644 index 00000000000..09ed4edd076 --- /dev/null +++ b/intern/boolop/intern/BOP_Face2Face.h @@ -0,0 +1,44 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_FACE2FACE_H +#define BOP_FACE2FACE_H + +#include "BOP_Mesh.h" +#include "BOP_Segment.h" +#include "BOP_Triangulator.h" +#include "BOP_Splitter.h" +#include "BOP_BSPTree.h" + +void BOP_Face2Face(BOP_Mesh *mesh, BOP_Faces *facesA, BOP_Faces *facesB); +void BOP_sew(BOP_Mesh *mesh, BOP_Faces *facesA, BOP_Faces *facesB); +void BOP_removeOverlappedFaces(BOP_Mesh *mesh, BOP_Faces *facesA, BOP_Faces *facesB); + +#endif diff --git a/intern/boolop/intern/BOP_Indexs.h b/intern/boolop/intern/BOP_Indexs.h new file mode 100644 index 00000000000..c5546e73252 --- /dev/null +++ b/intern/boolop/intern/BOP_Indexs.h @@ -0,0 +1,41 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_Indexs_H +#define BOP_Indexs_H + +#include +using namespace std; + +typedef unsigned int BOP_Index; +typedef vector BOP_Indexs; +typedef vector::iterator BOP_IT_Indexs; + +#endif diff --git a/intern/boolop/intern/BOP_Interface.cpp b/intern/boolop/intern/BOP_Interface.cpp new file mode 100644 index 00000000000..02945340d55 --- /dev/null +++ b/intern/boolop/intern/BOP_Interface.cpp @@ -0,0 +1,603 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include +#include +#include "../extern/BOP_Interface.h" +#include "../../bsp/intern/BSP_CSGMesh_CFIterator.h" +#include "BOP_BSPTree.h" +#include "BOP_Mesh.h" +#include "BOP_Face2Face.h" +#include "BOP_Merge.h" +#include "BOP_MaterialContainer.h" +#include "BOP_Chrono.h" + +//#define DEBUG + +BoolOpState BOP_intersectionBoolOp(BOP_Mesh* meshC, + BOP_Faces* facesA, + BOP_Faces* facesB, + bool invertMeshA, + bool invertMeshB); +BOP_Face3* BOP_createFace(BOP_Mesh* mesh, + BOP_Index vertex1, + BOP_Index vertex2, + BOP_Index vertex3, + BOP_Index idxFace); +void BOP_addMesh(BOP_Mesh* mesh, + BOP_Faces* meshFacesId, + BOP_MaterialContainer* materials, + CSG_MeshPropertyDescriptor props, + CSG_FaceIteratorDescriptor& face_it, + CSG_VertexIteratorDescriptor& vertex_it, + bool invert); +BSP_CSGMesh* BOP_newEmptyMesh(CSG_MeshPropertyDescriptor props); +BSP_CSGMesh* BOP_exportMesh(BOP_Mesh* inputMesh, + BOP_MaterialContainer* materials, + CSG_MeshPropertyDescriptor props, + bool invert); +void BOP_meshFilter(BOP_Mesh* meshC, BOP_Faces* faces, BOP_BSPTree* bsp); +void BOP_simplifiedMeshFilter(BOP_Mesh* meshC, BOP_Faces* faces, BOP_BSPTree* bsp, bool inverted); +void BOP_meshClassify(BOP_Mesh* meshC, BOP_Faces* faces, BOP_BSPTree* bsp); + +/** + * Performs a generic booleam operation, the entry point for external modules. + * @param opType Boolean operation type BOP_INTERSECTION, BOP_UNION, BOP_DIFFERENCE + * @param outputProps Output mesh properties + * @param outputMesh Output mesh, the final result (the object C) + * @param obAProps Object A properties + * @param obAFaces Object A faces list + * @param obAVertices Object A vertices list + * @param obBProps Object B properties + * @param obBFaces Object B faces list + * @param obBVertices Object B vertices list + * @param interpFunc Interpolating function + * @return operation state: BOP_OK, BOP_NO_SOLID, BOP_ERROR + */ +BoolOpState BOP_performBooleanOperation(BoolOpType opType, + CSG_MeshPropertyDescriptor outputProps, + BSP_CSGMesh** outputMesh, + CSG_MeshPropertyDescriptor obAProps, + CSG_FaceIteratorDescriptor obAFaces, + CSG_VertexIteratorDescriptor obAVertices, + CSG_MeshPropertyDescriptor obBProps, + CSG_FaceIteratorDescriptor obBFaces, + CSG_VertexIteratorDescriptor obBVertices, + CSG_InterpolateUserFaceVertexDataFunc interpFunc) +{ + #ifdef DEBUG + cout << "BEGIN BOP_performBooleanOperation" << endl; + #endif + + // Set invert flags depending on boolean operation type: + // INTERSECTION: A^B = and(A,B) + // UNION: A|B = not(and(not(A),not(B))) + // DIFFERENCE: A-B = and(A,not(B)) + bool invertMeshA = (opType == BOP_UNION); + bool invertMeshB = (opType != BOP_INTERSECTION); + bool invertMeshC = (opType == BOP_UNION); + + // Faces list for both objects, used by boolean op. + BOP_Faces meshAFacesId; + BOP_Faces meshBFacesId; + + // Build C-mesh, the output mesh + BOP_Mesh meshC; + + // Prepare the material container + BOP_MaterialContainer materials; + materials.setInterpFunc(interpFunc); + + // Add A-mesh into C-mesh + BOP_addMesh(&meshC, &meshAFacesId, &materials, obAProps, obAFaces, obAVertices, invertMeshA); + + // Add B-mesh into C-mesh + BOP_addMesh(&meshC, &meshBFacesId, &materials, obBProps, obBFaces, obBVertices, invertMeshB); + + // Perform the intersection boolean operation. + BoolOpState result = BOP_intersectionBoolOp(&meshC, &meshAFacesId, &meshBFacesId, + invertMeshA, invertMeshB); + + // Invert the output mesh if is required + *outputMesh = BOP_exportMesh(&meshC, &materials, outputProps, invertMeshC); + + #ifdef DEBUG + cout << "END BOP_performBooleanOperation" << endl; + #endif + + return result; +} + +/** + * Computes the intersection boolean operation. Creates a new mesh resulting from + * an intersection of two meshes. + * @param meshC Input & Output mesh + * @param facesA Mesh A faces list + * @param facesB Mesh B faces list + * @param invertMeshA determines if object A is inverted + * @param invertMeshB determines if object B is inverted + * @return operation state: BOP_OK, BOP_NO_SOLID, BOP_ERROR + */ +BoolOpState BOP_intersectionBoolOp(BOP_Mesh* meshC, + BOP_Faces* facesA, + BOP_Faces* facesB, + bool invertMeshA, + bool invertMeshB) +{ + #ifdef DEBUG + BOP_Chrono chrono; + float t = 0.0f; + float c = 0.0f; + chrono.start(); + cout << "---" << endl; + #endif + + // Create BSPs trees for mesh A & B + BOP_BSPTree bspA; + bspA.addMesh(meshC, *facesA); + bspA.computeBox(); + + BOP_BSPTree bspB; + bspB.addMesh(meshC, *facesB); + bspB.computeBox(); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "Create BSP " << c << endl; + #endif + + unsigned int numVertices = meshC->getNumVertexs(); + + // mesh pre-filter + BOP_simplifiedMeshFilter(meshC, facesA, &bspB, invertMeshB); + if ((0.25*facesA->size()) > bspB.getDeep()) + BOP_meshFilter(meshC, facesA, &bspB); + + BOP_simplifiedMeshFilter(meshC, facesB, &bspA, invertMeshA); + if ((0.25*facesB->size()) > bspA.getDeep()) + BOP_meshFilter(meshC, facesB, &bspA); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "mesh Filter " << c << endl; + #endif + + // Face 2 Face + BOP_Face2Face(meshC,facesA,facesB); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "Face2Face " << c << endl; + #endif + + // BSP classification + BOP_meshClassify(meshC,facesA,&bspB); + BOP_meshClassify(meshC,facesB,&bspA); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "Classification " << c << endl; + #endif + + // Process overlapped faces + BOP_removeOverlappedFaces(meshC,facesA,facesB); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "Remove overlap " << c << endl; + #endif + + // Sew two meshes + BOP_sew(meshC,facesA,facesB); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "Sew " << c << endl; + #endif + + // Merge faces + BOP_Merge::getInstance().mergeFaces(meshC,numVertices); + + #ifdef DEBUG + c = chrono.stamp(); t += c; + cout << "Merge faces " << c << endl; + cout << "Total " << t << endl; + // Test integrity + meshC->testMesh(); + #endif + + return BOP_OK; +} + +/** + * Preprocess to filter no collisioned faces. + * @param meshC Input & Output mesh data + * @param faces Faces list to test + * @param bsp BSP tree used to filter + */ +void BOP_meshFilter(BOP_Mesh* meshC, BOP_Faces* faces, BOP_BSPTree* bsp) +{ + BOP_IT_Faces it; + BOP_TAG tag; + + it = faces->begin(); + while (it!=faces->end()) { + BOP_Face *face = *it; + MT_Point3 p1 = meshC->getVertex(face->getVertex(0))->getPoint(); + MT_Point3 p2 = meshC->getVertex(face->getVertex(1))->getPoint(); + MT_Point3 p3 = meshC->getVertex(face->getVertex(2))->getPoint(); + if ((tag = bsp->classifyFace(p1,p2,p3,face->getPlane()))==OUT||tag==OUTON) { + face->setTAG(BROKEN); + it = faces->erase(it); + } + else if (tag == IN) { + it = faces->erase(it); + }else{ + it++; + } + } +} + +/** + * Pre-process to filter no collisioned faces. + * @param meshC Input & Output mesh data + * @param faces Faces list to test + * @param bsp BSP tree used to filter + * @param inverted determines if the object is inverted + */ +void BOP_simplifiedMeshFilter(BOP_Mesh* meshC, BOP_Faces* faces, BOP_BSPTree* bsp, bool inverted) +{ + BOP_IT_Faces it; + + it = faces->begin(); + while (it!=faces->end()) { + BOP_Face *face = *it; + MT_Point3 p1 = meshC->getVertex(face->getVertex(0))->getPoint(); + MT_Point3 p2 = meshC->getVertex(face->getVertex(1))->getPoint(); + MT_Point3 p3 = meshC->getVertex(face->getVertex(2))->getPoint(); + if (bsp->filterFace(p1,p2,p3,face)==OUT) { + if (!inverted) face->setTAG(BROKEN); + it = faces->erase(it); + } + else { + it++; + } + } +} + +/** + * Process to classify the mesh faces using a bsp tree. + * @param meshC Input & Output mesh data + * @param faces Faces list to classify + * @param bsp BSP tree used to face classify + */ +void BOP_meshClassify(BOP_Mesh* meshC, BOP_Faces* faces, BOP_BSPTree* bsp) +{ + for(BOP_IT_Faces face=faces->begin();face!=faces->end();face++) { + if ((*face)->getTAG()!=BROKEN) { + MT_Point3 p1 = meshC->getVertex((*face)->getVertex(0))->getPoint(); + MT_Point3 p2 = meshC->getVertex((*face)->getVertex(1))->getPoint(); + MT_Point3 p3 = meshC->getVertex((*face)->getVertex(2))->getPoint(); + if (bsp->simplifiedClassifyFace(p1,p2,p3,(*face)->getPlane())!=IN) { + (*face)->setTAG(BROKEN); + } + } + } +} + +/** + * Returns a new mesh triangle. + * @param meshC Input & Output mesh data + * @param vertex1 first vertex of the new face + * @param vertex2 second vertex of the new face + * @param vertex3 third vertex of the new face + * @param idxFace identifier of the new face + * @return new the new face + */ +BOP_Face3 *BOP_createFace3(BOP_Mesh* mesh, + BOP_Index vertex1, + BOP_Index vertex2, + BOP_Index vertex3, + BOP_Index idxFace) +{ + MT_Point3 p1 = mesh->getVertex(vertex1)->getPoint(); + MT_Point3 p2 = mesh->getVertex(vertex2)->getPoint(); + MT_Point3 p3 = mesh->getVertex(vertex3)->getPoint(); + MT_Plane3 plane(p1,p2,p3); + + return new BOP_Face3(vertex1, vertex2, vertex3, plane, idxFace); +} + +/** + * Adds mesh information into destination mesh. + * @param mesh input/output mesh, destination for the new mesh data + * @param meshFacesId output mesh faces, contains an added faces list + * @param materials used to store material data + * @param props Properties of the input mesh data + * @param face_it faces iterator + * @param vertex_it vertices iterator + * @param inverted if TRUE adding inverted faces, non-inverted otherwise + */ +void BOP_addMesh(BOP_Mesh* mesh, + BOP_Faces* meshFacesId, + BOP_MaterialContainer* materials, + CSG_MeshPropertyDescriptor props, + CSG_FaceIteratorDescriptor& face_it, + CSG_VertexIteratorDescriptor& vertex_it, + bool invert) +{ + unsigned int vtxIndexOffset = mesh->getNumVertexs(); + + // The size of the vertex data array will be at least the number of faces. + CSG_IVertex vertex; + while (!vertex_it.Done(vertex_it.it)) { + vertex_it.Fill(vertex_it.it,&vertex); + MT_Point3 pos(vertex.position); + mesh->addVertex(pos); + vertex_it.Step(vertex_it.it); + } + + CSG_IFace face; + + // now for the polygons. + // we may need to decalare some memory for user defined face properties. + unsigned int sizeFace = props.user_data_size; + if (sizeFace) { + face.user_face_data = new char[sizeFace]; + } + else { + face.user_face_data = NULL; + } + + unsigned int sizeVertex = props.user_face_vertex_data_size; + if (sizeVertex) { + char * fv_data2 = NULL; + fv_data2 = new char[4 * sizeVertex]; + + face.user_face_vertex_data[0] = fv_data2; + face.user_face_vertex_data[1] = fv_data2 + sizeVertex; + face.user_face_vertex_data[2] = fv_data2 + 2*sizeVertex; + face.user_face_vertex_data[3] = fv_data2 + 3*sizeVertex; + } + else { + face.user_face_vertex_data[0] = NULL; + face.user_face_vertex_data[1] = NULL; + face.user_face_vertex_data[2] = NULL; + face.user_face_vertex_data[3] = NULL; + } + + unsigned int idFaceMaterial; + BOP_Material faceMaterial(sizeFace,sizeVertex); + BOP_Material* materialHandler; + BOP_Face3 *newface; + + while (!face_it.Done(face_it.it)) { + face_it.Fill(face_it.it,&face); + + faceMaterial.setFaceMaterial((char *)face.user_face_data); + faceMaterial.setFaceVertexMaterial((char *)face.user_face_vertex_data[0]); + faceMaterial.setOriginalFace(mesh->getNumFaces()); + faceMaterial.setIsQuad(face.vertex_number == 4); + idFaceMaterial = materials->addMaterial(faceMaterial); + materialHandler = materials->getMaterial(idFaceMaterial); + + // Let's not rely on quads being coplanar - especially if they + // are coming out of that soup of code from blender... + if (face.vertex_number == 4){ + // QUAD + if (invert) { + newface = BOP_createFace3(mesh, + face.vertex_index[2] + vtxIndexOffset, + face.vertex_index[0] + vtxIndexOffset, + face.vertex_index[3] + vtxIndexOffset, + idFaceMaterial); + meshFacesId->push_back(newface); + mesh->addFace(newface); + materialHandler->setOriginalFaceVertex(newface->getVertex(0),2); + materialHandler->setOriginalFaceVertex(newface->getVertex(1),0); + materialHandler->setOriginalFaceVertex(newface->getVertex(2),3); + newface = BOP_createFace3(mesh, + face.vertex_index[2] + vtxIndexOffset, + face.vertex_index[1] + vtxIndexOffset, + face.vertex_index[0] + vtxIndexOffset, + idFaceMaterial); + meshFacesId->push_back(newface); + mesh->addFace(newface); + materialHandler->setOriginalFaceVertex(newface->getVertex(1),1); + } + else { + newface = BOP_createFace3(mesh, + face.vertex_index[0] + vtxIndexOffset, + face.vertex_index[2] + vtxIndexOffset, + face.vertex_index[3] + vtxIndexOffset, + idFaceMaterial); + meshFacesId->push_back(newface); + mesh->addFace(newface); + materialHandler->setOriginalFaceVertex(newface->getVertex(0),0); + materialHandler->setOriginalFaceVertex(newface->getVertex(1),2); + materialHandler->setOriginalFaceVertex(newface->getVertex(2),3); + newface = BOP_createFace3(mesh, + face.vertex_index[0] + vtxIndexOffset, + face.vertex_index[1] + vtxIndexOffset, + face.vertex_index[2] + vtxIndexOffset, + idFaceMaterial); + meshFacesId->push_back(newface); + mesh->addFace(newface); + materialHandler->setOriginalFaceVertex(newface->getVertex(1),1); + } + } + else { + // TRIANGLES + if (invert) { + newface = BOP_createFace3(mesh, + face.vertex_index[2] + vtxIndexOffset, + face.vertex_index[1] + vtxIndexOffset, + face.vertex_index[0] + vtxIndexOffset, + idFaceMaterial); + meshFacesId->push_back(newface); + mesh->addFace(newface); + materialHandler->setOriginalFaceVertex(newface->getVertex(0),2); + materialHandler->setOriginalFaceVertex(newface->getVertex(1),1); + materialHandler->setOriginalFaceVertex(newface->getVertex(2),0); + } + else { + newface = BOP_createFace3(mesh, + face.vertex_index[0] + vtxIndexOffset, + face.vertex_index[1] + vtxIndexOffset, + face.vertex_index[2] + vtxIndexOffset, + idFaceMaterial); + meshFacesId->push_back(newface); + mesh->addFace(newface); + materialHandler->setOriginalFaceVertex(newface->getVertex(0),0); + materialHandler->setOriginalFaceVertex(newface->getVertex(1),1); + materialHandler->setOriginalFaceVertex(newface->getVertex(2),2); + } + } + + face_it.Step(face_it.it); + } + + // delete temporal material data + if (face.user_face_data) + delete[] static_cast(face.user_face_data); + if (face.user_face_vertex_data) + delete[] static_cast(face.user_face_vertex_data[0]); +} + +/** + * Returns an empty mesh with the specified properties. + * @param props Output mesh properties + * @return a new empty mesh + */ +BSP_CSGMesh* BOP_newEmptyMesh(CSG_MeshPropertyDescriptor props) +{ + BSP_CSGMesh* mesh = BSP_CSGMesh::New(); + if (mesh == NULL) return mesh; + + vector* vertices = new vector; + BSP_CSGUserData* faceData = new BSP_CSGUserData(props.user_data_size); + BSP_CSGUserData* faceVtxData = new BSP_CSGUserData(props.user_face_vertex_data_size); + + mesh->SetVertices(vertices); + mesh->SetFaceData(faceData); + mesh->SetFaceVertexData(faceVtxData); + + return mesh; +} + +/** + * Exports a BOP_Mesh to a BSP_CSGMesh. + * @param mesh Input mesh + * @param materials used to reconstruct original faces materials + * @param props Properties of output mesh + * @param invert if TRUE export with inverted faces, no inverted otherwise + * @return the corresponding new BSP_CSGMesh + */ +BSP_CSGMesh* BOP_exportMesh(BOP_Mesh* mesh, + BOP_MaterialContainer* materials, + CSG_MeshPropertyDescriptor props, + bool invert) +{ + BSP_CSGMesh* outputMesh = BOP_newEmptyMesh(props); + + // User data handlers + BSP_CSGUserData* outputFaceVtxData = &(outputMesh->FaceVertexData()); + BSP_CSGUserData* outputFaceData = &(outputMesh->FaceData()); + + // vtx index dictionary, to translate indeces from input to output. + map dic; + map::iterator itDic; + + unsigned int count = 0; + + // Add a new face for each face in the input list + BOP_Faces faces = mesh->getFaces(); + BOP_Vertexs vertexs = mesh->getVertexs(); + + // Reserve temporal memory + char* tmpFaceVtxData = new char[props.user_face_vertex_data_size]; + + for (BOP_IT_Faces face = faces.begin(); face != faces.end(); face++) { + if ((*face)->getTAG()!=BROKEN){ + // Add output face + outputMesh->FaceSet().push_back(BSP_MFace()); + BSP_MFace& outFace = outputMesh->FaceSet().back(); + + // Copy face + outFace.m_verts.clear(); + outFace.m_fv_data.clear(); + outFace.m_plane = (*face)->getPlane(); + + // Copy face user data from input mesh + outputFaceData->Duplicate(materials->getFaceMaterial((*face)->getOriginalFace())); + + // invert face if is required + if (invert) (*face)->invert(); + + // Add the face vertex if not added yet + for (unsigned int pos=0;pos<(*face)->size();pos++) { + BSP_VertexInd outVtxId; + BOP_Index idVertex = (*face)->getVertex(pos); + itDic = dic.find(idVertex); + if (itDic == dic.end()) { + // The vertex isn't added yet + outVtxId = BSP_VertexInd(outputMesh->VertexSet().size()); + BSP_MVertex outVtx((mesh->getVertex(idVertex))->getPoint()); + outVtx.m_edges.clear(); + outputMesh->VertexSet().push_back(outVtx); + dic[idVertex] = outVtxId; + count++; + } + else { + // The vertex is added + outVtxId = BSP_VertexInd(itDic->second); + } + + // Add vertex to output face + outFace.m_verts.push_back(outVtxId); + + // Add face vertex user data + char* faceVtxData = materials->getFaceVertexMaterial(mesh, + (*face)->getOriginalFace(), + (mesh->getVertex(idVertex))->getPoint(), + tmpFaceVtxData); + BSP_UserFVInd userFVInd(outputFaceVtxData->Duplicate((void*) faceVtxData)); + outFace.m_fv_data.push_back(userFVInd); + } + } + } + // free temporal memory + delete[] tmpFaceVtxData; + + // Build the mesh edges using topological informtion + outputMesh->BuildEdges(); + + return outputMesh; +} diff --git a/intern/boolop/intern/BOP_Material.cpp b/intern/boolop/intern/BOP_Material.cpp new file mode 100644 index 00000000000..2d1e747eb49 --- /dev/null +++ b/intern/boolop/intern/BOP_Material.cpp @@ -0,0 +1,176 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Material.h" +#include +using namespace std; + +/** + * Constructs a new material. + * @param faceWidth face material size in bytes. + * @param faceVertexWidth verex face material size in bytes. + */ +BOP_Material::BOP_Material(int faceWidth, int faceVertexWidth) +{ + m_faceWidth = faceWidth; + m_faceVertexWidth = faceVertexWidth; + + m_faceMaterial = new char[m_faceWidth]; + m_faceVertexMaterial = new char[N_FACE_VERTEX*m_faceVertexWidth]; +} + +/** + * Constructs a new material duplicating the other object data. + * @param other the other object to copy the data. + */ +BOP_Material::BOP_Material(const BOP_Material& other) +{ + m_faceWidth = other.getFaceWidth(); + m_faceVertexWidth = other.getFaceVertexWidth(); + + m_faceMaterial = new char[m_faceWidth]; + m_faceVertexMaterial = new char[N_FACE_VERTEX*m_faceVertexWidth]; + + duplicate(other); +} + +/** + * Destroys a material. + */ +BOP_Material::~BOP_Material() +{ + delete[] m_faceMaterial; + delete[] m_faceVertexMaterial; +} + +/** + * Duplicates the face material passed by argument. + * @param faceMaterial pointer to face material data. + */ +void BOP_Material::setFaceMaterial(char* faceMaterial) +{ + memcpy(m_faceMaterial, faceMaterial, m_faceWidth); +} + +/** + * Duplicates the all face vertex materials passed by argument. It's supossed + * that all face vertex materials positions are consecutive. + * @param faceVertexMaterial pointer to firts vertex face material. + */ +void BOP_Material::setFaceVertexMaterial(char* faceVertexMaterial) +{ + memcpy(m_faceVertexMaterial, faceVertexMaterial, N_FACE_VERTEX*m_faceVertexWidth); +} + +/** + * Duplicates on i-position the face vertex material passed by argument. + * @param faceMaterial pointer to face vertex material. + * @param i destination position of new face vertex material (0<=i<4) + */ +void BOP_Material::setFaceVertexMaterial(char* faceVertexMaterial, int i) +{ + if (i>=0&&i=0&&igetOriginalFace() << ") < "; + int N = m->isQuad() ? 4 : 3; + for (int i=0;igetOriginalFaceVertex(i) << " "; + cout << ">" << endl; + + return stream; +} diff --git a/intern/boolop/intern/BOP_Material.h b/intern/boolop/intern/BOP_Material.h new file mode 100644 index 00000000000..a057384bf01 --- /dev/null +++ b/intern/boolop/intern/BOP_Material.h @@ -0,0 +1,80 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_MATERIAL_H +#define BOP_MATERIAL_H + +#include +using namespace std; + +#define N_FACE_VERTEX 4 + +class BOP_Material +{ +private: + char* m_faceMaterial; + char* m_faceVertexMaterial; + int m_faceWidth; + int m_faceVertexWidth; + int m_originalFace; + int m_originalFaceVertices[N_FACE_VERTEX]; + bool m_isQuad; + +public: + BOP_Material(int faceWidth, int faceVertexWidth); + BOP_Material(const BOP_Material& other); + ~BOP_Material(); + void setFaceMaterial(char* faceMaterial); + void setFaceVertexMaterial(char* faceVertexMaterial); + void setFaceVertexMaterial(char* faceVertexMaterial, int i); + void duplicate(const BOP_Material& other); + BOP_Material& operator = (BOP_Material& other); + char* getFaceMaterial() const; + char* getFaceVertexMaterial(int i) const; + int getFaceWidth() const { return m_faceWidth; }; + int getFaceVertexWidth() const { return m_faceVertexWidth; }; + + void setOriginalFace(int originalFace) {m_originalFace = originalFace;}; + int getOriginalFace() const {return m_originalFace;}; + void setOriginalFaceVertex(int originalFaceVertex, int i) { + if (0<=i&&i +#include "BOP_MaterialContainer.h" +#include "BOP_MathUtils.h" +#include "MEM_SmartPtr.h" + +/** + * Constructs a new material container. + */ +BOP_MaterialContainer::BOP_MaterialContainer() +{ + m_interpFunc = NULL; +} + +/** + * Destroys a material container. + */ +BOP_MaterialContainer::~BOP_MaterialContainer() +{ +} + +/** + * Adds a new material to this container. + * @param m material material object to add. + * @return the new material index. + */ +BOP_Index BOP_MaterialContainer::addMaterial(BOP_Material m) +{ + m_materialList.push_back(m); + return m_materialList.size()-1; +} + +/** + * Updates the interpolation function of this container. + * @param interpFunc the interpolation function. + */ +void BOP_MaterialContainer::setInterpFunc(CSG_InterpolateUserFaceVertexDataFunc interpFunc) +{ + m_interpFunc = interpFunc; +} + +/** + * Returns the material list. + * @return + */ +BOP_Materials& BOP_MaterialContainer::getMaterialList() +{ + return m_materialList; +} + +/** + * Returns the material with the specified index. + * @param index material index. + * @return material with the specified index. + */ +BOP_Material* BOP_MaterialContainer::getMaterial(BOP_Index index) +{ + return index < m_materialList.size() ? &(m_materialList[index]) : NULL; +} + +/** + * Returns the pointer to face material specified by index. + * @param index material index. + * @return pointer to face material. + */ +char* BOP_MaterialContainer::getFaceMaterial(BOP_Index index) +{ + if (index < m_materialList.size()) + return m_materialList[index].getFaceMaterial(); + else return NULL; +} + +/** + * Returns a pointer to face vertex material, if is the material not exist, then + * returns an interpoled material. + * @param mesh original mesh data. + * @param originalFaceIndex index to the original mesh face. + * @param point point who needs a material. + * @param faceVertexMaterial pointer to mem region where the material will be + * saved. + * @return pointer to the face vertex material. + */ +char* BOP_MaterialContainer::getFaceVertexMaterial(BOP_Mesh *mesh, + BOP_Index originalFaceIndex, + MT_Point3 point, + char* faceVertexMaterial) +{ + if (originalFaceIndex>=m_materialList.size()) return NULL; + + BOP_Material& material = m_materialList[originalFaceIndex]; + + if (material.isQuad()) { + + BOP_Face *face1 = mesh->getFace(material.getOriginalFace()); + BOP_Face *face2 = mesh->getFace(material.getOriginalFace()+1); + + if (!face1 || !face2) return NULL; + + // Search original point + for (unsigned int i=0;isize();i++) { + if (point == mesh->getVertex(face1->getVertex(i))->getPoint()) { + return material.getOriginalFaceVertexMaterial(face1->getVertex(i)); + } + } + for (unsigned int i=0;isize();i++) { + if (point == mesh->getVertex(face2->getVertex(i))->getPoint()) { + return material.getOriginalFaceVertexMaterial(face2->getVertex(i)); + } + } + // wich is the half quad where the point is? + MT_Vector3 N = face1->getPlane().Normal(); + MT_Point3 p0 = mesh->getVertex(face1->getVertex(0))->getPoint(); + MT_Point3 q(p0.x()+N.x(),p0.y()+N.y(),p0.z()+N.z()); + MT_Point3 p2 = mesh->getVertex(face1->getVertex(1))->getPoint(); + MT_Plane3 plane(p0,p2,q); + + if (BOP_sign(plane.signedDistance(point))==-1) { + // first half quad + faceVertexMaterial = interpolateMaterial(mesh, face1, material, point, faceVertexMaterial); + } + else { + // second half quad + faceVertexMaterial = interpolateMaterial(mesh, face2, material, point, faceVertexMaterial); + } + } + else { + BOP_Face *face1 = mesh->getFace(material.getOriginalFace()); + + if (!face1) return NULL; + + // Search original point + for (unsigned int i=0;isize();i++) { + if (point == mesh->getVertex(face1->getVertex(i))->getPoint()) + return material.getOriginalFaceVertexMaterial(face1->getVertex(i)); + } + + faceVertexMaterial = interpolateMaterial(mesh, face1, material, point, faceVertexMaterial); + } + + return faceVertexMaterial; +} + +/** + * Performs vertex data interpolation. + * @param mesh original mesh data. + * @param face face used to interpolate an interior face point material + * @param material face material, input data for implementation. + * @param point interpolated point. + * @param faceVertexMaterial pointer to memory region. + * @return pointer to face vertex material. + */ +char* BOP_MaterialContainer::interpolateMaterial(BOP_Mesh* mesh, + BOP_Face* face, + BOP_Material& material, + MT_Point3 point, + char* faceVertexMaterial) +{ + // (p1)-----(I)------(p2) + // \ | / + // \ | / + // \ | / + // \ (point) / + // \ | / + // \ | / + // \ | / + // (p3) + + MT_Point3 p1 = mesh->getVertex(face->getVertex(0))->getPoint(); + MT_Point3 p2 = mesh->getVertex(face->getVertex(1))->getPoint(); + MT_Point3 p3 = mesh->getVertex(face->getVertex(2))->getPoint(); + MT_Point3 I = BOP_4PointIntersect(p1, p2, p3, point); + MT_Scalar epsilon0 = 1.0-BOP_EpsilonDistance(p1, p2, I); + MT_Scalar epsilon1 = 1.0-BOP_EpsilonDistance(I, p3, point); + + // Interpolate data + if (m_interpFunc) { + // temporal data + char* faceVertexMaterialTemp = new char[material.getFaceVertexWidth()]; + + (*m_interpFunc)(material.getOriginalFaceVertexMaterial(face->getVertex(0)), + material.getOriginalFaceVertexMaterial(face->getVertex(1)), + faceVertexMaterialTemp, + epsilon0); + + (*m_interpFunc)(faceVertexMaterialTemp, + material.getOriginalFaceVertexMaterial(face->getVertex(2)), + faceVertexMaterial, + epsilon1); + + // free temporal data + delete[] faceVertexMaterialTemp; + + } + else faceVertexMaterial = NULL; + + // return the result + return (char*) faceVertexMaterial; +} + +/** + * Implements operator << + */ +ostream &operator<<(ostream &stream, BOP_MaterialContainer *mc) +{ + stream << "***[ Material List ]***********************************************" << endl; + BOP_IT_Materials it; + for (it=mc->getMaterialList().begin();it!=mc->getMaterialList().end();++it) { + stream << "[" << it - mc->getMaterialList().begin() << "] "; + stream << &(*it); + } + stream << "*******************************************************************" << endl; + return stream; +} diff --git a/intern/boolop/intern/BOP_MaterialContainer.h b/intern/boolop/intern/BOP_MaterialContainer.h new file mode 100644 index 00000000000..c6de4cd96e5 --- /dev/null +++ b/intern/boolop/intern/BOP_MaterialContainer.h @@ -0,0 +1,72 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_MATERIALCONTAINER_H +#define BOP_MATERIALCONTAINER_H + +#include "BOP_Mesh.h" +#include "BOP_Material.h" +#include "BOP_Interface.h" +#include +using namespace std; + +typedef vector BOP_Materials; +typedef vector::iterator BOP_IT_Materials; + +class BOP_MaterialContainer +{ +private: + BOP_Materials m_materialList; + CSG_InterpolateUserFaceVertexDataFunc m_interpFunc; + +public: + BOP_MaterialContainer(); + ~BOP_MaterialContainer(); + BOP_Index addMaterial(BOP_Material m); + void setInterpFunc(CSG_InterpolateUserFaceVertexDataFunc interpFunc); + BOP_Materials& getMaterialList(); + BOP_Material* getMaterial(BOP_Index index); + char* getFaceMaterial(BOP_Index index); + char* getFaceVertexMaterial(BOP_Mesh *mesh, + BOP_Index originalFaceIndex, + MT_Point3 point, + char* faceVertexMaterial); + + friend ostream &operator<<(ostream &stream, BOP_MaterialContainer *mc); + +private: + char* interpolateMaterial(BOP_Mesh* mesh, + BOP_Face* face, + BOP_Material& material, + MT_Point3 point, + char* faceVertexMaterial); +}; + +#endif diff --git a/intern/boolop/intern/BOP_MathUtils.cpp b/intern/boolop/intern/BOP_MathUtils.cpp new file mode 100644 index 00000000000..0d84bb1778c --- /dev/null +++ b/intern/boolop/intern/BOP_MathUtils.cpp @@ -0,0 +1,419 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_MathUtils.h" +#include +using namespace std; + +/** + * Compares two scalars with EPSILON accuracy. + * @param A scalar + * @param B scalar + * @return 1 if A > B, -1 if A < B, 0 otherwise + */ +int BOP_comp(const MT_Scalar A, const MT_Scalar B) +{ + if (A >= B + BOP_EPSILON) return 1; + else if (B >= A + BOP_EPSILON) return -1; + else return 0; +} + +/** + * Compares two scalar triplets with EPSILON accuracy. + * @param A scalar triplet + * @param B scalar triplet + * @return 1 if A > B, -1 if A < B, 0 otherwise + */ +int BOP_comp(const MT_Tuple3& A, const MT_Tuple3& B) +{ + if (A.x() >= (B.x() + BOP_EPSILON)) return 1; + else if (B.x() >= (A.x() + BOP_EPSILON)) return -1; + else if (A.y() >= (B.y() + BOP_EPSILON)) return 1; + else if (B.y() >= (A.y() + BOP_EPSILON)) return -1; + else if (A.z() >= (B.z() + BOP_EPSILON)) return 1; + else if (B.z() >= (A.z() + BOP_EPSILON)) return -1; + else return 0; +} + +/** + * Compares two scalars strictly. + * @param A scalar + * @param B scalar + * @return 1 if A > B, -1 if A < B, 0 otherwise + */ +int BOP_exactComp(const MT_Scalar A, const MT_Scalar B) +{ + if (A > B) return 1; + else if (B > A) return -1; + else return 0; +} +/** + * Compares two scalar strictly. + * @param A scalar triplet + * @param B scalar triplet + * @return 1 if A > B, -1 if A < B, 0 otherwise + */ +int BOP_exactComp(const MT_Tuple3& A, const MT_Tuple3& B) +{ + if (A.x() > B.x()) return 1; + else if (B.x() > A.x()) return -1; + else if (A.y() > B.y()) return 1; + else if (B.y() > A.y()) return -1; + else if (A.z() > B.z()) return 1; + else if (B.z() > A.z()) return -1; + else return 0; +} + +/** + * Returns if p1 is between p2 and p3 and lay on the same line (are collinears). + * @param p1 point + * @param p2 point + * @param p3 point + * @return true if p1 is between p2 and p3 and lay on the same line, false otherwise + */ +bool BOP_between(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3) +{ + MT_Scalar distance = p2.distance(p3); + return (p1.distance(p2) < distance && p1.distance(p3) < distance) && BOP_collinear(p1,p2,p3); +} + +/** + * Returns if three points lay on the same line (are collinears). + * @param p1 point + * @param p2 point + * @param p3 point + * @return true if the three points lay on the same line, false otherwise + */ +bool BOP_collinear(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3) +{ + MT_Vector3 v1 = p2 - p1; + MT_Vector3 v2 = p3 - p2; + + MT_Vector3 w = v1.cross(v2); + + return (BOP_comp(w.x(),0.0) == 0) && (BOP_comp(w.y(),0.0) == 0) && (BOP_comp(w.z(),0.0) == 0); +} + +/** + * Returns if a quad (coplanar) is convex. + * @return true if the quad is convex, false otherwise + */ +bool BOP_convex(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, const MT_Point3& p4) +{ + MT_Vector3 v1 = p3 - p1; + MT_Vector3 v2 = p4 - p2; + MT_Vector3 quadPlane = v1.cross(v2); + // plane1 is the perpendicular plane that contains the quad diagonal (p2,p4) + MT_Plane3 plane1(quadPlane.cross(v2),p2); + // if p1 and p3 are classified in the same region, the quad is not convex + if (BOP_classify(p1,plane1) == BOP_classify(p3,plane1)) return false; + else { + // Test the other quad diagonal (p1,p3) and perpendicular plane + MT_Plane3 plane2(quadPlane.cross(v1),p1); + // if p2 and p4 are classified in the same region, the quad is not convex + return (BOP_classify(p2,plane2) != BOP_classify(p4,plane2)); + } +} + +/** + * Returns if a quad (coplanar) is concave and where is the split edge. + * @return 0 if is convex, 1 if is concave and split edge is p1-p3 and -1 if is + * cancave and split edge is p2-p4. + */ +int BOP_concave(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, const MT_Point3& p4) +{ + MT_Vector3 v1 = p3 - p1; + MT_Vector3 v2 = p4 - p2; + MT_Vector3 quadPlane = v1.cross(v2); + // plane1 is the perpendicular plane that contains the quad diagonal (p2,p4) + MT_Plane3 plane1(quadPlane.cross(v2),p2); + // if p1 and p3 are classified in the same region, the quad is not convex + if (BOP_classify(p1,plane1) == BOP_classify(p3,plane1)) return 1; + else { + // Test the other quad diagonal (p1,p3) and perpendicular plane + MT_Plane3 plane2(quadPlane.cross(v1),p1); + // if p2 and p4 are classified in the same region, the quad is not convex + if (BOP_classify(p2,plane2) == BOP_classify(p4,plane2)) return -1; + else return 0; + } +} + +/** + * Computes the intersection between two lines (on the same plane). + * @param vL1 first line vector + * @param pL1 first line point + * @param vL2 second line vector + * @param pL2 second line point + * @param intersection intersection point (if exists) + * @return false if lines are parallels, true otherwise + */ +bool BOP_intersect(const MT_Vector3& vL1, const MT_Point3& pL1, const MT_Vector3& vL2, + const MT_Point3& pL2, MT_Point3 &intersection) +{ + // NOTE: + // If the lines aren't on the same plane, the intersection point will not be valid. + // So be careful !! + + MT_Scalar t = -1; + MT_Scalar den = (vL1.y()*vL2.x() - vL1.x() * vL2.y()); + + if (BOP_comp(den,0)) { + t = (pL2.y()*vL1.x() - vL1.y()*pL2.x() + pL1.x()*vL1.y() - pL1.y()*vL1.x()) / den ; + } + else { + den = (vL1.y()*vL2.z() - vL1.z() * vL2.y()); + if (BOP_comp(den,0)) { + t = (pL2.y()*vL1.z() - vL1.y()*pL2.z() + pL1.z()*vL1.y() - pL1.y()*vL1.z()) / den ; + } + else { + den = (vL1.x()*vL2.z() - vL1.z() * vL2.x()); + if (BOP_comp(den,0)) { + t = (pL2.x()*vL1.z() - vL1.x()*pL2.z() + pL1.z()*vL1.x() - pL1.x()*vL1.z()) / den ; + } + else { + return false; + } + } + } + + intersection.setValue(vL2.x()*t + pL2.x(), vL2.y()*t + pL2.y(), vL2.z()*t + pL2.z()); + return true; +} + +/** + * Returns the center of the circle defined by three points. + * @param p1 point + * @param p2 point + * @param p3 point + * @param center circle center + * @return false if points are collinears, true otherwise + */ +bool BOP_getCircleCenter(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + MT_Point3& center) +{ + // Compute quad plane + MT_Vector3 p1p2 = p2-p1; + MT_Vector3 p1p3 = p3-p1; + MT_Plane3 plane1(p1,p2,p3); + MT_Vector3 plane = plane1.Normal(); + + // Compute first line vector, perpendicular to plane vector and edge (p1,p2) + MT_Vector3 vL1 = p1p2.cross(plane); + vL1.normalize(); + + // Compute first line point, middle point of edge (p1,p2) + MT_Point3 pL1 = p1.lerp(p2, 0.5); + + // Compute second line vector, perpendicular to plane vector and edge (p1,p3) + MT_Vector3 vL2 = p1p3.cross(plane); + vL2.normalize(); + + // Compute second line point, middle point of edge (p1,p3) + MT_Point3 pL2 = p1.lerp(p3, 0.5); + + // Compute intersection (the lines lay on the same plane, so the intersection exists + // only if they are not parallel!!) + return BOP_intersect(vL1,pL1,vL2,pL2,center); +} + +/** + * Returns if points q is inside the circle defined by p1, p2 and p3. + * @param p1 point + * @param p2 point + * @param p3 point + * @param q point + * @return true if p4 or p5 are inside the circle, false otherwise. If + * the circle does not exist (p1, p2 and p3 are collinears) returns true + */ +bool BOP_isInsideCircle(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + const MT_Point3& q) +{ + MT_Point3 center; + + // Compute circle center + bool ok = BOP_getCircleCenter(p1,p2,p3,center); + + if (!ok) return true; // p1,p2 and p3 are collinears + + // Check if q is inside the circle + MT_Scalar r = p1.distance(center); + MT_Scalar d = q.distance(center); + return (BOP_comp(d,r) <= 0); +} + +/** + * Returns if points p4 or p5 is inside the circle defined by p1, p2 and p3. + * @param p1 point + * @param p2 point + * @param p3 point + * @param p4 point + * @param p5 point + * @return true if p4 or p5 is inside the circle, false otherwise. If + * the circle does not exist (p1, p2 and p3 are collinears) returns true + */ +bool BOP_isInsideCircle(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + const MT_Point3& p4, const MT_Point3& p5) +{ + MT_Point3 center; + bool ok = BOP_getCircleCenter(p1,p2,p3,center); + + if (!ok) return true; // Collinear points! + + // Check if p4 or p5 is inside the circle + MT_Scalar r = p1.distance(center); + MT_Scalar d1 = p4.distance(center); + MT_Scalar d2 = p5.distance(center); + return (BOP_comp(d1,r) <= 0 || BOP_comp(d2,r) <= 0); +} + +/** + * Returns if two planes share the same orientation. + * @return >0 if planes share the same orientation + */ +MT_Scalar BOP_orientation(const MT_Plane3& p1, const MT_Plane3& p2) +{ + // Dot product between plane normals + return (p1.x()*p2.x() + p1.y()*p2.y() + p1.z()*p2.z()); +} + +/** + * Classifies a point according to the specified plane with EPSILON accuracy. + * @param p point + * @param plane plane + * @return >0 if the point is above (OUT), + * =0 if the point is on (ON), + * <0 if the point is below (IN) + */ +int BOP_classify(const MT_Point3& p, const MT_Plane3& plane) +{ + // Compare plane - point distance with zero + return BOP_comp(plane.signedDistance(p),0); +} + +/** + * Intersects a plane with the line that contains the specified points. + * @param plane split plane + * @param p1 first line point + * @param p2 second line point + * @return intersection between plane and line that contains p1 and p2 + */ +MT_Point3 BOP_intersectPlane(const MT_Plane3& plane, const MT_Point3& p1, const MT_Point3& p2) +{ + // Compute intersection between plane and line ... + // + // L: (p2-p1)lambda + p1 + // + // supposes resolve equation ... + // + // coefA*((p2.x - p1.y)*lambda + p1.x) + ... + coefD = 0 + + MT_Point3 intersection; + MT_Scalar den = plane.x()*(p2.x()-p1.x()) + + plane.y()*(p2.y()-p1.y()) + + plane.z()*(p2.z()-p1.z()); + if (den != 0) { + MT_Scalar lambda = (-plane.x()*p1.x()-plane.y()*p1.y()-plane.z()*p1.z()-plane.w()) / den; + intersection.setValue(p1.x() + (p2.x()-p1.x())*lambda, + p1.y() + (p2.y()-p1.y())*lambda, + p1.z() + (p2.z()-p1.z())*lambda); + return intersection; + } + return intersection; +} + +/** + * Returns if a plane contains a point with EPSILON accuracy. + * @param plane plane + * @param point point + * @return true if the point is on the plane, false otherwise + */ +bool BOP_containsPoint(const MT_Plane3& plane, const MT_Point3& point) +{ + return BOP_comp(plane.signedDistance(point),0) == 0; +} + +/** + * Pre: p0, p1 and p2 is a triangle and q is an interior point. + * @param p0 point + * @param p1 point + * @param p2 point + * @param q point + * @return intersection point I + * v + * (p0)-----(I)----->(p1) + * \ ^ / + * \ |w / + * \ | / + * \ (q) / + * \ | / + * \ | / + * \ | / + * (p2) + * + * v = P1-P2 + * w = P3-Q + * r0(t) = v*t+P1 + * r1(t) = w*t+P3 + * I = r0^r1 + */ +MT_Point3 BOP_4PointIntersect(const MT_Point3& p0, const MT_Point3& p1, const MT_Point3& p2, + const MT_Point3& q) +{ + MT_Vector3 v(p0.x()-p1.x(), p0.y()-p1.y(), p0.z()-p1.z()); + MT_Vector3 w(p2.x()-q.x(), p2.y()-q.y(), p2.z()-q.z()); + MT_Point3 I; + + BOP_intersect(v,p0,w,p2,I); + return I; +} + +/** + * Pre: p0, p1 and q are collinears. + * @param p0 point + * @param p1 point + * @param q point + * @return 0 if q == p0, 1 if q == p1, or a value between 0 and 1 otherwise + * + * (p0)-----(q)------------(p1) + * |<-d1-->| | + * |<---------d0---------->| + * + */ +MT_Scalar BOP_EpsilonDistance(const MT_Point3& p0, const MT_Point3& p1, const MT_Point3& q) +{ + MT_Scalar d0 = p0.distance(p1); + MT_Scalar d1 = p0.distance(q); + MT_Scalar d; + + if (BOP_comp(d0,0)==0) d = 1.0; + else if (BOP_comp(d1,0)==0) d = 0.0; + else d = d1 / d0; + return d; +} diff --git a/intern/boolop/intern/BOP_MathUtils.h b/intern/boolop/intern/BOP_MathUtils.h new file mode 100644 index 00000000000..61458bd8a78 --- /dev/null +++ b/intern/boolop/intern/BOP_MathUtils.h @@ -0,0 +1,72 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_MATHUTILS_H +#define BOP_MATHUTILS_H + +#include +#include +#include "MT_Point3.h" +#include "MT_Plane3.h" + +const MT_Scalar BOP_EPSILON(1.0e-5); + +inline int BOP_sign(MT_Scalar x) { + return x < 0.0 ? -1 : x > 0.0 ? 1 : 0; +} +inline MT_Scalar BOP_abs(MT_Scalar x) { return fabs(x); } +inline bool BOP_fuzzyZero(MT_Scalar x) { return BOP_abs(x) < BOP_EPSILON; } + +int BOP_comp(const MT_Scalar A, const MT_Scalar B); +int BOP_comp(const MT_Tuple3& A, const MT_Tuple3& B); +int BOP_exactComp(const MT_Scalar A, const MT_Scalar B); +int BOP_exactComp(const MT_Tuple3& A, const MT_Tuple3& B); +bool BOP_between(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3); +bool BOP_collinear(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3); +bool BOP_convex(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + const MT_Point3& p4); +int BOP_concave(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, const MT_Point3& p4); +bool BOP_intersect(const MT_Vector3& vL1, const MT_Point3& pL1, const MT_Vector3& vL2, + const MT_Point3& pL2, MT_Point3& intersection); +bool BOP_getCircleCenter(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + const MT_Point3& center); +bool BOP_isInsideCircle(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + const MT_Point3& p4, const MT_Point3& p5); +bool BOP_isInsideCircle(const MT_Point3& p1, const MT_Point3& p2, const MT_Point3& p3, + const MT_Point3& q); +MT_Scalar BOP_orientation(const MT_Plane3& p1, const MT_Plane3& p2); +int BOP_classify(const MT_Point3& p, const MT_Plane3& plane); +MT_Point3 BOP_intersectPlane(const MT_Plane3& plane, const MT_Point3& p1, const MT_Point3& p2); +bool BOP_containsPoint(const MT_Plane3& plane, const MT_Point3& point); +MT_Point3 BOP_4PointIntersect(const MT_Point3& p0, const MT_Point3& p1, const MT_Point3& p2, + const MT_Point3& q); +MT_Scalar BOP_EpsilonDistance(const MT_Point3& p0, const MT_Point3& p1, const MT_Point3& q); + +#endif diff --git a/intern/boolop/intern/BOP_Merge.cpp b/intern/boolop/intern/BOP_Merge.cpp new file mode 100644 index 00000000000..1165ac10a8f --- /dev/null +++ b/intern/boolop/intern/BOP_Merge.cpp @@ -0,0 +1,796 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Merge.h" + +/** + * SINGLETON (use method BOP_Merge.getInstance). + */ +BOP_Merge BOP_Merge::SINGLETON; + +/** + * Simplifies a mesh, merging its faces. + * @param m mesh + * @param v index of the first mergeable vertex (can be removed by merge) + */ +void BOP_Merge::mergeFaces(BOP_Mesh *m, BOP_Index v) +{ + m_mesh = m; + m_firstVertex = v; + + bool cont = false; + + // Merge faces + mergeFaces(); + + do { + // Add quads ... + cont = createQuads(); + if (cont) { + // ... and merge new faces + cont = mergeFaces(); + } + // ... until the merge is not succesful + } while(cont); +} + +/** + * Simplifies a mesh, merging its faces. + */ +bool BOP_Merge::mergeFaces() +{ + BOP_Indexs mergeVertices; + BOP_Vertexs vertices = m_mesh->getVertexs(); + BOP_IT_Vertexs v = vertices.begin(); + const BOP_IT_Vertexs verticesEnd = vertices.end(); + + // Advance to first mergeable vertex + advance(v,m_firstVertex); + BOP_Index pos = m_firstVertex; + + // Add unbroken vertices to the list + while(v!=verticesEnd) { + if ((*v)->getTAG() != BROKEN) mergeVertices.push_back(pos); + v++;pos++; + } + + // Merge faces with that vertices + return mergeFaces(mergeVertices); +} + + +/** + * Simplifies a mesh, merging the faces with the specified vertices. + * @param mergeVertices vertices to test + * @return true if a face merge was performed + */ +bool BOP_Merge::mergeFaces(BOP_Indexs &mergeVertices) +{ + // Check size > 0! + if (mergeVertices.size() == 0) return false; + + // New faces added by merge + BOP_Faces newFaces; + + // Old faces removed by merge + BOP_Faces oldFaces; + + // Get the first vertex index and add it to + // the current pending vertices to merge + BOP_Index v = mergeVertices[0]; + BOP_Indexs pendingVertices; + pendingVertices.push_back(v); + + // Get faces with index v that come from the same original face + BOP_LFaces facesByOriginalFace; + getFaces(facesByOriginalFace,v); + + bool merged = true; + + // Check it has any unbroken face + if (facesByOriginalFace.size()==0) { + // v has not any unbroken face (so it's a new BROKEN vertex) + (m_mesh->getVertex(v))->setTAG(BROKEN); + merged = false; + } + + // Merge vertex faces + const BOP_IT_LFaces facesEnd = facesByOriginalFace.end(); + + for(BOP_IT_LFaces facesByOriginalFaceX = facesByOriginalFace.begin(); + (facesByOriginalFaceX != facesEnd)&&merged; + facesByOriginalFaceX++) { + merged = mergeFaces((*facesByOriginalFaceX),oldFaces,newFaces,pendingVertices,v); + } + + // Check if the are some pendingVertices to merge + if (pendingVertices.size() > 1 && merged) { + // There are pending vertices that we need to merge in order to merge v ... + for(unsigned int i=1;isetTAG(BROKEN); + + // ... and add merged faces (that are the new merged faces without pending vertices) + const BOP_IT_Faces newFacesEnd = newFaces.end(); + for(BOP_IT_Faces newFace=newFaces.begin();newFace!=newFacesEnd;newFace++) { + m_mesh->addFace(*newFace); + // Also, add new face vertices to the queue of vertices to merge if they weren't + for(BOP_Index i = 0;i<(*newFace)->size();i++) { + BOP_Index vertexIndex = (*newFace)->getVertex(i); + if (vertexIndex >= m_firstVertex && !containsIndex(mergeVertices,vertexIndex)) + mergeVertices.push_back(vertexIndex); + } + } + // Set the merged vertices to BROKEN ... + const BOP_IT_Indexs pendingEnd = pendingVertices.end(); + for(BOP_IT_Indexs pendingVertex = pendingVertices.begin(); pendingVertex != pendingEnd;pendingVertex++) { + BOP_Index pV = *pendingVertex; + m_mesh->getVertex(pV)->setTAG(BROKEN); + // ... and remove them from mergeVertices queue + const BOP_IT_Indexs mergeEnd = mergeVertices.end(); + for(BOP_IT_Indexs mergeVertex = mergeVertices.begin(); mergeVertex != mergeEnd;mergeVertex++) { + BOP_Index mV = *mergeVertex; + if (mV == pV) { + mergeVertices.erase(mergeVertex); + break; + } + } + } + } + else { + // The merge was not succesful, remove the vertex frome merge vertices queue + mergeVertices.erase(mergeVertices.begin()); + + // free the not used newfaces + const BOP_IT_Faces newFacesEnd = newFaces.end(); + for(BOP_IT_Faces newFace=newFaces.begin();newFace!=newFacesEnd;newFace++) { + delete (*newFace); + } + } + + // Invoke mergeFaces and return the merge result + return (mergeFaces(mergeVertices) || merged); +} + + +/** + * Simplifies a mesh, merging the faces with vertex v that come from the same face. + * @param oldFaces sequence of old mesh faces obtained from the merge + * @param newFaces sequence of new mesh faces obtained from the merge + * @param vertices sequence of indexs (v1 ... vi = v ... vn) where : + * v is the current vertex to test, + * vj (j < i) are tested vertices, + * vk (k >= i) are vertices required to test to merge vj + * (so if a vertex vk can't be merged, the merge is not possible). + * @return true if the vertex v was 'merged' (obviously it could require to test + * some new vertices that will be added to the vertices list) + */ +bool BOP_Merge::mergeFaces(BOP_Faces &oldFaces, BOP_Faces &newFaces, BOP_Indexs &vertices, BOP_Index v) { + + bool merged = true; + + // Get faces with v that come from the same original face, (without the already 'merged' from vertices) + BOP_LFaces facesByOriginalFace; + getFaces(facesByOriginalFace,vertices,v); + + if (facesByOriginalFace.size()==0) { + // All the faces with this vertex were already merged!!! + return true; + } + else { + // Merge faces + const BOP_IT_LFaces facesEnd = facesByOriginalFace.end(); + for(BOP_IT_LFaces facesByOriginalFaceX = facesByOriginalFace.begin(); + (facesByOriginalFaceX != facesEnd)&&merged; + facesByOriginalFaceX++) { + merged = mergeFaces((*facesByOriginalFaceX),oldFaces,newFaces,vertices,v); + } + } + return merged; +} + + +/** + * Merge a set of faces removing the vertex index v. + * @param faces set of faces + * @param oldFaces set of old faces obtained from the merge + * @param newFaces set of new faces obtained from the merge + * @param vertices sequence of indexs (v1 ... vi = v ... vn) where : + * v is the current vertex to test, + * vj (j < i) are tested vertices, + * vk (k >= i) are vertices required to test to merge vj + * (so if a vertex vk can't be merged, the merge is not possible). + * @param v vertex index + * @return true if the merge is succesful, false otherwise + */ +bool BOP_Merge::mergeFaces(BOP_Faces &faces, BOP_Faces &oldFaces, BOP_Faces &newFaces, BOP_Indexs &vertices, BOP_Index v) +{ + + bool merged = false; + + if (faces.size() == 2) { + // Merge a pair of faces into a new face without v + BOP_Face *faceI = faces[0]; + BOP_Face *faceJ = faces[1]; + BOP_Face *faceK = mergeFaces(faceI,faceJ,vertices,v); + if (faceK != NULL) { + newFaces.push_back(faceK); + oldFaces.push_back(faceI); + oldFaces.push_back(faceJ); + merged = true; + } + else merged = false; + } + else if (faces.size() == 4) { + // Merge two pair of faces into a new pair without v + // First we try to perform a simplify merge to avoid more pending vertices + // (for example, if we have two triangles and two quads it will be better + // to do 3+4 and 3+4 than 3+3 and 4+4) + BOP_Face *oldFace1 = faces[0]; + BOP_Face *oldFace2, *newFace1; + unsigned int indexJ = 1; + while (indexJ < faces.size() && !merged) { + oldFace2 = faces[indexJ]; + newFace1 = mergeFaces(oldFace1,oldFace2,v); + if (newFace1 != NULL) merged = true; + else indexJ++; + } + if (merged) { + // Merge the other pair of faces + unsigned int indexK, indexL; + if (indexJ == 1) {indexK = 2;indexL = 3;} + else if (indexJ == 2) {indexK = 1;indexL = 3;} + else {indexK = 1;indexL = 2;} + BOP_Face *oldFace3 = faces[indexK]; + BOP_Face *oldFace4 = faces[indexL]; + unsigned int oldSize = vertices.size(); + BOP_Face *newFace2 = mergeFaces(oldFace3,oldFace4,vertices,v); + if (newFace2 != NULL) { + newFaces.push_back(newFace1); + newFaces.push_back(newFace2); + oldFaces.push_back(oldFace1); + oldFaces.push_back(oldFace2); + oldFaces.push_back(oldFace3); + oldFaces.push_back(oldFace4); + merged = true; + } + else { + // Undo all changes + delete newFace1; + merged = false; + unsigned int count = vertices.size() - oldSize; + if (count != 0) + vertices.erase(vertices.end() - count, vertices.end()); + } + } + if (!merged) { + // Try a complete merge + merged = true; + while (faces.size()>0 && merged) { + indexJ = 1; + BOP_Face *faceI = faces[0]; + merged = false; + while (indexJ < faces.size()) { + BOP_Face *faceJ = faces[indexJ]; + BOP_Face *faceK = mergeFaces(faceI,faceJ,vertices,v); + if (faceK != NULL) { + // faceK = faceI + faceJ and it does not include v! + faces.erase(faces.begin()+indexJ,faces.begin()+(indexJ+1)); + faces.erase(faces.begin(),faces.begin()+1); + newFaces.push_back(faceK); + oldFaces.push_back(faceI); + oldFaces.push_back(faceJ); + merged = true; + break; + } + else indexJ++; + } + } + } + } + else merged = false; // there are N=1 or N=3 or N>4 faces! + + // Return merge result + return merged; +} + +/** + * Returns a new quad from the merge of two faces (one quad and one triangle) + * that share the vertex v and come from the same original face. + * @param faceI mesh face (quad or triangle) with index v + * @param faceJ mesh face (quad or triangle) with index v + * @param v vertex index shared by both faces + * @return if the merge is possible, a new quad without v + */ +BOP_Face* BOP_Merge::mergeFaces(BOP_Face *faceI, BOP_Face *faceJ, BOP_Index v) +{ + if (faceI->size() == 3) { + if (faceJ->size() == 4) + return mergeFaces((BOP_Face4*)faceJ,(BOP_Face3*)faceI,v); + } + else if (faceI->size() == 4) { + if (faceJ->size() == 3) + return mergeFaces((BOP_Face4*)faceI,(BOP_Face3*)faceJ,v); + } + return NULL; +} + +/** + * Returns a new face from the merge of two faces (quads or triangles) that + * share te vertex v and come from the same original face. + * @param faceI mesh face (quad or triangle) with index v + * @param faceJ mesh face (quad or triangle) with index v + * @param pending vector with pending vertices (required to merge two quads into + * a new quad or one quad and one triangle into a new triangle; these merges + * suppose to remove two vertexs, v and its neighbour, that will be a pending + * vertex to merge if it wasn't) + * @param v vertex index shared by both faces + * @return if the merge is possible, a new face without v + */ +BOP_Face* BOP_Merge::mergeFaces(BOP_Face *faceI, BOP_Face *faceJ, BOP_Indexs &pending, BOP_Index v) +{ + if (faceI->size() == 3) { + if (faceJ->size() == 3) + return mergeFaces((BOP_Face3*)faceI,(BOP_Face3*)faceJ,v); + else if (faceJ->size() == 4) + return mergeFaces((BOP_Face4*)faceJ,(BOP_Face3*)faceI,pending,v); + } + else if (faceI->size() == 4) { + if (faceJ->size() == 3) + return mergeFaces((BOP_Face4*)faceI,(BOP_Face3*)faceJ,pending,v); + else if (faceJ->size() == 4) + return mergeFaces((BOP_Face4*)faceI,(BOP_Face4*)faceJ,pending,v); + } + return NULL; +} + +/** + * Returns a new triangle from the merge of two triangles that share the vertex + * v and come from the same original face. + * @param faceI mesh triangle + * @param faceJ mesh triangle + * @param v vertex index shared by both triangles + * @return If the merge is possible, a new triangle without v + */ +BOP_Face* BOP_Merge::mergeFaces(BOP_Face3 *faceI, BOP_Face3 *faceJ, BOP_Index v) +{ + BOP_Face *faceK = NULL; + + // Get faces data + BOP_Index prevI, nextI, prevJ, nextJ; + faceI->getNeighbours(v,prevI,nextI); + faceJ->getNeighbours(v,prevJ,nextJ); + MT_Point3 vertex = m_mesh->getVertex(v)->getPoint(); + MT_Point3 vPrevI = m_mesh->getVertex(prevI)->getPoint(); + MT_Point3 vNextI = m_mesh->getVertex(nextI)->getPoint(); + MT_Point3 vPrevJ = m_mesh->getVertex(prevJ)->getPoint(); + MT_Point3 vNextJ = m_mesh->getVertex(nextJ)->getPoint(); + + // Merge test + if (prevI == nextJ) { + // Both faces share the edge (prevI,v) == (v,nextJ) + if (BOP_between(vertex,vNextI,vPrevJ)) { + faceK = new BOP_Face3(prevI,prevJ,nextI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + } + else if (nextI == prevJ) { + // Both faces share the edge (v,nextI) == (prevJ,v) + if (BOP_between(vertex,vPrevI,vNextJ)) { + faceK = new BOP_Face3(prevI,nextJ,nextI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + } + return faceK; +} + +/** + * Returns a new quad from the merge of one quad and one triangle that share + * the vertex v and come from the same original face. + * @param faceI mesh quad + * @param faceJ mesh triangle + * @param v vertex index shared by both faces + * @return If the merge is possible, a new quad without v + */ +BOP_Face* BOP_Merge::mergeFaces(BOP_Face4 *faceI, BOP_Face3 *faceJ, BOP_Index v) +{ + BOP_Face *faceK = NULL; + + // Get faces data + BOP_Index prevI, nextI, opp, prevJ, nextJ; + faceI->getNeighbours(v,prevI,nextI,opp); + faceJ->getNeighbours(v,prevJ,nextJ); + MT_Point3 vertex = m_mesh->getVertex(v)->getPoint(); + MT_Point3 vOpp = m_mesh->getVertex(opp)->getPoint(); + MT_Point3 vPrevI = m_mesh->getVertex(prevI)->getPoint(); + MT_Point3 vNextI = m_mesh->getVertex(nextI)->getPoint(); + MT_Point3 vPrevJ = m_mesh->getVertex(prevJ)->getPoint(); + MT_Point3 vNextJ = m_mesh->getVertex(nextJ)->getPoint(); + + // Merge test + if (prevI == nextJ) { + if (BOP_between(vertex,vNextI,vPrevJ) && !BOP_collinear(vPrevJ,vPrevI,vOpp) + && BOP_convex(vOpp,vPrevI,vPrevJ,vNextI)) { + faceK = new BOP_Face4(opp,prevI,prevJ,nextI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + } + else if (nextI == prevJ) { + if (BOP_between(vertex,vPrevI,vNextJ) && !BOP_collinear(vNextJ,vNextI,vOpp) + && BOP_convex(vOpp,vPrevI,vNextJ,vNextI)) { + faceK = new BOP_Face4(opp,prevI,nextJ,nextI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + } + return faceK; +} + +/** + * Returns a new face (quad or triangle) from the merge of one quad and one + * triangle that share the vertex v and come from the same original face. + * @param faceI mesh quad + * @param faceJ mesh triangle + * @param pending vector with pending vertices (required to merge one quad + * and one triangle into a new triangle; it supposes to remove two vertexs, + * v and its neighbour, that will be a new pending vertex if it wasn't) + * @param v vertex index shared by both faces + * @return If the merge is possible, a new face without v + */ +BOP_Face* BOP_Merge::mergeFaces(BOP_Face4 *faceI, BOP_Face3 *faceJ, BOP_Indexs &pending, BOP_Index v) +{ + BOP_Face *faceK = NULL; + + // Get faces data + BOP_Index prevI, nextI, opp, prevJ, nextJ; + faceI->getNeighbours(v,prevI,nextI,opp); + faceJ->getNeighbours(v,prevJ,nextJ); + MT_Point3 vertex = m_mesh->getVertex(v)->getPoint(); + MT_Point3 vOpp = m_mesh->getVertex(opp)->getPoint(); + MT_Point3 vPrevI = m_mesh->getVertex(prevI)->getPoint(); + MT_Point3 vNextI = m_mesh->getVertex(nextI)->getPoint(); + MT_Point3 vPrevJ = m_mesh->getVertex(prevJ)->getPoint(); + MT_Point3 vNextJ = m_mesh->getVertex(nextJ)->getPoint(); + + // Merge test + if (prevI == nextJ) { + if (BOP_between(vertex,vNextI,vPrevJ)) { + if (!BOP_collinear(vPrevJ,vPrevI,vOpp) && BOP_convex(vOpp,vPrevI,vPrevJ,vNextI)) { + // The result is a new quad + faceK = new BOP_Face4(opp,prevI,prevJ,nextI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + else if (BOP_between(vPrevI,vPrevJ,vOpp)) { + // The result is a triangle (only if prevI can be merged) + if (prevI < m_firstVertex) return NULL; // It can't be merged + faceK = new BOP_Face3(nextI,opp,prevJ,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + if (!containsIndex(pending, prevI)) pending.push_back(prevI); + } + } + } + else if (nextI == prevJ) { + if (BOP_between(vertex,vPrevI,vNextJ)) { + if (!BOP_collinear(vNextJ,vNextI,vOpp) && BOP_convex(vOpp,vPrevI,vNextJ,vNextI)) { + // The result is a new quad + faceK = new BOP_Face4(opp,prevI,nextJ,nextI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + else if (BOP_between(vNextI,vOpp,vNextJ)) { + // The result is a triangle (only if nextI can be merged) + if (nextI < m_firstVertex) return NULL; + faceK = new BOP_Face3(prevI,nextJ,opp,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + if (!containsIndex(pending, nextI)) pending.push_back(nextI); + } + } + } + return faceK; +} + +/** + * Returns a new quad from the merge of two quads that share + * the vertex v and come from the same original face. + * @param faceI mesh quad + * @param faceJ mesh quad + * @param pending vector with pending vertices (required to merge the two + * quads supposes to remove two vertexs, v and its neighbour, + * that will be a new pending vertex if it wasn't) + * @param v vertex index shared by both quads + * @return If the merge is possible, a new quad without v + */ +BOP_Face* BOP_Merge::mergeFaces(BOP_Face4 *faceI, BOP_Face4 *faceJ, BOP_Indexs &pending, BOP_Index v) +{ + BOP_Face *faceK = NULL; + + // Get faces data + BOP_Index prevI, nextI, oppI, prevJ, nextJ, oppJ; + faceI->getNeighbours(v,prevI,nextI,oppI); + faceJ->getNeighbours(v,prevJ,nextJ,oppJ); + MT_Point3 vertex = m_mesh->getVertex(v)->getPoint(); + MT_Point3 vPrevI = m_mesh->getVertex(prevI)->getPoint(); + MT_Point3 vNextI = m_mesh->getVertex(nextI)->getPoint(); + MT_Point3 vOppI = m_mesh->getVertex(oppI)->getPoint(); + MT_Point3 vPrevJ = m_mesh->getVertex(prevJ)->getPoint(); + MT_Point3 vNextJ = m_mesh->getVertex(nextJ)->getPoint(); + MT_Point3 vOppJ = m_mesh->getVertex(oppJ)->getPoint(); + + // Merge test + if (prevI == nextJ) { + // prevI/nextJ will be a new vertex required to merge + if (prevI < m_firstVertex) return NULL; // It can't be merged + if (BOP_between(vertex,vPrevJ,vNextI) && BOP_between(vNextJ,vOppJ,vOppI)) { + faceK = new BOP_Face4(oppJ,prevJ,nextI,oppI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + // We add prevI to the pending list if it wasn't yet + if (!containsIndex(pending, prevI)) pending.push_back(prevI); + } + } + else if (nextI == prevJ) { + // nextI/prevJ will be a new vertex required to merge + if (nextI < m_firstVertex) return NULL; // It can't be merged + if (BOP_between(vertex,vPrevI,vNextJ) && BOP_between(vNextI,vOppI,vOppJ)) { + faceK = new BOP_Face4(oppI,prevI,nextJ,oppJ,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + // Add nextI to the pending list if it wasn't yet + if (!containsIndex(pending, nextI)) pending.push_back(nextI); + } + } + return faceK; +} + + +/** + * Simplifies the mesh, merging the pairs of triangles that come frome the + * same original face and define a quad. + * @return true if a quad was added, false otherwise + */ +bool BOP_Merge::createQuads() +{ + + BOP_Faces quads; + + // Get mesh faces + BOP_Faces faces = m_mesh->getFaces(); + + // Merge mesh triangles + const BOP_IT_Faces facesIEnd = (faces.end()-1); + const BOP_IT_Faces facesJEnd = faces.end(); + for(BOP_IT_Faces faceI=faces.begin();faceI!=facesIEnd;faceI++) { + if ((*faceI)->getTAG() == BROKEN || (*faceI)->size() != 3) continue; + for(BOP_IT_Faces faceJ=(faceI+1);faceJ!=facesJEnd;faceJ++) { + if ((*faceJ)->getTAG() == BROKEN || (*faceJ)->size() != 3 || + (*faceJ)->getOriginalFace() != (*faceI)->getOriginalFace()) continue; + + // Test if both triangles share a vertex index + BOP_Index v; + bool found = false; + for(unsigned int i=0;i<3 && !found;i++) { + v = (*faceI)->getVertex(i); + found = (*faceJ)->containsVertex(v); + + } + if (!found) continue; + + BOP_Face *faceK = createQuad((BOP_Face3*)*faceI,(BOP_Face3*)*faceJ,v); + if (faceK != NULL) { + // Set triangles to BROKEN + (*faceI)->setTAG(BROKEN); + (*faceJ)->setTAG(BROKEN); + quads.push_back(faceK); + break; + } + } + } + + // Add quads to mesh + const BOP_IT_Faces quadsEnd = quads.end(); + for(BOP_IT_Faces quad=quads.begin();quad!=quadsEnd;quad++) m_mesh->addFace(*quad); + return (quads.size() > 0); +} + +/** + * Returns a new quad (convex) from the merge of two triangles that share the + * vertex index v. + * @param faceI mesh triangle + * @param faceJ mesh triangle + * @param v vertex index shared by both triangles + * @return a new convex quad if the merge is possible + */ +BOP_Face* BOP_Merge::createQuad(BOP_Face3 *faceI, BOP_Face3 *faceJ, BOP_Index v) +{ + BOP_Face *faceK = NULL; + + // Get faces data + BOP_Index prevI, nextI, prevJ, nextJ; + faceI->getNeighbours(v,prevI,nextI); + faceJ->getNeighbours(v,prevJ,nextJ); + MT_Point3 vertex = m_mesh->getVertex(v)->getPoint(); + MT_Point3 vPrevI = m_mesh->getVertex(prevI)->getPoint(); + MT_Point3 vNextI = m_mesh->getVertex(nextI)->getPoint(); + MT_Point3 vPrevJ = m_mesh->getVertex(prevJ)->getPoint(); + MT_Point3 vNextJ = m_mesh->getVertex(nextJ)->getPoint(); + + // Quad test + if (prevI == nextJ) { + if (!BOP_collinear(vNextI,vertex,vPrevJ) && !BOP_collinear(vNextI,vPrevI,vPrevJ) && + BOP_convex(vertex,vNextI,vPrevI,vPrevJ)) { + faceK = new BOP_Face4(v,nextI,prevI,prevJ,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + } + else if (nextI == prevJ) { + if (!BOP_collinear(vPrevI,vertex,vNextJ) && !BOP_collinear(vPrevI,vNextI,vNextJ) && + BOP_convex(vertex,vNextJ,vNextI,vPrevI)) { + faceK = new BOP_Face4(v,nextJ,nextI,prevI,faceI->getPlane(),faceI->getOriginalFace()); + faceK->setTAG(faceI->getTAG()); + } + } + return faceK; +} + +/** + * Returns if a index is inside a set of indexs. + * @param indexs set of indexs + * @param i index + * @return true if the index is inside the set, false otherwise + */ +bool BOP_Merge::containsIndex(BOP_Indexs indexs, BOP_Index i) +{ + const BOP_IT_Indexs indexsEnd = indexs.end(); + for(BOP_IT_Indexs it=indexs.begin();it!=indexsEnd;it++) { + if (*it == i) return true; + } + return false; +} + +/** + * Creates a list of lists L1, L2, ... LN where + * LX = mesh faces with vertex v that come from the same original face + * @param facesByOriginalFace list of faces lists + * @param v vertex index + */ +void BOP_Merge::getFaces(BOP_LFaces &facesByOriginalFace, BOP_Index v) +{ + // Get edges with vertex v + BOP_Indexs edgeIndexs = m_mesh->getVertex(v)->getEdges(); + const BOP_IT_Indexs edgeEnd = edgeIndexs.end(); + for(BOP_IT_Indexs edgeIndex = edgeIndexs.begin();edgeIndex != edgeEnd;edgeIndex++) { + // Foreach edge, add its no broken faces to the output list + BOP_Edge* edge = m_mesh->getEdge(*edgeIndex); + BOP_Indexs faceIndexs = edge->getFaces(); + const BOP_IT_Indexs faceEnd = faceIndexs.end(); + for(BOP_IT_Indexs faceIndex=faceIndexs.begin();faceIndex!=faceEnd;faceIndex++) { + BOP_Face* face = m_mesh->getFace(*faceIndex); + if (face->getTAG() != BROKEN) { + bool found = false; + // Search if we already have created a list for the + // faces that come from the same original face + const BOP_IT_LFaces lfEnd = facesByOriginalFace.end(); + for(BOP_IT_LFaces facesByOriginalFaceX=facesByOriginalFace.begin(); + facesByOriginalFaceX!=lfEnd; facesByOriginalFaceX++) { + if (((*facesByOriginalFaceX)[0])->getOriginalFace() == face->getOriginalFace()) { + // Search that the face has not been added to the list before + for(unsigned int i = 0;i<(*facesByOriginalFaceX).size();i++) { + if ((*facesByOriginalFaceX)[i] == face) { + found = true; + break; + } + } + if (!found) { + // Add the face to the list + if (face->getTAG()==OVERLAPPED) facesByOriginalFaceX->insert(facesByOriginalFaceX->begin(),face); + else facesByOriginalFaceX->push_back(face); + found = true; + } + break; + } + } + if (!found) { + // Create a new list and add the current face + BOP_Faces facesByOriginalFaceX; + facesByOriginalFaceX.push_back(face); + facesByOriginalFace.push_back(facesByOriginalFaceX); + } + } + } + } +} + +/** + * Creates a list of lists L1, L2, ... LN where + * LX = mesh faces with vertex v that come from the same original face + * and without any of the vertices that appear before v in vertices + * @param facesByOriginalFace list of faces lists + * @param vertices vector with vertices indexs that contains v + * @param v vertex index + */ +void BOP_Merge::getFaces(BOP_LFaces &facesByOriginalFace, BOP_Indexs vertices, BOP_Index v) +{ + // Get edges with vertex v + BOP_Indexs edgeIndexs = m_mesh->getVertex(v)->getEdges(); + const BOP_IT_Indexs edgeEnd = edgeIndexs.end(); + for(BOP_IT_Indexs edgeIndex = edgeIndexs.begin();edgeIndex != edgeEnd;edgeIndex++) { + // Foreach edge, add its no broken faces to the output list + BOP_Edge* edge = m_mesh->getEdge(*edgeIndex); + BOP_Indexs faceIndexs = edge->getFaces(); + const BOP_IT_Indexs faceEnd = faceIndexs.end(); + for(BOP_IT_Indexs faceIndex=faceIndexs.begin();faceIndex!=faceEnd;faceIndex++) { + BOP_Face* face = m_mesh->getFace(*faceIndex); + if (face->getTAG() != BROKEN) { + // Search if the face contains any of the forbidden vertices + bool found = false; + for(BOP_IT_Indexs vertex = vertices.begin();*vertex!= v;vertex++) { + if (face->containsVertex(*vertex)) { + // face contains a forbidden vertex! + found = true; + break; + } + } + if (!found) { + // Search if we already have created a list with the + // faces that come from the same original face + const BOP_IT_LFaces lfEnd = facesByOriginalFace.end(); + for(BOP_IT_LFaces facesByOriginalFaceX=facesByOriginalFace.begin(); + facesByOriginalFaceX!=lfEnd; facesByOriginalFaceX++) { + if (((*facesByOriginalFaceX)[0])->getOriginalFace() == face->getOriginalFace()) { + // Search that the face has not been added to the list before + for(unsigned int i = 0;i<(*facesByOriginalFaceX).size();i++) { + if ((*facesByOriginalFaceX)[i] == face) { + found = true; + break; + } + } + if (!found) { + // Add face to the list + if (face->getTAG()==OVERLAPPED) facesByOriginalFaceX->insert(facesByOriginalFaceX->begin(),face); + else facesByOriginalFaceX->push_back(face); + found = true; + } + break; + } + } + if (!found) { + // Create a new list and add the current face + BOP_Faces facesByOriginalFaceX; + facesByOriginalFaceX.push_back(face); + facesByOriginalFace.push_back(facesByOriginalFaceX); + } + } + } + } + } +} diff --git a/intern/boolop/intern/BOP_Merge.h b/intern/boolop/intern/BOP_Merge.h new file mode 100644 index 00000000000..2ccce8e137b --- /dev/null +++ b/intern/boolop/intern/BOP_Merge.h @@ -0,0 +1,74 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_MERGE_H +#define BOP_MERGE_H + +#include "BOP_Mesh.h" +#include "BOP_Tag.h" +#include "BOP_MathUtils.h" +#include "MEM_SmartPtr.h" + +typedef vector< BOP_Faces > BOP_LFaces; +typedef vector< BOP_Faces >::iterator BOP_IT_LFaces; + +class BOP_Merge { + private: + BOP_Mesh* m_mesh; + BOP_Index m_firstVertex; + static BOP_Merge SINGLETON; + + BOP_Merge() {}; + bool mergeFaces(); + bool mergeFaces(BOP_Indexs &mergeVertices); + bool mergeFaces(BOP_Faces &oldFaces, BOP_Faces &newFaces, BOP_Indexs &vertices, BOP_Index v); + bool mergeFaces(BOP_Faces &faces, BOP_Faces &oldFaces, BOP_Faces &newFaces, BOP_Indexs &vertices, BOP_Index v); + BOP_Face *mergeFaces(BOP_Face *faceI, BOP_Face *faceJ, BOP_Index v); + BOP_Face *mergeFaces(BOP_Face *faceI, BOP_Face *faceJ, BOP_Indexs &pending, BOP_Index v); + BOP_Face *mergeFaces(BOP_Face3 *faceI, BOP_Face3 *faceJ, BOP_Index v); + BOP_Face *mergeFaces(BOP_Face4 *faceI, BOP_Face3 *faceJ, BOP_Index v); + BOP_Face *mergeFaces(BOP_Face4 *faceI, BOP_Face3 *faceJ, BOP_Indexs &pending, BOP_Index v); + BOP_Face *mergeFaces(BOP_Face4 *faceI, BOP_Face4 *faceJ, BOP_Indexs &pending, BOP_Index v); + bool createQuads(); + BOP_Face *createQuad(BOP_Face3 *faceI, BOP_Face3 *faceJ, BOP_Index v); + bool containsIndex(BOP_Indexs indexs, BOP_Index index); + void getFaces(BOP_LFaces &facesByOriginalFace, BOP_Index v); + void getFaces(BOP_LFaces &facesByOriginalFace, BOP_Indexs vertices, BOP_Index v); + + public: + + static BOP_Merge &getInstance() { + return SINGLETON; + } + + void mergeFaces(BOP_Mesh *m, BOP_Index v); +}; + +#endif diff --git a/intern/boolop/intern/BOP_Mesh.cpp b/intern/boolop/intern/BOP_Mesh.cpp new file mode 100644 index 00000000000..d8193f9c4b0 --- /dev/null +++ b/intern/boolop/intern/BOP_Mesh.cpp @@ -0,0 +1,835 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Mesh.h" +#include "BOP_MathUtils.h" +#include +#include + + +/** + * Destroys a mesh. + */ +BOP_Mesh::~BOP_Mesh() +{ + const BOP_IT_Vertexs vertexsEnd = m_vertexs.end(); + for(BOP_IT_Vertexs it=m_vertexs.begin();it!=vertexsEnd;it++){ + delete *it; + } + m_vertexs.clear(); + + const BOP_IT_Edges edgesEnd = m_edges.end(); + for(BOP_IT_Edges it=m_edges.begin();it!=edgesEnd;it++){ + delete *it; + } + m_edges.clear(); + + const BOP_IT_Faces facesEnd = m_faces.end(); + for(BOP_IT_Faces it=m_faces.begin();it!=facesEnd;it++){ + delete *it; + } + m_faces.clear(); +} + +/** + * Adds a new vertex. + * @param p vertex point + * @return mesh vertex index + */ +BOP_Index BOP_Mesh::addVertex(MT_Point3 p) +{ + m_vertexs.push_back(new BOP_Vertex(p)); + return m_vertexs.size()-1; +} + +/** + * Adds a new edge. + * @param v1 mesh vertex index + * @param v2 mesh vertex index + * @return mesh edge index + */ +BOP_Index BOP_Mesh::addEdge(BOP_Index v1, BOP_Index v2) +{ + m_edges.push_back(new BOP_Edge(v1,v2)); + return (m_edges.size()-1); +} + +/** + * Adds a new face. + * @param face mesh face + * @return mesh face index + */ +BOP_Index BOP_Mesh::addFace(BOP_Face *face) +{ + if (face->size()==3) + return addFace((BOP_Face3 *)face); + else + return addFace((BOP_Face4 *)face); +} + +/** + * Adds a new triangle. + * @param face mesh triangle + * @return mesh face index + */ +BOP_Index BOP_Mesh::addFace(BOP_Face3 *face) +{ + BOP_Index indexface = m_faces.size(); + + BOP_Index index1 = face->getVertex(0); + BOP_Index index2 = face->getVertex(1); + BOP_Index index3 = face->getVertex(2); + + m_faces.push_back((BOP_Face *)face); + + BOP_Index edge; + + if (!getIndexEdge(index1,index2,edge)) { + edge = addEdge(index1,index2); + getVertex(index1)->addEdge(edge); + getVertex(index2)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if (!getIndexEdge(index2,index3,edge)) { + edge = addEdge(index2,index3); + getVertex(index2)->addEdge(edge); + getVertex(index3)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if (!getIndexEdge(index3,index1,edge)) { + edge = addEdge(index3,index1); + getVertex(index3)->addEdge(edge); + getVertex(index1)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if ((index1 == index2) || (index1 == index3) || (index2 == index3)) + face->setTAG(BROKEN); + + return indexface; +} + +/** + * Adds a new quad. + * @param face mesh quad + * @return mesh face index + */ +BOP_Index BOP_Mesh::addFace(BOP_Face4 *face) +{ + m_faces.push_back((BOP_Face *)face); + BOP_Index indexface = m_faces.size()-1; + + BOP_Index index1 = face->getVertex(0); + BOP_Index index2 = face->getVertex(1); + BOP_Index index3 = face->getVertex(2); + BOP_Index index4 = face->getVertex(3); + + BOP_Index edge; + + if (!getIndexEdge(index1,index2,edge)) { + edge = addEdge(index1,index2); + getVertex(index1)->addEdge(edge); + getVertex(index2)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if (!getIndexEdge(index2,index3,edge)) { + edge = addEdge(index2,index3); + getVertex(index2)->addEdge(edge); + getVertex(index3)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if (!getIndexEdge(index3,index4,edge)) { + edge = addEdge(index3,index4); + getVertex(index3)->addEdge(edge); + getVertex(index4)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if (!getIndexEdge(index4,index1,edge)) { + edge = addEdge(index4,index1); + getVertex(index4)->addEdge(edge); + getVertex(index1)->addEdge(edge); + } + + getEdge(edge)->addFace(indexface); + + if ((index1 == index2) || (index1 == index3) || (index1 == index4) || + (index2 == index3) || (index2 == index4) || (index3 == index4)) + face->setTAG(BROKEN); + + return m_faces.size()-1; +} + +/** + * Returns if a faces set contains the specified face. + * @param faces faces set + * @param face face + * @return true if the set contains the specified face + */ +bool BOP_Mesh::containsFace(BOP_Faces *faces, BOP_Face *face) +{ + const BOP_IT_Faces facesEnd = faces->end(); + for(BOP_IT_Faces it = faces->begin();it!=facesEnd;it++) { + if (face == *it) + return true; + } + + return false; +} +/** + * Returns the first edge with the specified vertex index from a list of edge indexs. + * @param edges edge indexs + * @param v vertex index + * @return first edge with the specified vertex index, NULL otherwise + */ +BOP_Edge* BOP_Mesh::getEdge(BOP_Indexs edges, BOP_Index v) +{ + const BOP_IT_Indexs edgesEnd = edges.end(); + for(BOP_IT_Indexs it=edges.begin();it!=edgesEnd;it++){ + BOP_Edge *edge = m_edges[*it]; + if ((edge->getVertex1() == v) || (edge->getVertex2() == v)) + return edge; + } + return NULL; +} + +/** + * Returns the mesh edge with the specified vertex indexs. + * @param v1 vertex index + * @param v2 vertex index + * @return mesh edge with the specified vertex indexs, NULL otherwise + */ +BOP_Edge* BOP_Mesh::getEdge(BOP_Index v1, BOP_Index v2) +{ + const BOP_IT_Edges edgesEnd = m_edges.end(); + for(BOP_IT_Edges edge=m_edges.begin();edge!=edgesEnd;edge++) { + if (((*edge)->getVertex1() == v1 && (*edge)->getVertex2() == v2) || + ((*edge)->getVertex1() == v2 && (*edge)->getVertex2() == v1)) + return *edge; + } + return NULL; +} + +/** + * Returns the mesh edge index with the specified vertex indexs. + * @param v1 vertex index + * @param v2 vertex index + * @param e edge index with the specified vertex indexs + * @return true if there is a mesh edge with the specified vertex indexs, false otherwise + */ +bool BOP_Mesh::getIndexEdge(BOP_Index v1, BOP_Index v2, BOP_Index &e) +{ + BOP_Index pos=0; + const BOP_IT_Edges edgesEnd = m_edges.end(); + for(BOP_IT_Edges edge=m_edges.begin();edge!=edgesEnd;edge++,pos++) { + if (((*edge)->getVertex1() == v1 && (*edge)->getVertex2() == v2) || + ((*edge)->getVertex1() == v2 && (*edge)->getVertex2() == v1)){ + e = pos; + return true; + } + } + return false; +} + +/** + * Returns the mesh edge on the specified face and relative edge index. + * @param face mesh face + * @param edge face relative edge index + * @return mesh edge on the specified face and relative index, NULL otherwise + */ +BOP_Edge* BOP_Mesh::getEdge(BOP_Face *face, unsigned int edge) +{ + if (face->size()==3) + return getEdge((BOP_Face3 *)face,edge); + else + return getEdge((BOP_Face4 *)face,edge); +} + +/** + * Returns the mesh edge on the specified triangle and relative edge index. + * @param face mesh triangle + * @param edge face relative edge index + * @return mesh edge on the specified triangle and relative index, NULL otherwise + */ +BOP_Edge* BOP_Mesh::getEdge(BOP_Face3 *face, unsigned int edge) +{ + switch(edge){ + case 1: + return getEdge(m_vertexs[face->getVertex(0)]->getEdges(),face->getVertex(1)); + case 2: + return getEdge(m_vertexs[face->getVertex(1)]->getEdges(),face->getVertex(2)); + case 3: + return getEdge(m_vertexs[face->getVertex(2)]->getEdges(),face->getVertex(0)); + }; + + return NULL; +} + +/** + * Returns the mesh edge on the specified quad and relative edge index. + * @param face mesh quad + * @param edge face relative edge index + * @return mesh edge on the specified quad and relative index, NULL otherwise + */ +BOP_Edge * BOP_Mesh::getEdge(BOP_Face4 *face, unsigned int edge) +{ + switch(edge){ + case 1: + return getEdge(m_vertexs[face->getVertex(0)]->getEdges(),face->getVertex(1)); + case 2: + return getEdge(m_vertexs[face->getVertex(1)]->getEdges(),face->getVertex(2)); + case 3: + return getEdge(m_vertexs[face->getVertex(2)]->getEdges(),face->getVertex(3)); + case 4: + return getEdge(m_vertexs[face->getVertex(3)]->getEdges(),face->getVertex(0)); + }; + + return NULL; +} + +/** + * Returns the mesh face with the specified vertex indexs. + * @param v1 vertex index + * @param v2 vertex index + * @param v3 vertex index + * @return mesh edge with the specified vertex indexs, NULL otherwise + */ +BOP_Face* BOP_Mesh::getFace(BOP_Index v1, BOP_Index v2, BOP_Index v3) +{ + const BOP_IT_Faces facesEnd = m_faces.end(); + for(BOP_IT_Faces face=m_faces.begin();face!=facesEnd;face++) { + if ((*face)->containsVertex(v1) && (*face)->containsVertex(v2) && + (*face)->containsVertex(v3)) + return (*face); + } + return NULL; +} + +/** + * Returns the mesh face index with the specified vertex indexs. + * @param v1 vertex index + * @param v2 vertex index + * @param v3 vertex index + * @param f face index with the specified vertex indexs + * @return true if there is a mesh face with the specified vertex indexs, false otherwise + */ +bool BOP_Mesh::getIndexFace(BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index &f) +{ + BOP_Index pos=0; + const BOP_IT_Faces facesEnd = m_faces.end(); + for(BOP_IT_Faces face=m_faces.begin();face!=facesEnd;face++,pos++) { + if ((*face)->containsVertex(v1) && (*face)->containsVertex(v2) && + (*face)->containsVertex(v3)){ + f = pos; + return true; + } + } + return false; +} + +/** + * Returns the vertices set of this mesh. + * @return vertices set + */ +BOP_Vertexs &BOP_Mesh::getVertexs() +{ + return m_vertexs; +} + +/** + * Returns the edges set of this mesh. + * @return edges set + */ +BOP_Edges &BOP_Mesh::getEdges() +{ + return m_edges; +} + +/** + * Returns the faces set of this mesh. + * @return faces set + */ +BOP_Faces &BOP_Mesh::getFaces() +{ + return m_faces; +} + +/** + * Returns the mesh vertex with the specified index. + * @param i vertex index + * @return vertex with the specified index + */ +BOP_Vertex* BOP_Mesh::getVertex(BOP_Index i) +{ + return m_vertexs[i]; +} + +/** + * Returns the mesh edge with the specified index. + * @param i edge index + * @return edge with the specified index + */ +BOP_Edge* BOP_Mesh::getEdge(BOP_Index i) +{ + return m_edges[i]; +} + +/** + * Returns the mesh face with the specified index. + * @param i face index + * @return face with the specified index + */ +BOP_Face* BOP_Mesh::getFace(BOP_Index i) +{ + return m_faces[i]; +} + +/** + * Returns the number of vertices of this mesh. + * @return number of vertices + */ +unsigned int BOP_Mesh::getNumVertexs() +{ + return m_vertexs.size(); +} + +/** + * Returns the number of edges of this mesh. + * @return number of edges + */ +unsigned int BOP_Mesh::getNumEdges() +{ + return m_edges.size(); +} + +/** + * Returns the number of faces of this mesh. + * @return number of faces + */ +unsigned int BOP_Mesh::getNumFaces() +{ + return m_faces.size(); +} + +/** + * Returns the number of vertices of this mesh with the specified tag. + * @return number of vertices with the specified tag + */ +unsigned int BOP_Mesh::getNumVertexs(BOP_TAG tag) +{ + unsigned int count = 0; + const BOP_IT_Vertexs vertexsEnd = m_vertexs.end(); + for(BOP_IT_Vertexs vertex=m_vertexs.begin();vertex!=vertexsEnd;vertex++) { + if ((*vertex)->getTAG() == tag) count++; + } + return count; +} +/** + * Returns the number of faces of this mesh with the specified tag. + * @return number of faces with the specified tag + */ +unsigned int BOP_Mesh::getNumFaces(BOP_TAG tag) +{ + unsigned int count = 0; + const BOP_IT_Faces facesEnd = m_faces.end(); + for(BOP_IT_Faces face=m_faces.begin();face!=facesEnd;face++) { + if ((*face)->getTAG() == tag) count++; + } + return count; +} + +/** + * Replaces a vertex index. + * @param oldIndex old vertex index + * @param newIndex new vertex index + */ +BOP_Index BOP_Mesh::replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex) +{ + if (oldIndex==newIndex) return newIndex; + + // Update faces, edges and vertices + BOP_Vertex *oldVertex = m_vertexs[oldIndex]; + BOP_Vertex *newVertex = m_vertexs[newIndex]; + BOP_Indexs oldEdges = oldVertex->getEdges(); + + BOP_Index edgeIdx=0; + bool found = false; + + // Update faces to the newIndex + BOP_IT_Indexs oldEdgesEnd = oldEdges.end(); + for(BOP_IT_Indexs oldEdgeIndex=oldEdges.begin();oldEdgeIndex!=oldEdgesEnd; + oldEdgeIndex++) { + BOP_Edge *edge = m_edges[*oldEdgeIndex]; + if ((edge->getVertex1()==oldIndex && edge->getVertex2()==newIndex) || + (edge->getVertex2()==oldIndex && edge->getVertex1()==newIndex)) { + // Remove old edge ==> set edge faces to BROKEN + BOP_Indexs edgeFaces = edge->getFaces(); + const BOP_IT_Indexs edgeFacesEnd = edgeFaces.end(); + for(BOP_IT_Indexs idxFace=edgeFaces.begin();idxFace!=edgeFacesEnd; + idxFace++) { + m_faces[*idxFace]->setTAG(BROKEN); + } + edgeIdx = *oldEdgeIndex; + found = true; + } + else { + BOP_Indexs faces = edge->getFaces(); + const BOP_IT_Indexs facesEnd = faces.end(); + for(BOP_IT_Indexs face=faces.begin();face!=facesEnd;face++) { + if (m_faces[*face]->getTAG()!=BROKEN) + m_faces[*face]->replaceVertexIndex(oldIndex,newIndex); + } + } + } + if (found) { + oldVertex->removeEdge(edgeIdx); + newVertex->removeEdge(edgeIdx); + } + + oldEdgesEnd = oldEdges.end(); + for(BOP_IT_Indexs oldEdgeIndex=oldEdges.begin();oldEdgeIndex!=oldEdgesEnd; + oldEdgeIndex++) { + BOP_Edge * edge = m_edges[*oldEdgeIndex]; + BOP_Edge * edge2; + BOP_Index v1 = edge->getVertex1(); + + v1 = (v1==oldIndex?edge->getVertex2():v1); + if ((edge2 = getEdge(newIndex,v1)) == NULL) { + edge->replaceVertexIndex(oldIndex,newIndex); + newVertex->addEdge(*oldEdgeIndex); + } + else { + BOP_Indexs faces = edge->getFaces(); + const BOP_IT_Indexs facesEnd = faces.end(); + for(BOP_IT_Indexs f=faces.begin();f!=facesEnd;f++) { + if (m_faces[*f]->getTAG()!=BROKEN) + edge2->addFace(*f); + } + BOP_Vertex *oppositeVertex = m_vertexs[v1]; + oppositeVertex->removeEdge(*oldEdgeIndex); + edge->replaceVertexIndex(oldIndex,newIndex); + } + } + oldVertex->setTAG(BROKEN); + + return newIndex; +} + + + +/** *************************************************************************** + * DEBUG METHODS * + * This functions are used to test the mesh state and debug program errors. * + ******************************************************************************/ + +/** + * print + */ +void BOP_Mesh::print() +{ + cout << "--Faces--" << endl; + for(unsigned int i=0;igetPoint() << endl; + } +} + +/** + * printFormat + */ +void BOP_Mesh::printFormat(BOP_Faces *faces) +{ + if (faces->size()) { + for(unsigned int it=1;itsize();it++) { + if ((*faces)[it]->getTAG()!=BROKEN) { + cout << m_vertexs[(*faces)[it]->getVertex(0)]->getPoint() << " "; + cout << m_vertexs[(*faces)[it]->getVertex(1)]->getPoint() << " "; + cout << m_vertexs[(*faces)[it]->getVertex(2)]->getPoint() << endl; + } + } + } +} + +/** + * saveFormat + */ +void BOP_Mesh::saveFormat(BOP_Faces *faces,char *filename) +{ + ofstream fout(filename); + + if (!fout.is_open()) { + cerr << "BOP_Mesh::saveFormat Error: Could not create file." << endl; + return; + } + + unsigned int count = 0; + if (faces->size()) { + for(unsigned int it=0;itsize();it++) { + if ((*faces)[it]->getTAG()!=BROKEN) { + count++; + } + } + } + + fout << count << endl; + if (faces->size()) { + for(unsigned int it=0;itsize();it++) { + if ((*faces)[it]->getTAG()!=BROKEN){ + fout << m_vertexs[(*faces)[it]->getVertex(0)]->getPoint() << " "; + fout << m_vertexs[(*faces)[it]->getVertex(1)]->getPoint() << " "; + fout << m_vertexs[(*faces)[it]->getVertex(2)]->getPoint() << endl; + } + } + } + + fout.close(); +} + +/** + * printFormat + */ +void BOP_Mesh::printFormat() +{ + cout << "--Vertices--" << endl; + if (m_vertexs.size()>0) { + cout << "{" << m_vertexs[0]->getPoint().x() << ","; + cout << m_vertexs[0]->getPoint().y() << ","; + cout << m_vertexs[0]->getPoint().z() << "}"; + for(unsigned int i=1;igetPoint().x() << ","; + cout << m_vertexs[i]->getPoint().y() << ","; + cout << m_vertexs[i]->getPoint().z() << "}"; + } + cout << endl; + } + + cout << "--Faces--" << endl; + if (m_faces.size()>0) { + cout << "{" << m_faces[0]->getVertex(0) << ","; + cout << m_faces[0]->getVertex(1) << "," << m_faces[0]->getVertex(2) << "}"; + for(unsigned int i=1;igetVertex(0) << ","; + cout << m_faces[i]->getVertex(1) << "," << m_faces[i]->getVertex(2) << "}"; + } + cout << endl; + } +} + +/** + * printFace + */ +void BOP_Mesh::printFace(BOP_Face *face, int col) +{ + cout << "--Face" << endl; + cout << m_vertexs[face->getVertex(0)]->getPoint(); + cout << " " << m_vertexs[face->getVertex(1)]->getPoint(); + cout << " " << m_vertexs[face->getVertex(2)]->getPoint(); + if (face->size()==4) + cout << " " << m_vertexs[face->getVertex(3)]->getPoint(); + cout << " " << col << endl; +} + +/** + * testMesh + */ +void BOP_Mesh::testMesh() +{ + + BOP_Face* cares[10]; + unsigned int nedges=0; + for(unsigned int i=0;igetFaces(); + unsigned int count = 0; + const BOP_IT_Indexs facesEnd = faces.end(); + for(BOP_IT_Indexs it = faces.begin();it!=facesEnd;it++) { + if (m_faces[*it]->getTAG()!=BROKEN) { + cares[count] = m_faces[*it]; + count++; + + } + } + + if ((count%2)!=0) nedges++; + } + if (nedges) + cout << nedges << " wrong edges." << endl; + else + cout << "well edges." << endl; + + unsigned int duplFaces = 0; + unsigned int wrongFaces = 0; + for(unsigned int i=0;igetTAG()==BROKEN) + continue; + + if (testFace(faceI)){ + wrongFaces++; + cout << "Wrong Face: " << faceI << endl; + } + + for(unsigned int j=i+1;jgetTAG()==BROKEN) + continue; + + if (testFaces(faceI,faceJ)){ + duplFaces++; + cout << "Duplicate FaceI: " << faceI << endl; + cout << "Duplicate FaceJ: " << faceJ << endl; + } + } + } + + cout << duplFaces << " duplicate faces." << endl; + cout << wrongFaces << " wrong faces." << endl; +} + +/** + * testFace + */ +bool BOP_Mesh::testFace(BOP_Face *face){ + + for(unsigned int i=0;isize();i++){ + for(unsigned int j=i+1;jsize();j++){ + if (face->getVertex(i)==face->getVertex(j)) + return true; + } + } + + return false; +} + +/** + * testFaces + */ +bool BOP_Mesh::testFaces(BOP_Face *faceI, BOP_Face *faceJ){ + + if (faceI->size()size()){ + for(unsigned int i=0;isize();i++){ + if (!faceJ->containsVertex(faceI->getVertex(i))) + return false; + } + //faceI->setTAG(BROKEN); + } + else{ + for(unsigned int i=0;isize();i++){ + if (!faceI->containsVertex(faceJ->getVertex(i))) + return false; + } + //faceJ->setTAG(BROKEN); + } + + return true; +} + +/** + * testPlane + */ +void BOP_Mesh::testPlane(BOP_Face *face) +{ + MT_Plane3 plane1(m_vertexs[face->getVertex(0)]->getPoint(), + m_vertexs[face->getVertex(1)]->getPoint(), + m_vertexs[face->getVertex(2)]->getPoint()); + + if (BOP_orientation(plane1,face->getPlane()) < 0) { + cout << "Test Plane " << face << " v1: "; + cout << m_vertexs[face->getVertex(0)]->getPoint() << " v2: "; + cout << m_vertexs[face->getVertex(1)]->getPoint() << " v3: "; + cout << m_vertexs[face->getVertex(2)]->getPoint() << " plane: "; + cout << face->getPlane() << endl; + cout << "Incorrect vertices order!!! plane1: " << plane1 << " ("; + cout << BOP_orientation(plane1,face->getPlane()) << ") " << " invert "; + cout << MT_Plane3(m_vertexs[face->getVertex(2)]->getPoint(), + m_vertexs[face->getVertex(1)]->getPoint(), + m_vertexs[face->getVertex(0)]->getPoint()) << endl; + if (BOP_collinear(m_vertexs[face->getVertex(0)]->getPoint(), + m_vertexs[face->getVertex(1)]->getPoint(), + m_vertexs[face->getVertex(2)]->getPoint())) { + cout << " COLLINEAR!!!" << endl; + } + else { + cout << endl; + } + } +} + +/** + * testEdges + */ +bool BOP_Mesh::testEdges(BOP_Faces *facesObj) +{ + for(unsigned int i=0;igetFaces(); + unsigned int count = 0; + const BOP_IT_Indexs facesEnd = faces.end(); + for(BOP_IT_Indexs it = faces.begin();it!=facesEnd;it++) { + if ((m_faces[*it]->getTAG()!=BROKEN) && containsFace(facesObj,m_faces[*it])) + count++; + } + if ((count%2)!=0) { + return false; + } + } + + return true; +} + +/** + * updatePlanes + */ +void BOP_Mesh::updatePlanes() +{ + const BOP_IT_Faces facesEnd = m_faces.end(); + for(BOP_IT_Faces it = m_faces.begin();it!=facesEnd;it++) { + BOP_Face *face = *it; + MT_Plane3 plane(m_vertexs[face->getVertex(0)]->getPoint(), + m_vertexs[face->getVertex(1)]->getPoint(), + m_vertexs[face->getVertex(2)]->getPoint()); + face->setPlane(plane); + } +} diff --git a/intern/boolop/intern/BOP_Mesh.h b/intern/boolop/intern/BOP_Mesh.h new file mode 100644 index 00000000000..6751df7c4e7 --- /dev/null +++ b/intern/boolop/intern/BOP_Mesh.h @@ -0,0 +1,97 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_MESH_H +#define BOP_MESH_H + +#include "BOP_Vertex.h" +#include "BOP_Edge.h" +#include "BOP_Face.h" + +typedef vector BOP_Vertexs; +typedef vector BOP_Edges; + +typedef vector::iterator BOP_IT_Vertexs; +typedef vector::iterator BOP_IT_Edges; + +class BOP_Mesh +{ +private: + BOP_Vertexs m_vertexs; + BOP_Edges m_edges; + BOP_Faces m_faces; + + BOP_Index addEdge(BOP_Index v1, BOP_Index v2); + BOP_Edge *getEdge(BOP_Indexs edges, BOP_Index v2); + bool containsFace(BOP_Faces *faces, BOP_Face *face); + + bool testEdges(BOP_Faces *faces); + bool testFaces(BOP_Face *faceI, BOP_Face *faceJ); + bool testFace(BOP_Face *face); + +public: + ~BOP_Mesh(); + + BOP_Index addVertex(MT_Point3 point); + BOP_Index addFace(BOP_Face *face); + BOP_Index addFace(BOP_Face3 *face); + BOP_Index addFace(BOP_Face4 *face); + BOP_Vertex* getVertex(BOP_Index v); + BOP_Face*getFace(BOP_Index v); + BOP_Edge* getEdge(BOP_Index v); + BOP_Edge* getEdge(BOP_Face * face, unsigned int edge); + BOP_Edge* getEdge(BOP_Face3 * face, unsigned int edge); + BOP_Edge* getEdge(BOP_Face4 * face, unsigned int edge); + BOP_Edge* getEdge(BOP_Index v1, BOP_Index v2); + bool getIndexEdge(BOP_Index v1, BOP_Index v2, BOP_Index &e); + BOP_Vertexs &getVertexs(); + BOP_Edges &getEdges(); + BOP_Faces &getFaces(); + BOP_Face* getFace(BOP_Index v1, BOP_Index v2, BOP_Index v3); + bool getIndexFace(BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index &f); + unsigned int getNumVertexs(); + unsigned int getNumEdges(); + unsigned int getNumFaces(); + unsigned int getNumVertexs(BOP_TAG tag); + unsigned int getNumFaces(BOP_TAG tag); + BOP_Index replaceVertexIndex(BOP_Index oldIndex, BOP_Index newIndex); + + // Debug functions + void print(); + void printFormat(); + void printFormat(BOP_Faces *faces); + void saveFormat(BOP_Faces *faces, char *filename); + void printFace(BOP_Face *face, int col = 0); + void testPlane(BOP_Face *face); + void testMesh(); + void updatePlanes(); +}; + +#endif diff --git a/intern/boolop/intern/BOP_Segment.cpp b/intern/boolop/intern/BOP_Segment.cpp new file mode 100644 index 00000000000..2a81660c4ff --- /dev/null +++ b/intern/boolop/intern/BOP_Segment.cpp @@ -0,0 +1,247 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Segment.h" + +#define UNDEFINED 0 + +/** + * Constructs a new segment. + */ +BOP_Segment::BOP_Segment(){ + m_cfg1 = UNDEFINED; + m_cfg2 = UNDEFINED; +} + +/** + * Returns the relative edge index between two relative vertex indices. + * @param v1 relative vertex index + * @param v2 relative vertex index + * @return relative edge index between two relative vertex indices, -1 otherwise + */ +int BOP_Segment::getEdgeBetween(unsigned int v1, unsigned int v2) +{ + if ((v1 == 1 && v2 == 2) || (v1 == 2 && v2 == 1)) return 1; + if ((v1 == 3 && v2 == 2) || (v1 == 2 && v2 == 3)) return 2; + if ((v1 == 1 && v2 == 3) || (v1 == 3 && v2 == 1)) return 3; + return -1; +} + +/** + * Returns if a relative vertex index is on a relative edge index. + * @param v relative vertex index + * @param e relative edge index + * @return true if the relative vertex index is on the relative edge index, + * false otherwise. + */ +bool BOP_Segment::isOnEdge(unsigned int v, unsigned int e) +{ + if (v == 1 && (e == 1 || e == 3)) return true; + if (v == 2 && (e == 1 || e == 2)) return true; + if (v == 3 && (e == 2 || e == 3)) return true; + return false; +} + +/** + * Inverts the segment, swapping ends data. + */ +void BOP_Segment::invert() +{ + BOP_Index aux = m_v1; + m_v1 = m_v2; + m_v2 = aux; + aux = m_cfg1; + m_cfg1 = m_cfg2; + m_cfg2 = aux; +} + +/** + * Sorts the segment according to ends configuration. + * The criterion to sort is ... + * + * UNDEFINED < VERTEX < EDGE < IN + * cfg1 > cfg2 + * + * so ... + * + * VERTEX(cfg1) => UNDEFINED(cfg2) || VERTEX(cfg2) + * EDGE(cfg1) => UNDEFINED(cfg2) || VERTEX(cfg2) || EDGE(cfg2) + * IN(cfg1) => UNDEFINED(cfg2) || VERTEX(cfg2) || EDGE(cfg2) || IN(cfg2) + */ +void BOP_Segment::sort() +{ + if (m_cfg1 < m_cfg2) invert(); +} + +/** + * Returns if the specified end segment configuration is IN. + * @return true if the specified end segment configuration is IN, false otherwise + */ +bool BOP_Segment::isIn(unsigned int cfg) +{ + return (cfg == 20); +} + +/** + * Returns if the specified end segment configuration is EDGE. + * @return true if the specified end segment configuration is EDGE, false otherwise + */ +bool BOP_Segment::isEdge(unsigned int cfg) +{ + return (cfg > 10) && (cfg < 20); +} + +/** + * Returns if the specified end segment configuration is VERTEX. + * @return true if the specified end segment configuration is VERTEX, false otherwise + */ +bool BOP_Segment::isVertex(unsigned int cfg) +{ + return (cfg!=UNDEFINED) && (cfg < 10); +} + +/** + * Returns if the specified end segment configuration is DEFINED (not UNDEFINED). + * @return true if the specified end segment configuration is DEFINED, false otherwise + */ +bool BOP_Segment::isDefined(unsigned int cfg) +{ + return (cfg != UNDEFINED); +} + +/** + * Returns if the specified end segment configuration is UNDEFINED. + * @return true if the specified end segment configuration is UNDEFINED, false otherwise + */ +bool BOP_Segment::isUndefined(unsigned int cfg) +{ + return (cfg == UNDEFINED); +} + +/** + * Returns the relative edge index from the specified end segment configuration. + * @return relative edge index from the specified end segment configuration + */ +unsigned int BOP_Segment::getEdge(unsigned int cfg) +{ + return cfg-10; +} + +/** + * Returns the relative vertex index from the specified end segment configuration. + * @return relative vertex index from the specified end segment configuration + */ +BOP_Index BOP_Segment::getVertex(unsigned int cfg) +{ + return cfg; +} + +/** + * Returns the end segment configuration for the specified relative edge index. + * @return end segment configuration for the specified relative edge index + */ +unsigned int BOP_Segment::createEdgeCfg(unsigned int edge) +{ + return 10+edge; +} + +/** + * Returns the end segment configuration for the specified relative vertex index. + * @return end segment configuration for the specified relative vertex index + */ +unsigned int BOP_Segment::createVertexCfg(BOP_Index vertex) +{ + return vertex; +} + +/** + * Returns the end segment IN configuration. + * @return end segment IN configuration + */ +unsigned int BOP_Segment::createInCfg() +{ + return 20; +} + +/** + * Returns the end segment UNDEFINED configuration. + * @return end segment UNDEFINED configuration + */ +unsigned int BOP_Segment::createUndefinedCfg() +{ + return UNDEFINED; +} + +/** + * Returns the inner segment configuration. + * @return inner segment configuration + */ +unsigned int BOP_Segment::getConfig() +{ + if (isUndefined(m_cfg1)) return m_cfg2; + else if (isUndefined(m_cfg2)) return m_cfg1; + else if (isVertex(m_cfg1)) { + // v1 is vertex + if (isVertex(m_cfg2)) { + // v2 is vertex + return createEdgeCfg(getEdgeBetween(getVertex(m_cfg1),getVertex(m_cfg2))); + } + else if (isEdge(m_cfg2)) { + // v2 is edge + if (isOnEdge(m_cfg1,getEdge(m_cfg2))) return m_cfg2; + else return createInCfg(); //IN + } + else return createInCfg(); //IN + } + else if (isEdge(m_cfg1)) { + // v1 is edge + if (isVertex(m_cfg2)) { + // v2 is vertex + if (isOnEdge(m_cfg2,getEdge(m_cfg1))) return m_cfg1; + else return createInCfg(); //IN + } + else if (isEdge(m_cfg2)) { + // v2 is edge + if (m_cfg1 == m_cfg2) return m_cfg1; + else return createInCfg(); // IN + } + else return createInCfg(); // IN + } + else return createInCfg(); // IN +} + +/** + * Implements operator << + */ +ostream &operator<<(ostream &stream, const BOP_Segment &c) +{ + cout << "m_v1: " << c.m_v1 << "(" << c.m_cfg1 << ") m_v2: " << c.m_v2 << "(" << c.m_cfg2 << ")"; + return stream; +} diff --git a/intern/boolop/intern/BOP_Segment.h b/intern/boolop/intern/BOP_Segment.h new file mode 100644 index 00000000000..caa6157346c --- /dev/null +++ b/intern/boolop/intern/BOP_Segment.h @@ -0,0 +1,73 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_SEGMENT_H +#define BOP_SEGMENT_H + +#include "BOP_Indexs.h" +#include +using namespace std; + +class BOP_Segment +{ +private: + int getEdgeBetween(unsigned int v1, unsigned int v2); + bool isOnEdge(unsigned int v, unsigned int e); + +public: + // Cfg : Configuration of the vertices + // Values: + // 20 IN, + // 1X Intersected edge X{1,2,3} of the face, + // 0X Coincident vertice X{1,2,3} of the face, + // 0 otherwise + unsigned int m_cfg1, m_cfg2; + BOP_Index m_v1, m_v2; // if cfgX >0, vX is the vertice index of the face + BOP_Segment(); + + static bool isIn(unsigned int cfg); + static bool isEdge(unsigned int cfg); + static bool isVertex(unsigned int cfg); + static bool isDefined(unsigned int cfg); + static bool isUndefined(unsigned int cfg); + static unsigned int getEdge(unsigned int cfg); + static BOP_Index getVertex(unsigned int cfg); + static unsigned int createEdgeCfg(unsigned int edge); + static unsigned int createVertexCfg(BOP_Index vertex); + static unsigned int createInCfg(); + static unsigned int createUndefinedCfg(); + void invert(); + void sort(); + unsigned int getConfig(); + + friend ostream &operator<<(ostream &stream, const BOP_Segment &c); +}; + +#endif diff --git a/intern/boolop/intern/BOP_Splitter.cpp b/intern/boolop/intern/BOP_Splitter.cpp new file mode 100644 index 00000000000..07f1f4d6c96 --- /dev/null +++ b/intern/boolop/intern/BOP_Splitter.cpp @@ -0,0 +1,193 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Splitter.h" +#include "BOP_Tag.h" + +#include +using namespace std; + +/** + * Returns the split point resulting from intersect a plane and a mesh face + * according to its specified relative edge. + * @param plane split plane + * @param m mesh + * @param f face + * @param e relative edge index + * @return intersection point + */ +MT_Point3 BOP_splitEdge(MT_Plane3 plane, BOP_Mesh *m, BOP_Face *f, unsigned int e) +{ + int v1 = -1, v2 = -1; + + switch(e) { + case 1: + v1 = f->getVertex(0); + v2 = f->getVertex(1); + break; + case 2: + v1 = f->getVertex(1); + v2 = f->getVertex(2); + break; + case 3: + v1 = f->getVertex(2); + v2 = f->getVertex(0); + break; + default: + // wrong relative edge index! + break; + } + + MT_Point3 p1 = m->getVertex(v1)->getPoint(); + MT_Point3 p2 = m->getVertex(v2)->getPoint(); + return BOP_intersectPlane(plane,p1,p2); +} + +/** + * Returns the segment resulting from intersect a plane and a mesh face. + * @param plane split plane + * @param m mesh + * @param f face + * @return segment if there is intersection, NULL otherwise + */ +BOP_Segment BOP_splitFace(MT_Plane3 plane, BOP_Mesh *m, BOP_Face *f) +{ + BOP_Vertex *v1 = m->getVertex(f->getVertex(0)); + BOP_Vertex *v2 = m->getVertex(f->getVertex(1)); + BOP_Vertex *v3 = m->getVertex(f->getVertex(2)); + + // Classify face vertices + BOP_TAG tag1 = BOP_createTAG(BOP_classify(v1->getPoint(),plane)); + BOP_TAG tag2 = BOP_createTAG(BOP_classify(v2->getPoint(),plane)); + BOP_TAG tag3 = BOP_createTAG(BOP_classify(v3->getPoint(),plane)); + + // Classify face according to its vertices classification + BOP_TAG tag = BOP_createTAG(tag1,tag2,tag3); + + BOP_Segment s; + + switch(tag) { + case IN_IN_IN : + case OUT_OUT_OUT : + case ON_ON_ON : + s.m_cfg1 = s.m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case ON_OUT_OUT : + case ON_IN_IN : + s.m_v1 = f->getVertex(0); + s.m_cfg1 = BOP_Segment::createVertexCfg(1); + s.m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case OUT_ON_OUT : + case IN_ON_IN : + s.m_v1 = f->getVertex(1); + s.m_cfg1 = BOP_Segment::createVertexCfg(2); + s.m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case OUT_OUT_ON : + case IN_IN_ON : + s.m_v1 = f->getVertex(2); + s.m_cfg1 = BOP_Segment::createVertexCfg(3); + s.m_cfg2 = BOP_Segment::createUndefinedCfg(); + break; + + case ON_ON_IN : + case ON_ON_OUT : + s.m_v1 = f->getVertex(0); + s.m_v2 = f->getVertex(1); + s.m_cfg1 = BOP_Segment::createVertexCfg(1); + s.m_cfg2 = BOP_Segment::createVertexCfg(2); + break; + + case ON_OUT_ON : + case ON_IN_ON : + s.m_v1 = f->getVertex(0); + s.m_v2 = f->getVertex(2); + s.m_cfg1 = BOP_Segment::createVertexCfg(1); + s.m_cfg2 = BOP_Segment::createVertexCfg(3); + break; + + case OUT_ON_ON : + case IN_ON_ON : + s.m_v1 = f->getVertex(1); + s.m_v2 = f->getVertex(2); + s.m_cfg1 = BOP_Segment::createVertexCfg(2); + s.m_cfg2 = BOP_Segment::createVertexCfg(3); + break; + + case IN_OUT_ON : + case OUT_IN_ON : + s.m_v2 = f->getVertex(2); + s.m_cfg1 = BOP_Segment::createEdgeCfg(1); + s.m_cfg2 = BOP_Segment::createVertexCfg(3); + break; + + case IN_ON_OUT : + case OUT_ON_IN : + s.m_v1 = f->getVertex(1); + s.m_cfg1 = BOP_Segment::createVertexCfg(2); + s.m_cfg2 = BOP_Segment::createEdgeCfg(3); + break; + + case ON_IN_OUT : + case ON_OUT_IN : + s.m_v1 = f->getVertex(0); + s.m_cfg1 = BOP_Segment::createVertexCfg(1); + s.m_cfg2 = BOP_Segment::createEdgeCfg(2); + break; + + case OUT_IN_IN : + case IN_OUT_OUT : + s.m_cfg1 = BOP_Segment::createEdgeCfg(1); + s.m_cfg2 = BOP_Segment::createEdgeCfg(3); + break; + + case OUT_IN_OUT : + case IN_OUT_IN : + s.m_cfg1 = BOP_Segment::createEdgeCfg(1); + s.m_cfg2 = BOP_Segment::createEdgeCfg(2); + break; + + case OUT_OUT_IN : + case IN_IN_OUT : + s.m_cfg1 = BOP_Segment::createEdgeCfg(2); + s.m_cfg2 = BOP_Segment::createEdgeCfg(3); + break; + + default: + // wrong TAG! + break; + } + + return s; +} diff --git a/intern/boolop/intern/BOP_Splitter.h b/intern/boolop/intern/BOP_Splitter.h new file mode 100644 index 00000000000..02cbdd2aa72 --- /dev/null +++ b/intern/boolop/intern/BOP_Splitter.h @@ -0,0 +1,44 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_SPLITTER_H +#define BOP_SPLITTER_H + +#include "BOP_MathUtils.h" +#include "BOP_Segment.h" +#include "BOP_Mesh.h" + +#include "MT_Plane3.h" +#include "MT_Point3.h" + +MT_Point3 BOP_splitEdge(MT_Plane3 plane, BOP_Mesh *mesh, BOP_Face *face, unsigned int edge); +BOP_Segment BOP_splitFace(MT_Plane3 plane, BOP_Mesh *mesh, BOP_Face *face); + +#endif diff --git a/intern/boolop/intern/BOP_Tag.cpp b/intern/boolop/intern/BOP_Tag.cpp new file mode 100644 index 00000000000..6a8832870fa --- /dev/null +++ b/intern/boolop/intern/BOP_Tag.cpp @@ -0,0 +1,142 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Tag.h" + +/** + * Gets the tag description. + * @param t tag + * @param dest tag description + */ +void BOP_stringTAG(BOP_TAG t, char *dest) { + + switch(t){ + case IN_IN_IN: + sprintf(dest, "IN_IN_IN"); + break; + case IN_IN_ON: + sprintf(dest, "IN_IN_ON"); + break; + case IN_ON_IN: + sprintf(dest, "IN_ON_IN"); + break; + case IN_ON_ON: + sprintf(dest, "IN_ON_ON"); + break; + case ON_IN_IN: + sprintf(dest, "ON_IN_IN"); + break; + case ON_IN_ON: + sprintf(dest, "ON_IN_ON"); + break; + case ON_ON_IN: + sprintf(dest, "ON_ON_IN"); + break; + case ON_ON_ON: + sprintf(dest, "ON_ON_ON"); + break; + case OUT_OUT_OUT: + sprintf(dest, "OUT_OUT_OUT"); + break; + case OUT_OUT_ON: + sprintf(dest, "OUT_OUT_ON"); + break; + case OUT_ON_OUT: + sprintf(dest, "OUT_ON_OUT"); + break; + case OUT_ON_ON: + sprintf(dest, "OUT_ON_ON"); + break; + case ON_OUT_OUT: + sprintf(dest, "ON_OUT_OUT"); + break; + case ON_OUT_ON: + sprintf(dest, "ON_OUT_ON"); + break; + case ON_ON_OUT: + sprintf(dest, "ON_ON_OUT"); + break; + case OUT_OUT_IN: + sprintf(dest, "OUT_OUT_IN"); + break; + case OUT_IN_OUT: + sprintf(dest, "OUT_IN_OUT"); + break; + case OUT_IN_IN: + sprintf(dest, "OUT_IN_IN"); + break; + case IN_OUT_OUT: + sprintf(dest, "IN_OUT_OUT"); + break; + case IN_OUT_IN: + sprintf(dest, "IN_OUT_IN"); + break; + case IN_IN_OUT: + sprintf(dest, "IN_IN_OUT"); + break; + case OUT_ON_IN: + sprintf(dest, "OUT_ON_IN"); + break; + case OUT_IN_ON: + sprintf(dest, "OUT_IN_ON"); + break; + case IN_ON_OUT: + sprintf(dest, "IN_ON_OUT"); + break; + case IN_OUT_ON: + sprintf(dest, "IN_OUT_ON"); + break; + case ON_IN_OUT: + sprintf(dest, "ON_IN_OUT"); + break; + case ON_OUT_IN: + sprintf(dest, "ON_OUT_IN"); + break; + case UNCLASSIFIED: + sprintf(dest, "UNCLASSIFIED"); + break; + case BROKEN: + sprintf(dest, "BROKEN"); + break; + case PHANTOM: + sprintf(dest, "PHANTOM"); + break; + case OVERLAPPED: + sprintf(dest, "OVERLAPPED"); + break; + case INOUT: + sprintf(dest, "INOUT"); + break; + default: + sprintf(dest, "DESCONEGUT %d",t); + break; + } + +} diff --git a/intern/boolop/intern/BOP_Tag.h b/intern/boolop/intern/BOP_Tag.h new file mode 100644 index 00000000000..2b6ff93b679 --- /dev/null +++ b/intern/boolop/intern/BOP_Tag.h @@ -0,0 +1,145 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include +#include + +#ifndef BOP_TAG_H +#define BOP_TAG_H + +#define IN_TAG 0x02 // Below the plane +#define ON_TAG 0x00 // On the plane +#define OUT_TAG 0x01 // Above the plane +#define INOUT_TAG 0x0E // Above and below the plane +#define INON_TAG 0x12 // Below and on the plane +#define OUTON_TAG 0x11 // Above and on the plane +#define UNCLASSIFIED_TAG 0x0F // Expecting to be classified + +#define PHANTOM_TAG 0x0C // Phantom face +#define OVERLAPPED_TAG 0x0D // Overlapped face +#define BROKEN_TAG 0x0B // Splitted and unused ... + +#define ON_ON_IN_TAG IN_TAG +#define ON_IN_ON_TAG IN_TAG << 2 +#define IN_ON_ON_TAG IN_TAG << 4 + +#define ON_ON_OUT_TAG OUT_TAG +#define ON_OUT_ON_TAG OUT_TAG << 2 +#define OUT_ON_ON_TAG OUT_TAG << 4 + +#define ON_ON_ON_TAG ON_TAG +#define IN_IN_IN_TAG IN_ON_ON_TAG | ON_IN_ON_TAG | ON_ON_IN_TAG +#define OUT_OUT_OUT_TAG OUT_ON_ON_TAG | ON_OUT_ON_TAG | ON_ON_OUT_TAG + +#define IN_IN_ON_TAG IN_ON_ON_TAG | ON_IN_ON_TAG +#define IN_ON_IN_TAG IN_ON_ON_TAG | ON_ON_IN_TAG +#define ON_IN_IN_TAG ON_IN_ON_TAG | ON_ON_IN_TAG + +#define OUT_OUT_ON_TAG OUT_ON_ON_TAG | ON_OUT_ON_TAG +#define OUT_ON_OUT_TAG OUT_ON_ON_TAG | ON_ON_OUT_TAG +#define ON_OUT_OUT_TAG ON_OUT_ON_TAG | ON_ON_OUT_TAG + +#define IN_OUT_OUT_TAG IN_ON_ON_TAG | ON_OUT_OUT_TAG +#define OUT_IN_OUT_TAG ON_IN_ON_TAG | OUT_ON_OUT_TAG +#define OUT_OUT_IN_TAG ON_ON_IN_TAG | OUT_OUT_ON_TAG + +#define OUT_IN_IN_TAG ON_IN_IN_TAG | OUT_ON_ON_TAG +#define IN_OUT_IN_TAG IN_ON_IN_TAG | ON_OUT_ON_TAG +#define IN_IN_OUT_TAG IN_IN_ON_TAG | ON_ON_OUT_TAG + +#define IN_ON_OUT_TAG IN_ON_ON_TAG | ON_ON_OUT_TAG +#define IN_OUT_ON_TAG IN_ON_ON_TAG | ON_OUT_ON_TAG +#define ON_IN_OUT_TAG ON_IN_ON_TAG | ON_ON_OUT_TAG +#define ON_OUT_IN_TAG ON_ON_IN_TAG | ON_OUT_ON_TAG +#define OUT_IN_ON_TAG ON_IN_ON_TAG | OUT_ON_ON_TAG +#define OUT_ON_IN_TAG ON_ON_IN_TAG | OUT_ON_ON_TAG + +typedef enum BOP_TAGEnum { + IN = IN_TAG, + ON = ON_TAG, + OUT = OUT_TAG, + INOUT = INOUT_TAG, + INON = INON_TAG, + OUTON = OUTON_TAG, + UNCLASSIFIED = UNCLASSIFIED_TAG, + PHANTOM = PHANTOM_TAG, + OVERLAPPED = OVERLAPPED_TAG, + BROKEN = BROKEN_TAG, + IN_ON_ON = IN_ON_ON_TAG, + ON_IN_ON = ON_IN_ON_TAG, + ON_ON_IN = ON_ON_IN_TAG, + OUT_ON_ON = OUT_ON_ON_TAG, + ON_OUT_ON = ON_OUT_ON_TAG, + ON_ON_OUT = ON_ON_OUT_TAG, + ON_ON_ON = ON_ON_ON_TAG, + IN_IN_IN = IN_IN_IN_TAG, + OUT_OUT_OUT = OUT_OUT_OUT_TAG, + IN_IN_ON = IN_IN_ON_TAG, + IN_ON_IN = IN_ON_IN_TAG, + ON_IN_IN = ON_IN_IN_TAG, + OUT_OUT_ON = OUT_OUT_ON_TAG, + OUT_ON_OUT = OUT_ON_OUT_TAG, + ON_OUT_OUT = ON_OUT_OUT_TAG, + IN_OUT_OUT = IN_OUT_OUT_TAG, + OUT_IN_OUT = OUT_IN_OUT_TAG, + OUT_OUT_IN = OUT_OUT_IN_TAG, + OUT_IN_IN = OUT_IN_IN_TAG, + IN_OUT_IN = IN_OUT_IN_TAG, + IN_IN_OUT = IN_IN_OUT_TAG, + IN_ON_OUT = IN_ON_OUT_TAG, + IN_OUT_ON = IN_OUT_ON_TAG, + ON_IN_OUT = ON_IN_OUT_TAG, + ON_OUT_IN = ON_OUT_IN_TAG, + OUT_IN_ON = OUT_IN_ON_TAG, + OUT_ON_IN = OUT_ON_IN_TAG } BOP_TAG; + +inline BOP_TAG BOP_createTAG(BOP_TAG tag1, BOP_TAG tag2, BOP_TAG tag3) +{ + return (BOP_TAG) (tag1 << 4 | tag2 << 2 | tag3); +} + +inline BOP_TAG BOP_createTAG(int i) +{ + return i < 0 ? IN : i > 0 ? OUT : ON; +} + +inline BOP_TAG BOP_addON(BOP_TAG tag) +{ + return (tag==IN?INON:(tag==OUT?OUTON:tag)); +} + +void BOP_stringTAG(BOP_TAG tag, char *dest); + +inline bool BOP_compTAG(BOP_TAG tag1, BOP_TAG tag2) +{ + return (tag1==tag2) || (BOP_addON(tag1) == BOP_addON(tag2)); +} + +#endif diff --git a/intern/boolop/intern/BOP_Triangulator.cpp b/intern/boolop/intern/BOP_Triangulator.cpp new file mode 100644 index 00000000000..fa604d44f2d --- /dev/null +++ b/intern/boolop/intern/BOP_Triangulator.cpp @@ -0,0 +1,515 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Triangulator.h" +#include +using namespace std; + +void BOP_addFace(BOP_Mesh* mesh, BOP_Faces *faces, BOP_Face* face, BOP_TAG tag); +void BOP_splitQuad(BOP_Mesh* mesh, MT_Plane3 plane, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, + BOP_Face* triangles[], BOP_Index original); +BOP_Index BOP_getTriangleVertex(BOP_Mesh* mesh, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4); +BOP_Index BOP_getNearestVertex(BOP_Mesh* mesh, BOP_Index u, BOP_Index v1, BOP_Index v2); +bool BOP_isInsideCircle(BOP_Mesh* mesh, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, BOP_Index v5); +bool BOP_isInsideCircle(BOP_Mesh* mesh, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index w); +void BOP_triangulateC_split(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, + BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, BOP_Index v5); +void BOP_triangulateD_split(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, + BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, BOP_Index v5); + +/** + * Triangulates the face in two new faces by splitting one edge. + * + * * + * /|\ + * / | \ + * / | \ + * / | \ + * / | \ + * *-----x-----* + * + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v vertex index that intersects the edge + * @param e relative edge index used to triangulate the face + */ + + +void BOP_triangulateA(BOP_Mesh *mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v, unsigned int e) +{ + BOP_Face *face1, *face2; + if (e == 1) { + face1 = new BOP_Face3(face->getVertex(0), v, face->getVertex(2), face->getPlane(), + face->getOriginalFace()); + face2 = new BOP_Face3(v, face->getVertex(1), face->getVertex(2), face->getPlane(), + face->getOriginalFace()); + } + else if (e == 2) { + face1 = new BOP_Face3(face->getVertex(0), face->getVertex(1), v, face->getPlane(), + face->getOriginalFace()); + face2 = new BOP_Face3(face->getVertex(0), v, face->getVertex(2), face->getPlane(), + face->getOriginalFace()); + } + else if (e == 3) { + face1 = new BOP_Face3(face->getVertex(0), face->getVertex(1), v, face->getPlane(), + face->getOriginalFace()); + face2 = new BOP_Face3(face->getVertex(1), face->getVertex(2), v, face->getPlane(), + face->getOriginalFace()); + } + else { + return; + } + + BOP_addFace(mesh, faces, face1, face->getTAG()); + BOP_addFace(mesh, faces, face2, face->getTAG()); + + face->setTAG(BROKEN); +} + +/** + * Triangulates the face in three new faces by one inner point. + * + * * + * / \ + * / \ + * / \ + * / x \ + * / \ + * *-----------* + * + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v vertex index that lays inside face + */ +void BOP_triangulateB(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, BOP_Index v) +{ + BOP_Face *face1 = new BOP_Face3(face->getVertex(0), face->getVertex(1), v, face->getPlane(), + face->getOriginalFace()); + BOP_Face *face2 = new BOP_Face3(face->getVertex(1), face->getVertex(2), v, face->getPlane(), + face->getOriginalFace()); + BOP_Face *face3 = new BOP_Face3(face->getVertex(2), face->getVertex(0), v, face->getPlane(), + face->getOriginalFace()); + + BOP_addFace(mesh,faces,face1,face->getTAG()); + BOP_addFace(mesh,faces,face2,face->getTAG()); + BOP_addFace(mesh,faces,face3,face->getTAG()); + face->setTAG(BROKEN); +} + + +/** + * Triangulates the face in five new faces by two inner points. + * + * * + * / \ + * / \ + * / \ + * / x x \ + * / \ + * *-----------* + * + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v1 first vertex index that lays inside face + * @param v2 second vertex index that lays inside face + */ +void BOP_triangulateC(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, BOP_Index v1, BOP_Index v2) +{ + if (!BOP_isInsideCircle(mesh, face->getVertex(0), v1, v2, face->getVertex(1), face->getVertex(2))) { + BOP_triangulateC_split(mesh, faces, face, face->getVertex(0), face->getVertex(1), + face->getVertex(2), v1, v2); + } + else if (!BOP_isInsideCircle(mesh, face->getVertex(1), v1, v2, face->getVertex(0), face->getVertex(2))) { + BOP_triangulateC_split(mesh, faces, face, face->getVertex(1), face->getVertex(2), + face->getVertex(0), v1, v2); + } + else if (!BOP_isInsideCircle(mesh, face->getVertex(2), v1, v2, face->getVertex(0), face->getVertex(1))) { + BOP_triangulateC_split(mesh, faces, face, face->getVertex(2), face->getVertex(0), + face->getVertex(1), v1, v2); + } + else { + BOP_triangulateC_split(mesh, faces, face, face->getVertex(2), face->getVertex(0), + face->getVertex(1), v1, v2); + } +} + +/** + * Triangulates the face (v1,v2,v3) in five new faces by two inner points (v4,v5), where + * v1 v4 v5 defines the nice triangle and v4 v5 v2 v3 defines the quad to be tesselated. + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v1 first vertex index that defines the original triangle + * @param v2 second vertex index that defines the original triangle + * @param v3 third vertex index that defines the original triangle + * @param v4 first vertex index that lays inside face + * @param v5 second vertex index that lays inside face + */ +void BOP_triangulateC_split(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, + BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, BOP_Index v5) +{ + BOP_Index v = BOP_getTriangleVertex(mesh, v1, v2, v4, v5); + BOP_Index w = (v == v4 ? v5 : v4); + + // v1 v w defines the nice triangle in the correct order + // v1 v2 v defines one lateral triangle in the correct order + // v1 w v3 defines the other lateral triangle in the correct order + // w v v2 v3 defines the quad in the correct order + + BOP_addFace(mesh, faces, new BOP_Face3(v1, v, w, face->getPlane(), + face->getOriginalFace()), face->getTAG()); + BOP_addFace(mesh, faces, new BOP_Face3(v1, v2, v, face->getPlane(), + face->getOriginalFace()), face->getTAG()); + BOP_addFace(mesh, faces, new BOP_Face3(v1, w, v3, face->getPlane(), + face->getOriginalFace()), face->getTAG()); + + BOP_Face *faces45[2]; + + BOP_splitQuad(mesh, face->getPlane(), v2, v3, w, v, faces45, face->getOriginalFace()); + BOP_addFace(mesh, faces, faces45[0], face->getTAG()); + BOP_addFace(mesh, faces, faces45[1], face->getTAG()); + + face->setTAG(BROKEN); +} + + +/** + * Triangulates the face in three new faces by splitting twice an edge. + * + * * + * / \ + * / \ + * / \ + * / \ + * / \ + * *---x---x---* + * + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v1 first vertex index that intersects the edge + * @param v2 second vertex index that intersects the edge + * @param e relative edge index used to triangulate the face + */ +void BOP_triangulateD(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, BOP_Index v1, + BOP_Index v2, unsigned int e) +{ + if (e == 1) { + BOP_triangulateD_split(mesh, faces, face, face->getVertex(0), face->getVertex(1), + face->getVertex(2), v1, v2); + } + else if (e == 2) { + BOP_triangulateD_split(mesh, faces, face, face->getVertex(1), face->getVertex(2), + face->getVertex(0), v1, v2); + } + else if (e == 3) { + BOP_triangulateD_split(mesh, faces, face, face->getVertex(2), face->getVertex(0), + face->getVertex(1), v1, v2); + } +} + +/** + * Triangulates the face (v1,v2,v3) in three new faces by splitting twice an edge. + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v1 first vertex index that defines the original triangle + * @param v2 second vertex index that defines the original triangle + * @param v3 third vertex index that defines the original triangle + * @param v4 first vertex index that lays on the edge + * @param v5 second vertex index that lays on the edge + */ +void BOP_triangulateD_split(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, + BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, BOP_Index v5) +{ + BOP_Index v = BOP_getNearestVertex(mesh, v1, v4, v5); + BOP_Index w = (v == v4 ? v5 : v4); + + BOP_addFace(mesh, faces, new BOP_Face3(v1, v, v3, face->getPlane(), + face->getOriginalFace()), face->getTAG()); + BOP_addFace(mesh, faces, new BOP_Face3(v, w, v3, face->getPlane(), + face->getOriginalFace()), face->getTAG()); + BOP_addFace(mesh, faces, new BOP_Face3(w, v2, v3, face->getPlane(), + face->getOriginalFace()), face->getTAG()); + + face->setTAG(BROKEN); +} + + +/** + * Triangulates the face in three new faces by splitting two edges. + * + * * + * / \ + * / \ + * x x + * / \ + * / \ + * *-----------* + * + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v1 vertex index that intersects the first edge + * @param v1 vertex index that intersects the second edge + * @param e1 first relative edge index used to triangulate the face + * @param e2 second relative edge index used to triangulate the face + */ +void BOP_triangulateE(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, + BOP_Index v1, BOP_Index v2, unsigned int e1, unsigned int e2) +{ + // Sort the edges to reduce the cases + if (e1 > e2) { + unsigned int aux = e1; + e1 = e2; + e2 = aux; + aux = v1; + v1 = v2; + v2 = aux; + } + // e1 < e2! + BOP_Face *face1; + BOP_Face *faces23[2]; + if (e1 == 1 && e2 == 2) { + // the vertex is 2 + face1 = new BOP_Face3(face->getVertex(1), v2, v1, face->getPlane(), + face->getOriginalFace()); + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(2), face->getVertex(0), v1, v2, + faces23, face->getOriginalFace()); + } + else if (e1 == 1 && e2 == 3) { + // the vertex is 1 + face1 = new BOP_Face3(face->getVertex(0), v1, v2, face->getPlane(), + face->getOriginalFace()); + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(1), face->getVertex(2), v2, v1, + faces23, face->getOriginalFace()); + } + else if (e1 == 2 && e2 == 3) { + // the vertex is 3 + face1 = new BOP_Face3(face->getVertex(2), v2, v1, face->getPlane(), + face->getOriginalFace()); + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(0), face->getVertex(1), v1, v2, + faces23, face->getOriginalFace()); + } + else { + return; + } + + BOP_addFace(mesh, faces, face1, face->getTAG()); + BOP_addFace(mesh, faces, faces23[0], face->getTAG()); + BOP_addFace(mesh, faces, faces23[1], face->getTAG()); + face->setTAG(BROKEN); +} + +/** + * Triangulates the face in four new faces by one edge and one inner point. + * + * * + * / \ + * / \ + * x x \ + * / \ + * / \ + * *-----------* + * + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains face and will contains new faces + * @param face input face to be triangulate + * @param v1 vertex index that lays inside face + * @param v2 vertex index that intersects the edge + * @param e relative edge index used to triangulate the face + */ +void BOP_triangulateF(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, + BOP_Index v1, BOP_Index v2, unsigned int e) +{ + BOP_Face *faces12[2]; + BOP_Face *faces34[2]; + if (e == 1) { + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(2), face->getVertex(0), v2, v1, + faces12, face->getOriginalFace()); + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(1), face->getVertex(2), v1, v2, + faces34, face->getOriginalFace()); + } + else if (e == 2) { + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(0), face->getVertex(1), v2, v1, + faces12, face->getOriginalFace()); + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(2), face->getVertex(0), v1, v2, + faces34, face->getOriginalFace()); + } + else if (e==3) { + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(1), face->getVertex(2), v2, v1, + faces12, face->getOriginalFace()); + BOP_splitQuad(mesh, face->getPlane(), face->getVertex(0), face->getVertex(1), v1, v2, + faces34, face->getOriginalFace()); + } + else { + return; + } + + BOP_addFace(mesh, faces, faces12[0], face->getTAG()); + BOP_addFace(mesh, faces, faces12[1], face->getTAG()); + BOP_addFace(mesh, faces, faces34[0], face->getTAG()); + BOP_addFace(mesh, faces, faces34[1], face->getTAG()); + + face->setTAG(BROKEN); +} + +/** + * Adds the new face into the faces set and the mesh and sets it a new tag. + * @param mesh mesh that contains the faces, edges and vertices + * @param faces set of faces that contains oldFace + * @param face input face to be added + * @param tag tag of the new face + */ +void BOP_addFace(BOP_Mesh* mesh, BOP_Faces* faces, BOP_Face* face, BOP_TAG tag) +{ + face->setTAG(tag); + faces->push_back(face); + mesh->addFace(face); +} + +/** + * Computes the best quad triangulation. + * @param mesh mesh that contains the faces, edges and vertices + * @param plane plane used to create the news faces + * @param v1 first vertex index + * @param v2 second vertex index + * @param v3 third vertex index + * @param v4 fourth vertex index + * @param triangles array of faces where the new two faces will be saved + * @param original face index to the new faces + */ +void BOP_splitQuad(BOP_Mesh* mesh, MT_Plane3 plane, BOP_Index v1, BOP_Index v2, + BOP_Index v3, BOP_Index v4, BOP_Face* triangles[], BOP_Index original) +{ + MT_Point3 p1 = mesh->getVertex(v1)->getPoint(); + MT_Point3 p2 = mesh->getVertex(v2)->getPoint(); + MT_Point3 p3 = mesh->getVertex(v3)->getPoint(); + MT_Point3 p4 = mesh->getVertex(v4)->getPoint(); + + int res = BOP_concave(p1,p2,p3,p4); + + if (res==0) { + MT_Plane3 plane1(p1, p2, p3); + MT_Plane3 plane2(p1, p3, p4); + + if (BOP_isInsideCircle(mesh, v1, v2, v4, v3) && + BOP_orientation(plane1, plane) && + BOP_orientation(plane2, plane)) { + triangles[0] = new BOP_Face3(v1, v2, v3, plane, original); + triangles[1] = new BOP_Face3(v1, v3, v4, plane, original); + } + else { + triangles[0] = new BOP_Face3(v1, v2, v4, plane, original); + triangles[1] = new BOP_Face3(v2, v3, v4, plane, original); + } + } + else if (res==-1) { + triangles[0] = new BOP_Face3(v1, v2, v4, plane, original); + triangles[1] = new BOP_Face3(v2, v3, v4, plane, original); + } + else { + triangles[0] = new BOP_Face3(v1, v2, v3, plane, original); + triangles[1] = new BOP_Face3(v1, v3, v4, plane, original); + } +} + +/** + * Returns the vertex (v3 or v4) that splits the quad (v1,v2,v3,v4) in the best pair of triangles. + * @param mesh mesh that contains the faces, edges and vertices + * @param v1 first vertex index + * @param v2 second vertex index + * @param v3 third vertex index + * @param v4 fourth vertex index + * @return v3 if the best split triangles are (v1,v2,v3) and (v1,v3,v4), v4 otherwise + */ +BOP_Index BOP_getTriangleVertex(BOP_Mesh* mesh, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4) +{ + if (BOP_isInsideCircle(mesh, v1, v2, v4, v3)) { + return v3; + } + return v4; +} + +/** + * Returns which of vertex v1 or v2 is nearest to u. + * @param mesh mesh that contains the faces, edges and vertices + * @param u reference vertex index + * @param v1 first vertex index + * @param v2 second vertex index + * @return the nearest vertex index + */ +BOP_Index BOP_getNearestVertex(BOP_Mesh* mesh, BOP_Index u, BOP_Index v1, BOP_Index v2) +{ + MT_Point3 q = mesh->getVertex(u)->getPoint(); + MT_Point3 p1 = mesh->getVertex(v1)->getPoint(); + MT_Point3 p2 = mesh->getVertex(v2)->getPoint(); + if (BOP_comp(q.distance(p1), q.distance(p2)) > 0) return v2; + else return v1; +} + +/** + * Computes if vertexs v4 and v5 are not inside the circle defined by v1,v2,v3 (seems to be a nice triangle) + * @param mesh mesh that contains the faces, edges and vertices + * @param v1 first vertex index + * @param v2 second vertex index + * @param v3 third vertex index + * @param v4 fourth vertex index + * @param v5 five vertex index + * @return if v1,v2,v3 defines a nice triangle against v4,v5 + */ +bool BOP_isInsideCircle(BOP_Mesh* mesh, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index v4, BOP_Index v5) +{ + return BOP_isInsideCircle(mesh->getVertex(v1)->getPoint(), + mesh->getVertex(v2)->getPoint(), + mesh->getVertex(v3)->getPoint(), + mesh->getVertex(v4)->getPoint(), + mesh->getVertex(v5)->getPoint()); +} + +/** + * Computes if vertex w is not inside the circle defined by v1,v2,v3 (seems to be a nice triangle) + * @param mesh mesh that contains the faces, edges and vertices + * @param v1 first vertex index + * @param v2 second vertex index + * @param v3 third vertex index + * @param w fourth vertex index + * @return if v1,v2,v3 defines a nice triangle against w + */ +bool BOP_isInsideCircle(BOP_Mesh* mesh, BOP_Index v1, BOP_Index v2, BOP_Index v3, BOP_Index w) +{ + return BOP_isInsideCircle(mesh->getVertex(v1)->getPoint(), + mesh->getVertex(v2)->getPoint(), + mesh->getVertex(v3)->getPoint(), + mesh->getVertex(w)->getPoint()); +} diff --git a/intern/boolop/intern/BOP_Triangulator.h b/intern/boolop/intern/BOP_Triangulator.h new file mode 100644 index 00000000000..12223e1ea1f --- /dev/null +++ b/intern/boolop/intern/BOP_Triangulator.h @@ -0,0 +1,44 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_TRIANGULATOR_H +#define BOP_TRIANGULATOR_H + +#include "BOP_MathUtils.h" +#include "BOP_Mesh.h" + +void BOP_triangulateA(BOP_Mesh *mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v, unsigned int e); +void BOP_triangulateB(BOP_Mesh * mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v); +void BOP_triangulateC(BOP_Mesh * mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v1, BOP_Index v2); +void BOP_triangulateD(BOP_Mesh * mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v1, BOP_Index v2, unsigned int e); +void BOP_triangulateE(BOP_Mesh *mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v1, BOP_Index v2, unsigned int e1, unsigned int e2); +void BOP_triangulateF(BOP_Mesh *mesh, BOP_Faces *faces, BOP_Face * face, BOP_Index v1, BOP_Index v2, unsigned int e); + +#endif diff --git a/intern/boolop/intern/BOP_Vertex.cpp b/intern/boolop/intern/BOP_Vertex.cpp new file mode 100644 index 00000000000..c039df5775d --- /dev/null +++ b/intern/boolop/intern/BOP_Vertex.cpp @@ -0,0 +1,94 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "BOP_Vertex.h" + +/** + * Constructs a new vertex with the specified coordinates. + * @param x X-axis coordinate + * @param y Y-axis coordinate + * @param z Z-axis coordinate + */ +BOP_Vertex::BOP_Vertex(double x, double y, double z) +{ + m_point.setValue(x,y,z); + m_tag = UNCLASSIFIED; +} + +/** + * Constructs a new vertex with the specified point. + * @param p point XYZ + */ +BOP_Vertex::BOP_Vertex(MT_Point3 p) +{ + m_point = p; + m_tag = UNCLASSIFIED; +} + +/** + * Adds a new edge index to this vertex. + * @param i edge index + */ +void BOP_Vertex::addEdge(BOP_Index i) +{ + if (!containsEdge(i)) + m_edges.push_back(i); +} + +/** + * Removes an edge index from this vertex. + * @param i edge index + */ +void BOP_Vertex::removeEdge(BOP_Index i) +{ + for(BOP_IT_Indexs it = m_edges.begin();it!=m_edges.end();it++) { + if ((*it)==i) { + m_edges.erase(it); + return; + } + } +} + +/** + * Returns if this vertex contains the specified edge index. + * @param i edge index + * @return true if this vertex contains the specified edge index, false otherwise + */ +bool BOP_Vertex::containsEdge(BOP_Index i) +{ + int pos=0; + for(BOP_IT_Indexs it = m_edges.begin();it!=m_edges.end();pos++,it++) { + if ((*it)==i){ + return true; + } + } + + return false; +} diff --git a/intern/boolop/intern/BOP_Vertex.h b/intern/boolop/intern/BOP_Vertex.h new file mode 100644 index 00000000000..a781407af34 --- /dev/null +++ b/intern/boolop/intern/BOP_Vertex.h @@ -0,0 +1,60 @@ +/** + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program 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 Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BOP_VERTEX_H +#define BOP_VERTEX_H + +#include "BOP_Tag.h" +#include "BOP_Indexs.h" +#include "MT_Point3.h" + +class BOP_Vertex +{ +private: + MT_Point3 m_point; + BOP_Indexs m_edges; + BOP_TAG m_tag; + + bool containsEdge(BOP_Index i); + +public: + BOP_Vertex(double x, double y, double z); + BOP_Vertex(MT_Point3 d); + void addEdge(BOP_Index i); + void removeEdge(BOP_Index i); + inline BOP_Index getEdge(unsigned int i) { return m_edges[i];}; + inline unsigned int getNumEdges() { return m_edges.size();}; + inline BOP_Indexs &getEdges() { return m_edges;}; + inline MT_Point3 getPoint() const { return m_point;}; + inline BOP_TAG getTAG() { return m_tag;}; + inline void setTAG(BOP_TAG t) { m_tag = t;}; +}; + +#endif diff --git a/intern/boolop/intern/Makefile b/intern/boolop/intern/Makefile new file mode 100644 index 00000000000..e098665eabf --- /dev/null +++ b/intern/boolop/intern/Makefile @@ -0,0 +1,48 @@ +# +# $Id$ +# +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program 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 Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# string intern Makefile +# + +LIBNAME = boolop +DIR = $(OCGDIR)/intern/$(LIBNAME) +DIRS = common + +include nan_compile.mk + +CCFLAGS += $(LEVEL_2_CPP_WARNINGS) + +CPPFLAGS += -I../extern +CPPFLAGS += -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_MEMUTIL)/include +CPPFLAGS += -I$(NAN_CONTAINER)/include +CPPFLAGS += -Icommon + + -- cgit v1.2.3