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