Merge pull request #456 from 3dgeo-heidelberg/devel-aux

Devel aux

pytests/test_demo_scenes.py

@@ -201,7 +201,7 @@ def test_xyzVoxels_tls_pyh():
 
 def eval_xyzVoxels_tls(dirname):
     assert (dirname / 'leg000_points.las').exists()
-    assert abs((dirname / 'leg000_points.las').stat().st_size - 50_340_807) < MAX_DIFFERENCE_BYTES
+    assert abs((dirname / 'leg000_points.las').stat().st_size - 19_352_123) < MAX_DIFFERENCE_BYTES
     # clean up
     if DELETE_FILES_AFTER:
         shutil.rmtree(dirname)
@@ -450,7 +450,7 @@ def test_dyn_exe():
 
 def eval_dyn(dirname):
     assert (dirname / 'leg000_points.laz').exists()
-    assert abs((dirname / 'leg000_points.laz').stat().st_size - 4_174_789) < MAX_DIFFERENCE_BYTES
+    assert abs((dirname / 'leg000_points.laz').stat().st_size - 2_642_291) < MAX_DIFFERENCE_BYTES
     # clean up
     if DELETE_FILES_AFTER:
         shutil.rmtree(dirname)

pytests/test_pyhelios.py

@@ -273,7 +273,7 @@ def test_create_survey():
     output = simB.join()
     meas, traj = pyhelios.outputToNumpy(output)
     # check length of output
-    assert meas.shape == (34317, 17)
+    assert meas.shape == (9926, 17)
     assert traj.shape == (6670, 7)
     # compare individual points
     np.testing.assert_allclose(meas[100, :3], np.array([83.32, -66.44204, 0.03114649]))

python/pyhelios/simulation_builder.py

@@ -1,6 +1,7 @@
 from .pyheliostools_exception import PyHeliosToolsException
 from .simulation_build import SimulationBuild
 from collections import namedtuple
+from collections.abc import Iterable
 from math import isnan
 import os
 import time
@@ -66,6 +67,8 @@ class SimulationBuilder:
     # ---  CONSTRUCTOR  --- #
     # --------------------- #
     def __init__(self, surveyPath, assetsDir, outputDir):
+        if not isinstance(assetsDir, Iterable) or isinstance(assetsDir, str):
+            assetsDir = [assetsDir]
         # Add default values for asset directories
         assetsDir = assetsDir + [os.getcwd(), str(resources.files("pyhelios")), str(resources.files("pyhelios") / "data")]
 
@@ -127,8 +130,6 @@ def build(self):
         build.sim.finalOutput = self.finalOutput
         build.sim.legacyEnergyModel = self.legacyEnergyModel
         build.sim.exportToFile = self.exportToFile
-        if self.callback is not None:
-            build.sim.setCallback(self.callback)
         for rotateFilter in self.rotateFilters:
             build.sim.addRotateFilter(
                 rotateFilter.q0,
@@ -157,6 +158,8 @@ def build(self):
             self.fullwaveNoise,
             self.platformNoiseDisabled
         )
+        if self.callback is not None:
+            build.sim.setCallback(self.callback)
 
         end = time.perf_counter()
         print(

src/assetloading/CMakeLists.txt

@@ -15,6 +15,8 @@ target_sources(
   "geometryfilter/RotateFilter.cpp"
   "geometryfilter/GeoTiffFileLoader.cpp"
   "geometryfilter/DetailedVoxelLoader.cpp"
+  "geometryfilter/DenseVoxelGrid.cpp"
+  "geometryfilter/SparseVoxelGrid.cpp"
   "geometryfilter/WavefrontObj.cpp"
   "geometryfilter/XYZPointCloudFileLoader.cpp"
   "geometryfilter/AbstractGeometryFilter.cpp"

src/assetloading/XmlUtils.cpp

@@ -55,7 +55,7 @@ std::map<std::string, ObjectT> XmlUtils::createParamsFromXml(
                 result.insert(std::pair<std::string, std::string>(key, valueString));
             } else {
 
-                if (type == "boolean") {
+                if (type == "boolean" || type == "bool") {
                     bool b = valueString == "true";
                     result.insert(std::pair<std::string, bool>(key, b));
                 } else if (type == "double") {

src/assetloading/geometryfilter/DenseVoxelGrid.cpp

@@ -0,0 +1,135 @@
+#include <assetloading/geometryfilter/DenseVoxelGrid.h>
+
+// ***  CONSTRUCTION / DESTRUCTION  *** //
+// ************************************ //
+DenseVoxelGrid::DenseVoxelGrid(size_t const maxNVoxels) :
+    IVoxelGrid(maxNVoxels)
+{
+    voxels = new VoxelGridCell[maxNVoxels];
+}
+
+
+// ***  VOXEL GRID INTERFACE  *** //
+// ****************************** //
+void DenseVoxelGrid::release(){
+    if(voxels != nullptr){
+        delete[] voxels;
+        voxels = nullptr;
+    }
+}
+
+
+bool DenseVoxelGrid::hasVoxel(size_t const key){
+    return voxels[key].voxel != nullptr;
+}
+
+Voxel* DenseVoxelGrid::getVoxel(size_t const key){
+    return voxels[key].voxel;
+}
+
+Voxel * DenseVoxelGrid::setVoxel(
+    size_t const key,
+    double const x, double const y, double const z,
+    double halfVoxelSize
+){
+    VoxelGridCell &vgc = voxels[key];
+    vgc.voxel = new Voxel(x, y, z, halfVoxelSize);
+    return vgc.voxel;
+}
+
+void DenseVoxelGrid::deleteVoxel(size_t const key){
+    Voxel *voxel = voxels[key].voxel;
+    if(voxel == nullptr) return;
+    delete voxel;
+    voxels[key].voxel = nullptr;
+}
+
+Mat<double> * DenseVoxelGrid::getMatrix(size_t const key) const {
+    return voxels[key].matrix;
+}
+
+Mat<double> & DenseVoxelGrid::getMatrixRef(size_t const key) const {
+    return *voxels[key].matrix;
+}
+
+Mat<double> const & DenseVoxelGrid::getMatrixConstRef(size_t const key) const {
+    return *voxels[key].matrix;
+}
+
+void DenseVoxelGrid::setMatrix(size_t const key, Mat<double> *mat){
+    VoxelGridCell &vgc = voxels[key];
+    if(vgc.matrix != nullptr) deleteMatrix(key);
+    vgc.matrix = mat;
+}
+
+void DenseVoxelGrid::setNextMatrixCol(
+    size_t const key,
+    double const x, double const y, double const z
+) {
+    VoxelGridCell &vgc = voxels[key];
+    size_t const startIdx = vgc.cursor*3;
+    (*vgc.matrix)[startIdx] = x;
+    (*vgc.matrix)[startIdx+1] = y;
+    (*vgc.matrix)[startIdx+2] = z;
+    ++vgc.cursor;
+}
+
+void DenseVoxelGrid::deleteMatrix(size_t const key){
+    delete voxels[key].matrix;
+    voxels[key].matrix = nullptr;
+}
+void DenseVoxelGrid::deleteMatrices(){
+    for(size_t i = 0 ; i < maxNVoxels ; ++i) deleteMatrix(i);
+}
+
+
+size_t DenseVoxelGrid::getCursor(size_t const key) const{
+    return voxels[key].cursor;
+}
+
+void DenseVoxelGrid::setCursor(size_t const key, size_t const cursor) {
+    voxels[key].cursor = cursor;
+}
+
+void DenseVoxelGrid::incrementCursor(size_t const key){
+    ++voxels[key].cursor;
+}
+
+double DenseVoxelGrid::getClosestPointDistance(size_t const key) const {
+    return voxels[key].closestPointDistance;
+}
+void DenseVoxelGrid::setClosestPointDistance(
+    size_t const key, double const distance
+) {
+    voxels[key].closestPointDistance = distance;
+}
+
+
+// ***   WHILE INTERFACE   *** //
+// *************************** //
+void DenseVoxelGrid::whileLoopStart(){
+    for(
+        whileLoopIter = 0 ;
+        whileLoopIter < maxNVoxels && voxels[whileLoopIter].voxel == nullptr;
+        ++whileLoopIter
+    );
+}
+
+bool DenseVoxelGrid::whileLoopHasNext(){
+    return whileLoopIter < maxNVoxels;
+}
+
+Voxel * DenseVoxelGrid::whileLoopNext(size_t *key){
+    // Obtain current voxel
+    Voxel *voxel = voxels[whileLoopIter].voxel;
+    // Obtain the matrix, if requested
+    if(key != nullptr) *key = whileLoopIter;
+    // Iterate to find next voxel, if any, and update whileLoopIter
+    for(
+        ++whileLoopIter;
+        whileLoopIter < maxNVoxels && voxels[whileLoopIter].voxel == nullptr;
+        ++whileLoopIter
+    );
+    // Return current voxel
+    return voxel;
+}

src/assetloading/geometryfilter/DenseVoxelGrid.h

@@ -0,0 +1,141 @@
+#pragma once
+
+#include <assetloading/geometryfilter/IVoxelGrid.h>
+
+/**
+ * @author Alberto M. Esmoris Pena
+ * @version 1.0
+ *
+ * @brief Dense voxel grid implementation of IVoxelGrid. It uses the indices
+ *  of an array to represent the (key, value) pairs as (index, voxel).
+ *
+ * @see IVoxelGrid
+ */
+class DenseVoxelGrid : public IVoxelGrid {
+protected:
+    // ***   ATTRIBUTES   *** //
+    // ********************** //
+    /**
+     * @brief Array of voxels.
+     * @see VoxelGridCell
+     * @see Voxel
+     */
+    VoxelGridCell *voxels;
+    /**
+     * @brief Used internally to track the current iteration of the while loop.
+     */
+    size_t whileLoopIter;
+
+public:
+    // ***  CONSTRUCTION / DESTRUCTION  *** //
+    // ************************************ //
+    /**
+     * @brief Constructor for a dense voxel grid.
+     * @see IVoxelGrid::IVoxelGrid
+     */
+    DenseVoxelGrid(size_t const maxNVoxels);
+    virtual ~DenseVoxelGrid() {release();}
+
+    // ***  VOXEL GRID INTERFACE  *** //
+    // ****************************** //
+    /**
+     * @see IVoxelGrid::release
+     */
+    void release() override;
+
+
+    /**
+     * @see IVoxelGrid::hasVoxel
+     */
+    bool hasVoxel(size_t const key) override;
+    /**
+     * @see IVoxelGrid::getVoxel
+     */
+    Voxel* getVoxel(size_t const key) override;
+    /**
+     * @see IVoxelGrid::setVoxel
+     */
+    Voxel * setVoxel(
+        size_t const key,
+        double const x, double const y, double const z,
+        double halfVoxelSize
+    ) override;
+    /**
+     * @see IVoxelGrid::deleteVoxel
+     */
+    void deleteVoxel(size_t const key) override;
+
+
+    /**
+     * @see IVoxelGrid::getMatrix
+     */
+    Mat<double> * getMatrix(size_t const key) const override;
+    /**
+     * @see IVoxelGrid::getMatrixRef
+     */
+    Mat<double> & getMatrixRef(size_t const key) const override;
+    /**
+     * @see IVoxelGrid::getMatrixConstRef
+     */
+    Mat<double> const & getMatrixConstRef(size_t const key) const override;
+    /**
+     * @see IVoxelGrid::setMatrix
+     */
+    void setMatrix(size_t const key, Mat<double> *mat) override;
+    /**
+     * @see IVoxelGrid::setNextMatrixCol
+     */
+    void setNextMatrixCol(
+        size_t const key,
+        double const x, double const y, double const z
+    ) override;
+    /**
+     * @see IVoxelGrid::deleteMatrix
+     */
+    void deleteMatrix(size_t const key) override;
+    /**
+     * @see IVoxelGrid::deleteMatrices
+     */
+    void deleteMatrices() override;
+
+
+    /**
+     * @see IVoxelGrid::getCursor
+     */
+    size_t getCursor(size_t const key) const override;
+    /**
+     * @see IVoxelGrid::setCursor
+     */
+    void setCursor(size_t const key, size_t const cursor) override;
+    /**
+     * @see IVoxelGrid::incrementCursor
+     */
+    void incrementCursor(size_t const key) override;
+
+    /**
+     * @see IVoxelGird::getClosestPointDistance
+     */
+    double getClosestPointDistance(size_t const key) const override;
+    /**
+     * @see IVoxelGrid::setClosestPointDistance
+     */
+    void setClosestPointDistance(
+        size_t const key, double const distance
+    ) override;
+
+
+    // ***   WHILE INTERFACE   *** //
+    // *************************** //
+    /**
+     * @see IVoxelGrid::whileLoopStart
+     */
+    void whileLoopStart() override;
+    /**
+     * @see IVoxelGrid::whileLoopHasNext
+     */
+    bool whileLoopHasNext() override;
+    /**
+     * @see IVoxelGrid::whileLoopNext
+     */
+    Voxel * whileLoopNext(size_t *key=nullptr) override;
+};

src/assetloading/geometryfilter/DetailedVoxelLoader.cpp

@@ -67,7 +67,8 @@ void DetailedVoxelLoader::loadDv(
     }
     // Prepare default material
     Material mat;
-    mat.isGround = false;
+    // Legacy default material for vegetation studies commented below
+    /*mat.isGround = false;
     mat.useVertexColors = true;
     mat.reflectance = 0.5;
     mat.specularity = 0.5;
@@ -78,7 +79,7 @@ void DetailedVoxelLoader::loadDv(
     mat.kd[2] = 0.5;    mat.kd[3] = 0.5;
     mat.ks[0] = 0.5;    mat.ks[1] = 0.5;
     mat.ks[2] = 0.5;    mat.ks[3] = 0.5;
-    mat.spectra = "wood";
+    mat.spectra = "wood";*/
 
     // Parse detailed voxels
     VoxelFileParser vfp;