File failed to load: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/config/TeX-MML-AM_CHTML/MathJax.js
DGtal 2.0.0
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 dependency graph for testMeshVoxelization.cpp:

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 41 of file testMeshVoxelization.cpp.

42{
43 using PointR3 = PointVector<3, double>;
44 using VectorR3 = PointVector<3, double>;
45 using PointR2 = PointVector<2, double>;
46 using PointZ3 = PointVector<3, int>;
47
48 using MeshVoxelizer26 = MeshVoxelizer< DigitalSet, 26>;
49 using MeshVoxelizer6 = MeshVoxelizer< DigitalSet, 6>;
50
51 using TriOr = MeshVoxelizer6::TriangleOrientation;
52
53 // ---------------------------------------------------------
54 SECTION("Test distance point/plan 3D")
55 {
56 // Triangle ABC in R3
57 const PointR3 A(38.6908 , 14.5441 , -0.71205);
58 const PointR3 B(34.6171 , 13.5999 , 2.44455);
59 const PointR3 C(37.4205 , 2.44239 , 6.31301);
60
61 // Point v
62 const PointZ3 v(35, 2, 5);
63
64 const VectorR3 e1 = A - B;
65 const VectorR3 e2 = A - C;
66
67 double distance = MeshVoxelizer6::distance(A, e1.crossProduct(e2), v);
68
69 REQUIRE( 2.40 < distance );
70 REQUIRE( distance < 2.41 );
71 }
72
73 // ---------------------------------------------------------
74 SECTION("Test if 2D point is inside triangle 2D")
75 {
76 // Triangle ABC in R2
77 PointR2 A(1.0, 1.0);
78 PointR2 B(2.0, 3.0);
79 PointR2 C(3.0, 1.0);
80
81 typedef InHalfPlaneBySimple3x3Matrix<PointR2, double> OrientationFunctor;
82 OrientationFunctor orientationFunctor;
83
84 //geometric predicate
85 PredicateFromOrientationFunctor2<OrientationFunctor> pointPredicate( orientationFunctor );
86
87 if(! pointPredicate(A, B, C))
88 {
89 std::swap(A, C);
90 }
91
92 // Test if point v is inside triangle ABC
93 // 0 : outside
94 // 1 : inside
95 // 2 : on edge
96 // 3 : on vertex
97 PointR2 v;
98
99 v[0] = 3.0;
100 v[1] = 3.0;
101 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::TRIANGLE_OUTSIDE);
102
103 v[0] = 2.0;
104 v[1] = 2.0;
105 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::TRIANGLE_INSIDE);
106
107 v[0] = 2;
108 v[1] = 1;
109 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::TRIANGLE_ONEDGE);
110
111 v[0] = 3;
112 v[1] = 1;
113 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::TRIANGLE_ONVERTEX);
114
115 // another case
116 A = { 16.3299, 0. };
117 B = { 0., 16.3299 };
118 C = { -16.3299, 0. };
119 v = { -17., 0.};
120 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::TRIANGLE_OUTSIDE);
121
122 // another case
123 A = { -0.891282, 9.91201 };
124 B = { -1.40823, 9.91261 };
125 C = { -1.36963, 9.37414 };
126 v = { -1.16961, 9.83039 };
127 REQUIRE(MeshVoxelizer6::pointIsInside2DTriangle(A, B, C, v) == TriOr::TRIANGLE_INSIDE);
128 }
129
130 // ---------------------------------------------------------
131 SECTION("Test if 3D point is inside voxel")
132 {
133 // Triangle ABC in R2
134 PointR3 P(-0.89, 9.91, 0.86);
135 PointZ3 v(-1, 10, 1);
136
137 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == true); // inside
138
139 P[0] = -1.41;
140 P[1] = 9.91;
141 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == true); // inside
142
143 P[0] = -1.37;
144 P[1] = 9.37;
145 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == false); // outside
146
147 P[0] = -1.17;
148 P[1] = 9.83;
149 P[2] = 0;
150 REQUIRE(MeshVoxelizer6::pointIsInsideVoxel(P, v) == false); // outside
151 }
152
153 // ---------------------------------------------------------
154 SECTION("26-sep voxelization of a single triangle")
155 {
156 Domain domain(Point(0,0,0), Point(10,10,10));
157 DigitalSet outputSet(domain);
158 MeshVoxelizer26 voxelizer;
159
160 voxelizer.voxelize(outputSet, Point(5,0,0), Point(0,5,0), Point(0,0,5));
161 REQUIRE( outputSet.size() == 46 );
162 }
163
164 // ---------------------------------------------------------
165 SECTION("6-sep voxelization of a single triangle")
166 {
167 Domain domain(Point(0,0,0), Point(10,10,10));
168 DigitalSet outputSet(domain);
169 MeshVoxelizer6 voxelizer;
170
171 voxelizer.voxelize(outputSet, Point(5,0,0), Point(0,5,0), Point(0,0,5));
172 REQUIRE( outputSet.size() == 21 );
173 }
174
175 // ---------------------------------------------------------
176 SECTION("6-sep voxelization of a OFF cube mesh")
177 {
178 //Importing OFF mesh
179 Mesh<Z3i::RealPoint> inputMesh;
180 MeshReader<Z3i::RealPoint>::importOFFFile(testPath +"/samples/box.off" , inputMesh);
181 Z3i::Domain domain( Point().diagonal(-30), Point().diagonal(30));
182 DigitalSet outputSet(domain);
183 MeshVoxelizer6 voxelizer;
184
185 CAPTURE(inputMesh.nbFaces());
186
187 voxelizer.voxelize(outputSet, inputMesh, 10.0 );
188
189 CAPTURE(outputSet.size());
190 //hard coded test.
191 REQUIRE( outputSet.size() == 2562 );
192 }
193 // ---------------------------------------------------------
194 SECTION("26-sep voxelization of a OFF cube mesh")
195 {
196 //Importing OFF mesh
197 Mesh<Z3i::RealPoint> inputMesh;
198 MeshReader<Z3i::RealPoint>::importOFFFile(testPath +"/samples/box.off" , inputMesh);
199 Z3i::Domain domain( Point().diagonal(-30), Point().diagonal(30));
200 DigitalSet outputSet(domain);
201 MeshVoxelizer26 voxelizer;
202
203 CAPTURE(inputMesh.nbFaces());
204
205 voxelizer.voxelize(outputSet, inputMesh, 10.0 );
206
207 CAPTURE(outputSet.size());
208 //hard coded test.
209 REQUIRE( outputSet.size() == 4162 );
210 }
211}
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::Domain
HyperRectDomain< Space > Domain
Definition StdDefs.h:172
DGtal::Z3i::Point
Space::Point Point
Definition StdDefs.h:168
DGtal::Z3i::DigitalSet
DigitalSetSelector< Domain, BIG_DS+HIGH_BEL_DS >::Type DigitalSet
Definition StdDefs.h:173
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, bool onlyFaceVertex=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(), SECTION(), and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::size().