Helios++
Helios software for LiDAR simulations
LadLutTest.h
1 #pragma once
2 
3 #include <string>
4 #include "BaseTest.h"
5 #include <LadLut.h>
6 #include <LadLutLoader.h>
7 
8 namespace HeliosTests{
9 
15 class LadLutTest : public BaseTest{
16 public:
17  // *** ATTRIBUTES *** //
18  // ******************** //
22  double eps = 0.00001; // Decimal precision for validation purposes
28  std::string testDir;
29 
30  // *** CONSTRUCTOR *** //
31  // ********************* //
35  LadLutTest(std::string testDir="data/test/") :
36  BaseTest("LadLut test"),
38  {}
39 
40  // *** R U N *** //
41  // *************** //
45  bool run() override;
46 
47  // *** INNER METHODS *** //
48  // *********************** //
56  bool validateLadLut(LadLut const &ladlut);
73  double x, double y, double z,
74  double ex, double ey, double ez
75  );
76 };
77 
78 
80  // Input / expected output
81  double u1[3] = {0.79259392, 0.22645541, 0.56613852};
82  double g1 = 0.582513;
83  double u2[3] = {-0.440759, 0.000000, 0.897626};
84  double g2 = 0.720515;
85  double u3[3] = {-0.36999991, 0.46129036, -0.80641879};
86  double g3 = 0.673911;
87 
88  // Load spherical
89  std::string llPath = testDir + "spherical.txt";
90  LadLutLoader loader;
91  std::shared_ptr<LadLut> ladlut = loader.load(llPath);
92  if(!validateLadLut(*ladlut)) return false;
93 
94  // Transform to LadLut domain
95  double wx, wy, wz;
96  ladlut->transformToLadLutDomain(u1[0], u1[1], u1[2], wx, wy, wz);
97  if(!validateTransformation(wx, wy, wz, 0.824310, 0.0, 0.566139))
98  return false;
99 
100  // Interpolate 1
101  double g = ladlut->interpolate(u1[0], u1[1], u1[2]);
102  if(fabs(g-g1) > eps) return false;
103 
104  // Interpolate w
105  g = ladlut->interpolate(wx, wy, wz);
106  if(fabs(g-g1) > eps) return false;
107 
108  // Interpolate 2
109  g = ladlut->interpolate(u2[0], u2[1], u2[2]);
110  if(fabs(g-g2) > eps) return false;
111 
112  // Interpolate 3
113  g = ladlut->interpolate(u3[0], u3[1], u3[2]);
114  if(fabs(g-g3) > eps) return false;
115 
116  // Return
117  return true;
118 }
119 
120 
121 bool LadLutTest::validateLadLut(LadLut const &ladlut){
122  // Validation data
123  size_t indices[4] = {0, 1, 498, 499};
124  double expectedX[4] = {
125  1.000000, 0.999921, 0.999921, 1.000000
126  };
127  double expectedY[4] = {
128  0.000000, 0.000000, 0.000000, 0.000000
129  };
130  double expectedZ[4] = {
131  0.000000, 0.012591, -0.012591, -0.000000
132  };
133  double expectedG[4] = {
134  0.500000, 0.500040, 0.500040, 0.500000
135  };
136 
137  // Validate
138  for(size_t i = 0 ; i < 4 ; i++){
139  size_t idx = indices[i];
140  // Compute differences
141  double diffX = ladlut.X[idx] - expectedX[i];
142  double diffY = ladlut.Y[idx] - expectedY[i];
143  double diffZ = ladlut.Z[idx] - expectedZ[i];
144  double diffG = ladlut.G[idx] - expectedG[i];
145  // Validate differences
146  if(diffX < -eps || diffX > eps) return false;
147  if(diffY < -eps || diffY > eps) return false;
148  if(diffZ < -eps || diffZ > eps) return false;
149  if(diffG < -eps || diffG > eps) return false;
150  }
151  return true;
152 }
153 
155  double x, double y, double z,
156  double ex, double ey, double ez
157 ){
158  double xDiff = x-ex;
159  double yDiff = y-ey;
160  double zDiff = z-ez;
161  return xDiff > -eps && xDiff < eps &&
162  yDiff > -eps && yDiff < eps &&
163  zDiff > -eps && zDiff < eps;
164 }
165 
166 }
BaseTest class.
Definition: BaseTest.h:20
Test look-up table for leaf angle distribution.
Definition: LadLutTest.h:15
double eps
Decimal precision for validation purposes.
Definition: LadLutTest.h:22
bool run() override
Definition: LadLutTest.h:79
std::string testDir
Where required test files are stored. For LadLutTest it is required that a file named spherical....
Definition: LadLutTest.h:28
bool validateLadLut(LadLut const &ladlut)
Validate given leaf angle distribution look-up table.
Definition: LadLutTest.h:121
bool validateTransformation(double x, double y, double z, double ex, double ey, double ez)
Validate a transformation.
Definition: LadLutTest.h:154
LadLutTest(std::string testDir="data/test/")
Leaf angle distribution look-up table test constructor.
Definition: LadLutTest.h:35
Loader for Leaf Angle Distribution Look Up Tables.
Definition: LadLutLoader.h:10
std::shared_ptr< LadLut > load(std::string const &path, std::string const separator=",")
Load LadLut from specified file.
Definition: LadLutLoader.cpp:8
Leaf Angle Distribution Look-Up Table.
Definition: LadLut.h:13
std::vector< double > Y
Y component of normalized director vector for each record.
Definition: LadLut.h:45
std::vector< double > G
Function evaluation for each record.
Definition: LadLut.h:53
std::vector< double > X
X component of normalized director vector for each record.
Definition: LadLut.h:41
std::vector< double > Z
Z component of normalized director vector for each record.
Definition: LadLut.h:49