python interfacing works. Implementted simple EPT-Format reader as a showcase

Author: Felix Igelbrink

src/gil.h

@@ -0,0 +1,79 @@
+//
+// Taken from the pybind11 project: https://github.com/pybind/pybind11/blob/14976c853b8422dc41ce7874742cab122684c97e/include/pybind11/gil.h
+//
+//Copyright (c) 2016 Wenzel Jakob <[email protected]>, All rights reserved.
+//
+//Redistribution and use in source and binary forms, with or without
+//        modification, are permitted provided that the following conditions are met:
+//
+//1. Redistributions of source code must retain the above copyright notice, this
+//list of conditions and the following disclaimer.
+//
+//2. Redistributions in binary form must reproduce the above copyright notice,
+//this list of conditions and the following disclaimer in the documentation
+//and/or other materials provided with the distribution.
+//
+//3. Neither the name of the copyright holder nor the names of its contributors
+//        may be used to endorse or promote products derived from this software
+//        without specific prior written permission.
+//
+//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+//        ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+//        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+//        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+//        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+//        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+//OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+//OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of
+//external contributions to this project including patches, pull requests, etc.
+
+#pragma once
+#include <Python.h>
+
+class gil_scoped_release {
+public:
+    explicit gil_scoped_release()  {
+        // `get_internals()` must be called here unconditionally in order to initialize
+        // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an
+        // initialization race could occur as multiple threads try `gil_scoped_acquire`.
+        tstate = PyEval_SaveThread();
+    }
+//
+//    gil_scoped_release(gil_scoped_release&& other) noexcept
+//        : tstate(other.tstate), active(other.active) {
+//        other.tstate = nullptr;
+//        other.active = false;
+//    }
+//
+//    gil_scoped_release& operator=(gil_scoped_release&& other) noexcept {
+//        tstate = other.tstate;
+//        other.tstate = nullptr;
+//        active = other.active;
+//        other.active = false;
+//        return *this;
+//    }
+
+    /// This method will disable the PyThreadState_DeleteCurrent call and the
+    /// GIL won't be acquired. This method should be used if the interpreter
+    /// could be shutting down when this is called, as thread deletion is not
+    /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
+    /// protect subsequent code.
+    void disarm() {
+        active = false;
+    }
+
+    ~gil_scoped_release() {
+        if (!tstate)
+            return;
+        // `PyEval_RestoreThread()` should not be called if runtime is finalizing
+        if (active)
+            PyEval_RestoreThread(tstate);
+    }
+private:
+    PyThreadState *tstate;
+    bool active = true;
+};

src/vtkPythonLoader.cxx

@@ -5,6 +5,7 @@
 #include "vtkPythonLoader.h"
 #include "vtkTileHierarchyNode.h"
 #include "vtkAttributedTileHierarchyNode.h"
+#include "gil.h"
 #include <vtkMapper.h>
 #include <vtkObjectFactory.h>
 #include <vtkCommand.h>
@@ -29,17 +30,10 @@ void vtkPythonLoader::FetchNode(vtkTileHierarchyNodePtr node) {
     Superclass::InvokeEvent(FetchNodeEvent, node);
 }
 
-//void vtkPythonLoader::DummyFetch() {
-//    vtkBoundingBox bounds(0, 1, 0, 1, 0,1);
-//    auto dummy_node = vtkAttributedTileHierarchyNodePtr::New();
-//    dummy_node->SetBoundingBox(bounds);
-//    dummy_node->SetSize(10);
-//    dummy_node->SetAttribute("name", "my_node_name");
-//    gil_scoped_release release; // release the Python GIL here so the thread can run!
-//    std::thread foo(&vtkPythonLoader::FetchNode, this, dummy_node);
-//    foo.join();
-//}
-
 void vtkPythonLoader::PrintSelf(ostream &os, vtkIndent indent) {
     Superclass::PrintSelf(os, indent);
+}
+
+std::unique_ptr<vtkTileHierarchyLoaderRenderState> vtkPythonLoader::PreRender() {
+    return std::make_unique<vtkTileHierarchyLoaderRenderStatePython>();
 }

src/vtkPythonLoader.h

@@ -10,6 +10,7 @@
 #include <memory>
 #include "vtkTileHierarchyLoader.h"
 #include "vtkTileHierarchyModule.h" // For export macro
+#include "gil.h"
 
 class vtkCommand;
 class vtkMapper;
@@ -18,6 +19,17 @@ class vtkBoundingBox;
 class vtkTileHierarchyNode;
 using vtkTileHierarchyNodePtr = vtkSmartPointer<vtkTileHierarchyNode>;
 
+
+class vtkTileHierarchyLoaderRenderStatePython: public vtkTileHierarchyLoaderRenderState {
+public:
+    vtkTileHierarchyLoaderRenderStatePython()
+            : release() { };
+    ~vtkTileHierarchyLoaderRenderStatePython() override {
+    };
+private:
+    gil_scoped_release release;
+};
+
 class VTKTILEHIERARCHY_EXPORT vtkPythonLoader: public vtkTileHierarchyLoader {
 public:
     static vtkPythonLoader* New();
@@ -27,7 +39,8 @@ class VTKTILEHIERARCHY_EXPORT vtkPythonLoader: public vtkTileHierarchyLoader {
     void Initialize() override;
     void FetchNode(vtkTileHierarchyNodePtr node) override;
 
-    //void DummyFetch();
+
+    VTK_WRAPEXCLUDE std::unique_ptr<vtkTileHierarchyLoaderRenderState> PreRender() override;
 
     vtkGetMacro(InitializeEvent, unsigned long);
     vtkGetMacro(FetchNodeEvent, unsigned long);

src/vtkTileHierarchyLoader.cxx

@@ -10,6 +10,7 @@
 #include <vtkMapper.h>
 #include <vtkDataSetMapper.h>
 
+
 std::size_t std::hash<vtkTileHierarchyNodePtr>::operator()(const vtkTileHierarchyNodePtr &s) const noexcept {
     return std::hash<vtkTileHierarchyNode *>{}(s.GetPointer());
 }
@@ -21,28 +22,13 @@ size_t vtkTileHierarchyLoader::TileTreeNodeSize::operator()(const vtkTileHierarc
 
 vtkTileHierarchyLoader::vtkTileHierarchyLoader()
     : RootNode(nullptr), Cache(15000000) {
-    //MapperTemplate->SetColorModeToMapScalars();
-    //MapperTemplate->SetScalarModeToUsePointData();
-    //MapperTemplate->SetStatic(true);
 
 }
 
-//void vtkTileHierarchyLoader::SetMapperTemplate(vtkMapper *mapper) {
-//    MapperTemplate.TakeReference(mapper);
-//}
-//
-//vtkMapper * vtkTileHierarchyLoader::GetMapperTemplate() {
-//    return MapperTemplate.Get();
-//}
-
 void vtkTileHierarchyLoader::PrintSelf(ostream &os, vtkIndent indent) {
     Superclass::PrintSelf(os, indent);
 }
 
-//bool vtkTileHierarchyLoader::IsCached(const vtkTileHierarchyNodePtr &node) const {
-//    return Cache.exist(node);
-//}
-
 vtkTileHierarchyNodePtr vtkTileHierarchyLoader::GetRootNode() {
     if(!RootNode) Initialize();
     return RootNode;
@@ -54,7 +40,6 @@ void vtkTileHierarchyLoader::SetRootNode(vtkTileHierarchyNode* root_node) {
 }
 
 vtkSmartPointer<vtkMapper> vtkTileHierarchyLoader::MakeMapper() const {
-    //auto mapper = vtkSmartPointer<vtkMapper>::NewInstance(MapperTemplate);
     auto mapper = vtkSmartPointer<vtkDataSetMapper>::New();
     assert(mapper->GetReferenceCount() == 1);
     mapper->SetStatic(true);
@@ -68,11 +53,8 @@ bool vtkTileHierarchyLoader::TryGetNodeFromCache(vtkTileHierarchyNodePtr &node)
         std::scoped_lock<std::mutex> node_lock{node->GetMutex()};
         node->Mapper = vtkSmartPointer(std::move(val.first));
         node->Size = val.second;
-        //Cache.erase(node); // Remove the node from cache as long as it is used by the mapper
-        //node_lock.unlock();
         return true;
     }
-    //if(node_lock) node_lock.unlock();
     return false;
 }
 
@@ -89,8 +71,6 @@ void vtkTileHierarchyLoader::LoadNode(vtkTileHierarchyNodePtr &node, bool recurs
     if(!node->IsLoaded()) {
         FetchNode(node);
     }
-    //if(!TryGetNodeFromCache(node) && !node->IsLoaded()) { // avoid loading nodes that are already in use or cached
-    //}
     // recursively load all nodes below as well
     if (recursive)
     {

src/vtkTileHierarchyLoader.h

@@ -10,6 +10,7 @@
 #include <vtkSmartPointer.h>
 #include <vtkObject.h>
 #include <memory>
+#include <any>
 #include "vtkTileHierarchyModule.h" // For export macro
 
 
@@ -26,6 +27,11 @@ class vtkMapper;
 
 class vtkTileHierarchyLoaderThread;
 
+struct vtkTileHierarchyLoaderRenderState {
+    vtkTileHierarchyLoaderRenderState() = default;
+    virtual ~vtkTileHierarchyLoaderRenderState() = default;
+};
+
 class VTKTILEHIERARCHY_EXPORT vtkTileHierarchyLoader: public vtkObject {
 public:
     vtkTypeMacro(vtkTileHierarchyLoader, vtkObject);
@@ -43,6 +49,13 @@ class VTKTILEHIERARCHY_EXPORT vtkTileHierarchyLoader: public vtkObject {
         UnloadNode(node, false);
     }
 
+    VTK_WRAPEXCLUDE virtual std::unique_ptr<vtkTileHierarchyLoaderRenderState> PreRender() {
+        return std::make_unique<vtkTileHierarchyLoaderRenderState>();
+    };
+
+    VTK_WRAPEXCLUDE virtual void PostRender(std::unique_ptr<vtkTileHierarchyLoaderRenderState> state) {
+    };
+
     VTK_WRAPEXCLUDE void UnloadNode(vtkTileHierarchyNodePtr& node, bool recursive);
 
     VTK_WRAPEXCLUDE virtual void FetchNode(vtkTileHierarchyNodePtr node) = 0;

src/vtkTileHierarchyMapper.cxx

@@ -16,14 +16,6 @@
 #include <vtkExecutive.h>
 #include <vtkRenderWindowInteractor.h>
 
-
-//bool is_different(const vtkMatrix4x4* first, const vtkMatrix4x4* second) {
-//    for (int i = 0; i < 4; ++i)
-//        for (int j = 0; j < 4; ++j)
-//            if (first->GetElement(i, j) != second->GetElement(i, j)) return true;
-//    return false;
-//}
-
 enum FrustumCull
 {
     INSIDE_FRUSTUM,
@@ -72,82 +64,6 @@ int intersect(vtkCamera* camera, const vtkBoundingBox& bbox, double aspect_ratio
     return result;
 }
 
-//class CheckVisibilityCallback: public vtkCallbackCommand {
-//public:
-//    static CheckVisibilityCallback* New();
-//    vtkTypeMacro(CheckVisibilityCallback, vtkCallbackCommand);
-//
-//    // Here we Create a vtkCallbackCommand and reimplement it.
-//    void Execute(vtkObject* caller, unsigned long evId, void*) override
-//    {
-//        std::cout << "Camera moved" << std::endl;
-//        // Note the use of reinterpret_cast to cast the caller to the expected type.
-//        auto camera = Mapper->Renderer->GetActiveCamera();//reinterpret_cast<vtkCamera*>(caller);
-//        vtkVector3d camera_position;
-//        camera->GetPosition(camera_position.GetData());
-//        vtkQuaterniond camera_orientation(camera->GetOrientationWXYZ());
-//        vtkSmartPointer<vtkMatrix4x4> projection_matrix;
-//        projection_matrix.TakeReference(camera->GetProjectionTransformMatrix(Mapper->Renderer));
-//
-//        vtkVector3d camera_position_difference;
-//        vtkMath::Subtract(camera_position.GetData(), LastPosition.GetData(), camera_position_difference.GetData());
-//        bool projection_different = true;
-//        if(LastProjection) {
-//            projection_different = is_different(projection_matrix, LastProjection);
-//        }
-//        if (!projection_different
-//            && camera_position_difference.Norm() < 0.01f
-//            && (camera_orientation - LastOrientation).Norm() < 0.01f)
-//            return;
-//        LastPosition = camera_position;
-//        LastOrientation = camera_orientation;
-//        LastProjection = projection_matrix;
-//        if(Mapper->Renderer)
-//            //std::cout << "Re-Rendering due to moved camera" << std::endl;
-//            Mapper->Renderer->GetRenderWindow()->Render(); // force a render
-//    }
-//    CheckVisibilityCallback(): Mapper(nullptr)
-//    {
-//    }
-//
-//    // Set pointers to any clientData or callData here.
-//    vtkTileHierarchyMapper* Mapper;
-//    vtkVector3d LastPosition;
-//    vtkQuaterniond LastOrientation;
-//    vtkSmartPointer<vtkMatrix4x4> LastProjection;
-//};
-//
-//class ReRenderCallback: public vtkCallbackCommand {
-//public:
-//    static ReRenderCallback* New();
-//    vtkTypeMacro(ReRenderCallback, vtkCallbackCommand);
-//
-//    // Here we Create a vtkCallbackCommand and reimplement it.
-//    void Execute(vtkObject* caller, unsigned long evId, void*) override
-//    {
-//        // Note the use of reinterpret_cast to cast the caller to the expected type.
-//        if (vtkCommand::TimerEvent == evId) {
-//            if(Mapper->ForceUpdate && Mapper->Renderer) {
-//                std::cout << "Re-rendering " << count++ << std::endl;
-//                Mapper->Renderer->GetRenderWindow()->Render(); // force a render
-//            }
-//        }
-//    }
-//    ReRenderCallback(): Mapper(nullptr)
-//    {
-//    }
-//
-//    // Set pointers to any clientData or callData here.
-//    vtkTileHierarchyMapper* Mapper;
-//    size_t count = 0;
-//};
-//
-//
-//vtkStandardNewMacro(CheckVisibilityCallback);
-//vtkStandardNewMacro(ReRenderCallback);
-
-
-
 vtkStandardNewMacro(vtkTileHierarchyMapper);
 
 vtkTileHierarchyMapper::vtkTileHierarchyMapper()
@@ -205,7 +121,7 @@ void vtkTileHierarchyMapper::OnNodeLoaded() {
 }
 
 void vtkTileHierarchyMapper::Render(vtkRenderer *ren, vtkActor *a) {
-    //std::cout << "Rendering" << std::endl;
+    auto loader_state = Loader->PreRender();
     ForceUpdate = false;
 
     if(ren->GetRenderWindow()->GetActualSize()[1] < 10) {
@@ -250,6 +166,7 @@ void vtkTileHierarchyMapper::Render(vtkRenderer *ren, vtkActor *a) {
 
         }
     }
+    Loader->PostRender(std::move(loader_state));
 }
 
 

src/vtkTileHierarchyNode.cxx

@@ -20,7 +20,7 @@ void vtkTileHierarchyNode::PrintSelf(ostream &os, vtkIndent indent) {
 }
 
 void vtkTileHierarchyNode::Render(vtkRenderer *ren, vtkActor *a) {
-    std::lock_guard<std::mutex> lock{Mutex};
+    //std::lock_guard<std::mutex> lock{Mutex};
     if(!Mapper) return;
 
     Mapper->Render(ren, a);
@@ -50,7 +50,7 @@ void vtkTileHierarchyNode::SetChild(vtkIdType idx, vtkTileHierarchyNode* child)
 
 void vtkTileHierarchyNode::ResetNode() {
     Mapper = nullptr;
-    Size = 0;
+    //Size = 0;
 }
 
 void vtkTileHierarchyNode::SetMapper(vtkMapper* mapper) {

vtk_tile_hierarchy/__init__.py

@@ -1,3 +1,4 @@
 from .vtkTileHierarchy import vtkPotreeLoader, vtkTileHierarchyLoader, vtkTileHierarchyNode, vtkAttributedTileHierarchyNode, vtkPointHierarchyNode, vtkTileHierarchyMapper
 from .python_hierarchy_loader import vtkPythonHierarchyLoader
-from .python_hierarchy_node import vtkTileHierarchyNodePython
+from .python_hierarchy_node import vtkTileHierarchyNodePython
+from .ept_loader import vtkEptLoader