DGtal 1.3.0
Loading...
Searching...
No Matches
Functions
testMeshVoxelization.cpp File Reference
DGtal Test Files
#include <iostream>
#include "ConfigTest.h"
#include "DGtalCatch.h"
#include "DGtal/shapes/MeshVoxelizer.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/io/readers/MeshReader.h"
#include "DGtal/io/Display3D.h"
#include "DGtal/io/boards/Board3D.h"

Go to the source code of this file.

Functions

 TEST_CASE ("Basic voxelization test", "[voxelization]")
 

Detailed Description

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

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, see http://www.gnu.org/licenses/.

Date
2016/01/25

Functions for testing class MeshVoxelizer

This file is part of the DGtal library.

Definition in file testMeshVoxelization.cpp.

Function Documentation

◆ TEST_CASE()

TEST_CASE ( "Basic voxelization test"  ,
""  [voxelization] 
)

Definition at line 44 of file testMeshVoxelization.cpp.

45{
46 using Space3Dint = SpaceND<3>;
47 using Domain = HyperRectDomain<Space3Dint>;
48 using PointR3 = PointVector<3, double>;
49 using VectorR3 = PointVector<3, double>;
50 using PointR2 = PointVector<2, double>;
51 using PointZ3 = PointVector<3, int>;
52 using DigitalSet = DigitalSetBySTLSet<Domain>;
53
54 using MeshVoxelizer26 = MeshVoxelizer< DigitalSet, 26>;
55 using MeshVoxelizer6 = MeshVoxelizer< DigitalSet, 6>;
56
57 using TriOr = MeshVoxelizer6::TriangleOrientation;
58
59 // ---------------------------------------------------------
60 SECTION("Test distance point/plan 3D")
61 {
62 // Triangle ABC in R3
63 const PointR3 A(38.6908 , 14.5441 , -0.71205);
64 const PointR3 B(34.6171 , 13.5999 , 2.44455);
65 const PointR3 C(37.4205 , 2.44239 , 6.31301);
66
67 // Point v
68 const PointZ3 v(35, 2, 5);
69
70 const VectorR3 e1 = A - B;
71 const VectorR3 e2 = A - C;
72
73 double distance = MeshVoxelizer6::distance(A, e1.crossProduct(e2), v);
74
75 REQUIRE( 2.40 < distance );
76 REQUIRE( distance < 2.41 );
77 }
78
79 // ---------------------------------------------------------
80 SECTION("Test if 2D point is inside triangle 2D")
81 {
82 // Triangle ABC in R2
83 PointR2 A(1.0, 1.0);
84 PointR2 B(2.0, 3.0);
85 PointR2 C(3.0, 1.0);
86
87 typedef InHalfPlaneBySimple3x3Matrix<PointR2, double> OrientationFunctor;
88 OrientationFunctor orientationFunctor;
89
90 //geometric predicate
91 PredicateFromOrientationFunctor2<OrientationFunctor> pointPredicate( orientationFunctor );
92
93 if(! pointPredicate(A, B, C))
94 {
95 std::swap(A, C);
96 }
97
98 // Test if point v is inside triangle ABC
99 // 0 : outside
100 // 1 : inside
101 // 2 : on edge
102 // 3 : on vertex
103 PointR2 v;
104
105 v[0] = 3.0;
106 v[1] = 3.0;
107 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::OUTSIDE);
108
109 v[0] = 2.0;
110 v[1] = 2.0;
111 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::INSIDE);
112
113 v[0] = 2;
114 v[1] = 1;
115 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::ONEDGE);
116
117 v[0] = 3;
118 v[1] = 1;
119 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::ONVERTEX);
120
121 // another case
122 A = { 16.3299, 0. };
123 B = { 0., 16.3299 };
124 C = { -16.3299, 0. };
125 v = { -17., 0.};
126 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::OUTSIDE);
127
128 // another case
129 A = { -0.891282, 9.91201 };
130 B = { -1.40823, 9.91261 };
131 C = { -1.36963, 9.37414 };
132 v = { -1.16961, 9.83039 };
133 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::INSIDE);
134 }
135
136 // ---------------------------------------------------------
137 SECTION("Test if 3D point is inside voxel")
138 {
139 // Triangle ABC in R2
140 PointR3 P(-0.89, 9.91, 0.86);
141 PointZ3 v(-1, 10, 1);
142
143 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == true); // inside
144
145 P[0] = -1.41;
146 P[1] = 9.91;
147 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == true); // inside
148
149 P[0] = -1.37;
150 P[1] = 9.37;
151 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == false); // outside
152
153 P[0] = -1.17;
154 P[1] = 9.83;
155 P[2] = 0;
156 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == false); // outside
157 }
158
159 // ---------------------------------------------------------
160 SECTION("26-sep voxelization of a single triangle")
161 {
162 Domain domain(Point(0,0,0), Point(10,10,10));
163 DigitalSet outputSet(domain);
164 MeshVoxelizer26 voxelizer;
165
166 voxelizer.voxelize(outputSet, Point(5,0,0), Point(0,5,0), Point(0,0,5));
167 Board3D<Z3i::Space, Z3i::KSpace> board;
168 for(auto p: outputSet)
169 board << p ;
170 board.saveOBJ("triangle26-dig.obj");
171
172 REQUIRE( outputSet.size() == 46 );
173 }
174
175 // ---------------------------------------------------------
176 SECTION("6-sep voxelization of a single triangle")
177 {
178 Domain domain(Point(0,0,0), Point(10,10,10));
179 DigitalSet outputSet(domain);
180 MeshVoxelizer6 voxelizer;
181
182 voxelizer.voxelize(outputSet, Point(5,0,0), Point(0,5,0), Point(0,0,5));
183 Board3D<Z3i::Space, Z3i::KSpace> board;
184 for(auto p: outputSet)
185 board << p ;
186 board.saveOBJ("triangle6-dig.obj");
187
188 REQUIRE( outputSet.size() == 21 );
189 }
190
191 // ---------------------------------------------------------
192 SECTION("6-sep voxelization of a OFF cube mesh")
193 {
194 //Importing OFF mesh
195 Mesh<Z3i::RealPoint> inputMesh;
196 MeshReader<Z3i::RealPoint>::importOFFFile(testPath +"/samples/box.off" , inputMesh);
197 Z3i::Domain domain( Point().diagonal(-30), Point().diagonal(30));
198 DigitalSet outputSet(domain);
199 MeshVoxelizer6 voxelizer;
200
201 CAPTURE(inputMesh.nbFaces());
202
203 voxelizer.voxelize(outputSet, inputMesh, 10.0 );
204 Board3D<Z3i::Space, Z3i::KSpace> board;
205 for(auto p: outputSet)
206 board << p ;
207 board.saveOBJ("box6-dig.obj");
208
209 CAPTURE(outputSet.size());
210 //hard coded test.
211 REQUIRE( outputSet.size() == 2562 );
212 }
213 // ---------------------------------------------------------
214 SECTION("26-sep voxelization of a OFF cube mesh")
215 {
216 //Importing OFF mesh
217 Mesh<Z3i::RealPoint> inputMesh;
218 MeshReader<Z3i::RealPoint>::importOFFFile(testPath +"/samples/box.off" , inputMesh);
219 Z3i::Domain domain( Point().diagonal(-30), Point().diagonal(30));
220 DigitalSet outputSet(domain);
221 MeshVoxelizer26 voxelizer;
222
223 CAPTURE(inputMesh.nbFaces());
224
225 voxelizer.voxelize(outputSet, inputMesh, 10.0 );
226 Board3D<Z3i::Space, Z3i::KSpace> board;
227 for(auto p: outputSet)
228 board << p ;
229 board.saveOBJ("box26-dig.obj");
230
231 CAPTURE(outputSet.size());
232 //hard coded test.
233 REQUIRE( outputSet.size() == 4162 );
234 }
235}
DGtal::Board3D
The class Board3D is a type of Display3D which export the figures in the format OBJ/MTL when calling ...
Definition: Board3D.h:82
DGtal::Board3D::saveOBJ
void saveOBJ(const std::string &filename, const bool isNormalized=false)
DGtal::DigitalSetByAssociativeContainer
Aim: A wrapper class around a STL associative container for storing sets of digital points within som...
Definition: DigitalSetByAssociativeContainer.h:90
DGtal::DigitalSetBySTLSet
Aim: A container class for storing sets of digital points within some given domain.
Definition: DigitalSetBySTLSet.h:85
DGtal::InHalfPlaneBySimple3x3Matrix
Aim: Class that implements an orientation functor, ie. it provides a way to compute the orientation o...
Definition: InHalfPlaneBySimple3x3Matrix.h:92
DGtal::MeshVoxelizer
Aim: A class for computing the digitization of a triangle or a Mesh.
Definition: MeshVoxelizer.h:80
DGtal::Mesh
Aim: This class is defined to represent a surface mesh through a set of vertices and faces....
Definition: Mesh.h:92
DGtal::Mesh::nbFaces
Size nbFaces() const
DGtal::PointVector
Aim: Implements basic operations that will be used in Point and Vector classes.
Definition: PointVector.h:593
DGtal::PredicateFromOrientationFunctor2
Aim: Small adapter to models of COrientationFunctor2. It is a model of concepts::CPointPredicate....
Definition: PredicateFromOrientationFunctor2.h:82
DGtal::Z3i::Point
Space::Point Point
Definition: StdDefs.h:168
DGtal::dec_helper::diagonal
DGtal::LinearOperator< Calculus, dim, duality, dim, duality > diagonal(const DGtal::KForm< Calculus, dim, duality > &kform)
Definition: DECHelpers.h:60
DGtal::MeshReader::importOFFFile
static bool importOFFFile(const std::string &filename, DGtal::Mesh< TPoint > &aMesh, bool invertVertexOrder=false)
CAPTURE
CAPTURE(thicknessHV)
domain
Domain domain
Definition: testProjection.cpp:88
SECTION
SECTION("Testing constant forward iterators")
Definition: testSimpleRandomAccessRangeFromPoint.cpp:66
REQUIRE
REQUIRE(domain.isInside(aPoint))

References CAPTURE(), domain, DGtal::MeshReader< TPoint >::importOFFFile(), DGtal::Mesh< TPoint >::nbFaces(), REQUIRE(), DGtal::Board3D< Space, KSpace >::saveOBJ(), SECTION(), and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::size().

Generated on Sun Nov 27 2022 15:15:59 for DGtal by doxygen 1.9.5