Helios++
Helios software for LiDAR simulations
SerializationTest.h
1 #pragma once
2 
3 #include <BaseTest.h>
4 #include <DetailedVoxel.h>
5 #include <Scene.h>
6 #include <SerialIO.h>
7 #include <vector>
8 #include <cstdio>
9 
10 namespace HeliosTests{
11 
18 class SerializationTest : public BaseTest{
19 public:
20  // *** CONSTRUCTOR *** //
21  // ********************* //
25  SerializationTest() : BaseTest("Serialization test"){}
26 
27  // *** R U N *** //
28  // *************** //
32  bool run() override;
33 
34  // *** UTILS *** //
35  // *************** //
43  bool validate(DetailedVoxel &dv1, DetailedVoxel &dv2);
50  bool validate(Voxel &v1, Voxel &v2);
58  bool validate(AABB &box1, AABB &box2);
59 
66  bool validate(Triangle &t1, Triangle &t2);
67 };
68 
70  std::string path("SerializationTest.tmp");
71 
72  // Detailed voxel serialization test
73  DetailedVoxel dv1(
74  1.0,
75  2.0,
76  1.0,
77  1.0,
78  std::vector<int>({0,1,2}),
79  std::vector<double>({1.0, 1.5, 2.0, 2.5, 3.0})
80  );
81  dv1.part = std::make_shared<ScenePart>();
82  dv1.part->onRayIntersectionMode = "TRANSMITTIVE";
83  dv1.material = std::make_shared<Material>();
84  dv1.material->ka[0] = 1.0;
85  dv1.material->ka[0] = 2.0;
86  dv1.material->ka[0] = 3.0;
87  dv1.material->ka[0] = 4.0;
90  if(!validate(dv1,*dv2)) return false;
91 
92  // Scene serialization test
93  size_t nRepeats = 32;
94  Scene scene1;
95  Vertex t1v1; t1v1.pos = glm::dvec3(0.0, 0.0, 0.0);
96  Vertex t1v2; t1v2.pos = glm::dvec3(0.0, 0.0, 4.0);
97  Vertex t1v3; t1v3.pos = glm::dvec3(2.0, 0.0, 0.0);
98  Triangle t1(t1v1, t1v2, t1v3);
99  Voxel v1(1.0, 1.0, 1.0, 1.0);
100  AABB box1(glm::dvec3(0.0, 0.0, 0.0), glm::dvec3(5.0, 5.0, 5.0));
101  scene1.primitives.push_back(dv1.clone());
102  scene1.primitives.push_back(t1.clone());
103  scene1.primitives.push_back(v1.clone());
104  scene1.primitives.push_back(box1.clone());
105  for(size_t i = 0 ; i < nRepeats ; i++)
106  scene1.primitives.push_back(dv1.clone());
107  scene1.primitives.push_back(dv1.clone());
108  scene1.finalizeLoading();
109  scene1.writeObject(path);
110  Scene *scene2 = Scene::readObject(path);
111  scene2->finalizeLoading();
112  if(!validate(dv1, *(DetailedVoxel *) scene2->primitives[0])) return false;
113  if(!validate(t1, *(Triangle *) scene2->primitives[1])) return false;
114  if(!validate(v1, *(Voxel *) scene2->primitives[2])) return false;
115  if(!validate(box1, *(AABB *) scene2->primitives[3])) return false;
116  for(size_t i = 0 ; i < nRepeats ; i++){
117  if(!validate(dv1, *(DetailedVoxel *) scene2->primitives[i+4]))
118  return false;
119  }
120 
121 
122  // Remove temporary file
123  std::remove(path.c_str());
124 
125  // Successfully reached end of test
126  return true;
127 }
128 
129 // *** UTILS *** //
130 // *************** //
132  DetailedVoxel &dv1, DetailedVoxel &dv2
133 ){
134  glm::dvec3 dv1c = dv1.getCentroid();
135  glm::dvec3 dv2c = dv2.getCentroid();
136  if(dv1c.x!=dv2c.x || dv1c.y!=dv2c.y || dv1c.z!=dv2c.z) return false;
137  if(dv1.halfSize!=dv2.halfSize) return false;
138  for(size_t i = 0 ; i < dv1.getNumberOfIntValues() ; i++){
139  if(dv1.getIntValue(i)!=dv2.getIntValue(i)) return false;
140  }
141  for(size_t i = 0 ; i < dv1.getNumberOfDoubleValues() ; i++){
142  if(dv1[i]!=dv2[i]) return false;
143  }
144  if(dv1.material == nullptr && dv2.material != nullptr) return false;
145  if(dv1.material != nullptr && dv2.material == nullptr) return false;
146  if(dv1.material != nullptr && dv2.material != nullptr) {
147  for (size_t i = 0; i < 4; i++) {
148  if (dv1.material->ka[i] != dv2.material->ka[i]) return false;
149  }
150  }
151  return true;
152 }
154  Voxel &v1, Voxel &v2
155 ){
156  glm::dvec3 v1c = v1.getCentroid();
157  glm::dvec3 v2c = v2.getCentroid();
158  if(v1c.x!=v2c.x || v1c.y!=v2c.y || v1c.z!=v2c.z) return false;
159  if(v1.halfSize!=v2.halfSize) return false;
160  return true;
161 }
163  AABB &box1, AABB &box2
164 ){
165  double minX1 = box1.getMin().x; double maxX1 = box1.getMax().x;
166  double minY1 = box1.getMin().y; double maxY1 = box1.getMax().y;
167  double minZ1 = box1.getMin().z; double maxZ1 = box1.getMax().z;
168  double minX2 = box2.getMin().x; double maxX2 = box2.getMax().x;
169  double minY2 = box2.getMin().y; double maxY2 = box2.getMax().y;
170  double minZ2 = box2.getMin().z; double maxZ2 = box2.getMax().z;
171 
172  if (minX1 != minX2) return false;
173  if (minY1 != minY2) return false;
174  if (minZ1 != minZ2) return false;
175 
176  if (maxX1 != maxX2) return false;
177  if (maxY1 != maxY2) return false;
178  if (maxZ1 != maxZ2) return false;
179 
180  return true;
181 }
182 
184  double x1, x2, y1, y2, z1, z2;
185  for(size_t i = 0 ; i < t1.getNumVertices() ; i++){
186  x1 = t1.verts[i].getX();
187  x2 = t2.verts[i].getX();
188  if(x1 != x2) return false;
189  y1 = t1.verts[i].getY();
190  y2 = t2.verts[i].getY();
191  if(y1 != y2) return false;
192  z1 = t1.verts[i].getZ();
193  z2 = t2.verts[i].getZ();
194  if(z1 != z2) return false;
195  }
196  return true;
197 }
198 
199 
200 
201 
202 }
glm::dvec3 const & getMin() const
Get the min value for each coordinate of the axis aligned bounding box.
Definition: AABB.h:75
glm::dvec3 getCentroid() override
Definition: Voxel.cpp:41
bool run() override
Definition: SerializationTest.h:69
size_t getNumberOfIntValues() const
Obtain the number of integer values defining the detailed voxel.
Definition: DetailedVoxel.h:182
Primitive * clone() override
Definition: Voxel.cpp:17
int getIntValue(size_t index) const
Obtain integer value at given index.
Definition: DetailedVoxel.h:203
void writeObject(std::string path)
Serialize the scene and write it to given output file.
Definition: Scene.cpp:231
Test serialization.
Definition: SerializationTest.h:18
std::shared_ptr< Material > material
Shared pointer to the material defining certain properties such as reflectance, specularity, ...
Definition: Primitive.h:43
std::vector< Primitive * > primitives
Vector of primitives composing the scene.
Definition: Scene.h:66
BaseTest class.
Definition: BaseTest.h:19
glm::dvec3 const & getMax() const
Get the max value for each coordinate of the axis aligned bounding box.
Definition: AABB.h:81
SerialClass * read(std::string &path, bool fastCompression=true)
Class which extends Voxel to support AMAPVox format with extra features.
Definition: DetailedVoxel.h:12
size_t getNumVertices() override
Definition: Triangle.h:98
bool finalizeLoading()
Handle scene loading finish process.
Definition: Scene.cpp:59
static Scene * readObject(std::string path)
Read serialized scene from given file.
Definition: Scene.cpp:238
Class representing an Axis Aligned Bounding Box (AABB)
Definition: AABB.h:10
Primitive * clone() override
Definition: Triangle.cpp:26
SerializationTest()
Serialization test constructor.
Definition: SerializationTest.h:25
bool validate(DetailedVoxel &dv1, DetailedVoxel &dv2)
Check two detailed voxels are equal.
Definition: SerializationTest.h:131
Class representing a voxel primitive.
Definition: Voxel.h:11
Class representing triangle primitive.
Definition: Triangle.h:13
double getX() const
Get the X coordinate of vertex position.
Definition: Vertex.h:84
double halfSize
Half of the voxel sizxe.
Definition: Voxel.h:67
glm::dvec3 pos
Vertex 3D position.
Definition: Vertex.h:32
void write(std::string &path, SerialClass *object, bool fastCompression=true)
double getZ() const
Get the Z coordinate of vertex position.
Definition: Vertex.h:102
Definition: BaseTest.h:6
Vertex verts[3]
The 3 vertices defining the triangle.
Definition: Triangle.h:54
Class representing a scene asset.
Definition: Scene.h:25
std::shared_ptr< ScenePart > part
Shared pointer to the scene part the primitive belongs to.
Definition: Primitive.h:37
static SerialIO * getInstance()
Definition: SerialIO.cpp:6
Primitive * clone() override
Generate a clone of the primitive.
Definition: AABB.cpp:17
size_t getNumberOfDoubleValues() const
Obtain the number of double values defining the detailed voxel.
Definition: DetailedVoxel.h:188
Primitive * clone() override
Definition: DetailedVoxel.cpp:6
Class representing a vertex.
Definition: Vertex.h:14
double getY() const
Get the Y coordinate of vertex position.
Definition: Vertex.h:93