Merge pull request #338 from favreau/master

Added API for torus and vesical geometry objects

bioexplorer/backend/science/BioExplorerPlugin.cpp

@@ -581,6 +581,18 @@ void BioExplorerPlugin::init()
         endPoint = PLUGIN_API_PREFIX + "add-sdf-demo";
         PLUGIN_INFO(1, "Registering '" + endPoint + "' endpoint");
         actionInterface->registerRequest<Response>(endPoint, [&]() { return _addSdfDemo(); });
+
+        endPoint = PLUGIN_API_PREFIX + "add-torus";
+        PLUGIN_REGISTER_ENDPOINT(endPoint);
+        _api->getActionInterface()->registerRequest<SDFTorusDetails, Response>(endPoint,
+                                                                               [&](const SDFTorusDetails &payload)
+                                                                               { return _addTorus(payload); });
+
+        endPoint = PLUGIN_API_PREFIX + "add-vesica";
+        PLUGIN_REGISTER_ENDPOINT(endPoint);
+        _api->getActionInterface()->registerRequest<SDFVesicaDetails, Response>(endPoint,
+                                                                                [&](const SDFVesicaDetails &payload)
+                                                                                { return _addVesica(payload); });
     }
 
     auto &params = engine.getParametersManager().getApplicationParameters();
@@ -2147,6 +2159,46 @@ Response BioExplorerPlugin::_setSpikeReportVisualizationSettings(const SpikeRepo
     return response;
 }
 
+Response BioExplorerPlugin::_addTorus(const details::SDFTorusDetails &payload)
+{
+    Response response;
+    try
+    {
+        auto &scene = _api->getScene();
+        auto model = scene.createModel();
+        ThreadSafeContainer modelContainer(*model, 0.f, Vector3d(), Quaterniond());
+        const size_t materialId = 0;
+        const auto position = doublesToVector3d(payload.position);
+        const auto displacement = doublesToVector3d(payload.displacement);
+        modelContainer.addTorus(position, payload.outerRadius, payload.innerRadius, materialId, NO_USER_DATA, {},
+                                displacement);
+        modelContainer.commitToModel();
+        scene.addModel(std::make_shared<ModelDescriptor>(std::move(model), payload.name));
+    }
+    CATCH_STD_EXCEPTION()
+    return response;
+}
+
+Response BioExplorerPlugin::_addVesica(const details::SDFVesicaDetails &payload)
+{
+    Response response;
+    try
+    {
+        auto &scene = _api->getScene();
+        auto model = scene.createModel();
+        ThreadSafeContainer modelContainer(*model, 0.f, Vector3d(), Quaterniond());
+        const size_t materialId = 0;
+        const auto source = doublesToVector3d(payload.srcPosition);
+        const auto target = doublesToVector3d(payload.dstPosition);
+        const auto displacement = doublesToVector3d(payload.displacement);
+        modelContainer.addVesica(source, target, payload.radius, materialId, NO_USER_DATA, {}, displacement);
+        modelContainer.commitToModel();
+        scene.addModel(std::make_shared<ModelDescriptor>(std::move(model), payload.name));
+    }
+    CATCH_STD_EXCEPTION()
+    return response;
+}
+
 extern "C" ExtensionPlugin *core_plugin_create(int argc, char **argv)
 {
     PLUGIN_INFO(1, " _|_|_|    _|            _|_|_|_|                      _|                                        ");

bioexplorer/backend/science/BioExplorerPlugin.h

@@ -168,6 +168,10 @@ class BioExplorerPlugin : public core::ExtensionPlugin
     details::LookAtResponseDetails _lookAt(const details::LookAtDetails &payload);
     details::Response _addSdfDemo();
 
+    // SDF Geometries
+    details::Response _addTorus(const details::SDFTorusDetails &payload);
+    details::Response _addVesica(const details::SDFVesicaDetails &payload);
+
     // Attributes
     common::AssemblyMap _assemblies;
 

bioexplorer/backend/science/api/Params.cpp

@@ -1155,4 +1155,41 @@ bool from_json(SpikeReportVisualizationSettingsDetails &param, const std::string
     }
     return true;
 }
+
+bool from_json(bioexplorer::details::SDFTorusDetails &param, const std::string &payload)
+{
+    try
+    {
+        auto js = nlohmann::json::parse(payload);
+        FROM_JSON(param, js, name);
+        FROM_JSON(param, js, position);
+        FROM_JSON(param, js, outerRadius);
+        FROM_JSON(param, js, innerRadius);
+        FROM_JSON(param, js, displacement);
+    }
+    catch (...)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool from_json(bioexplorer::details::SDFVesicaDetails &param, const std::string &payload)
+{
+    try
+    {
+        auto js = nlohmann::json::parse(payload);
+        FROM_JSON(param, js, name);
+        FROM_JSON(param, js, srcPosition);
+        FROM_JSON(param, js, dstPosition);
+        FROM_JSON(param, js, radius);
+        FROM_JSON(param, js, displacement);
+    }
+    catch (...)
+    {
+        return false;
+    }
+    return true;
+}
+
 #endif

bioexplorer/backend/science/api/Params.h

@@ -122,6 +122,10 @@ bool from_json(bioexplorer::details::SynapsesDetails &param, const std::string &
 bool from_json(bioexplorer::details::SynapseEfficacyDetails &param, const std::string &payload);
 bool from_json(bioexplorer::details::SpikeReportVisualizationSettingsDetails &param, const std::string &payload);
 
+// Extra geometry
+bool from_json(bioexplorer::details::SDFTorusDetails &param, const std::string &payload);
+bool from_json(bioexplorer::details::SDFVesicaDetails &param, const std::string &payload);
+
 // Utilities
 bool from_json(bioexplorer::details::LookAtDetails &param, const std::string &payload);
 std::string to_json(const bioexplorer::details::LookAtResponseDetails &param);

bioexplorer/backend/science/common/ThreadSafeContainer.h

@@ -29,9 +29,6 @@ namespace bioexplorer
 {
 namespace common
 {
-using MaterialSet = std::set<size_t>;
-using Neighbours = std::set<size_t>;
-
 /**
  * @brief The ThreadSafeContainer class is used to load large datasets in
  * parallel. Every individual element is loaded in a separate thread and

bioexplorer/backend/science/common/Types.h

@@ -77,6 +77,9 @@ const double NO_GRID_ALIGNMENT = 0.0;
 
 namespace common
 {
+using MaterialSet = std::set<size_t>;
+using Neighbours = std::set<size_t>;
+
 class Node;
 using NodePtr = std::shared_ptr<Node>;
 using NodeMap = std::map<std::string, NodePtr>;
@@ -1669,5 +1672,23 @@ typedef struct
     double frequency{1.0};
 } CellAnimationDetails;
 
+typedef struct
+{
+    std::string name;
+    doubles position;
+    double outerRadius;
+    double innerRadius;
+    doubles displacement;
+} SDFTorusDetails;
+
+typedef struct
+{
+    std::string name;
+    doubles srcPosition;
+    doubles dstPosition;
+    double radius;
+    doubles displacement;
+} SDFVesicaDetails;
+
 } // namespace details
 } // namespace bioexplorer

bioexplorer/backend/science/morphologies/Neurons.cpp

@@ -642,7 +642,7 @@ void Neurons::_buildMorphology(ThreadSafeContainer& container, const uint64_t ne
         if (distanceToSoma <= _details.maxDistanceToSoma)
             _addSection(container, neuronId, soma.morphologyId, section.first, section.second, geometryIndex,
                         somaPosition, somaRotation, somaRadius, baseMaterialId, mitochondriaDensity, somaUserData,
-                        synapses, distanceToSoma);
+                        synapses, distanceToSoma, neighbours);
     }
 } // namespace morphology
 
@@ -730,7 +730,8 @@ void Neurons::_addSection(ThreadSafeContainer& container, const uint64_t neuronI
                           const uint64_t sectionId, const Section& section, const uint64_t somaGeometryIndex,
                           const Vector3d& somaPosition, const Quaterniond& somaRotation, const double somaRadius,
                           const size_t baseMaterialId, const double mitochondriaDensity, const uint64_t somaUserData,
-                          const SectionSynapseMap& synapses, const double distanceToSoma)
+                          const SectionSynapseMap& synapses, const double distanceToSoma,
+                          const Neighbours& somaNeighbours)
 {
     const auto& connector = DBConnector::getInstance();
     const auto sectionType = static_cast<NeuronSectionType>(section.type);
@@ -778,7 +779,7 @@ void Neurons::_addSection(ThreadSafeContainer& container, const uint64_t neuronI
     double sectionLength = 0.0;
     double sectionVolume = 0.0;
     uint64_t geometryIndex = 0;
-    Neighbours neighbours;
+    Neighbours neighbours = somaNeighbours;
     if (_details.morphologyColorScheme == MorphologyColorScheme::none)
         neighbours.insert(somaGeometryIndex);
 

bioexplorer/backend/science/morphologies/Neurons.h

@@ -96,7 +96,8 @@ class Neurons : public Morphologies
                      const uint64_t sectionId, const Section& section, const uint64_t somaGeometryIndex,
                      const core::Vector3d& somaPosition, const core::Quaterniond& somaRotation, const double somaRadius,
                      const size_t baseMaterialId, const double mitochondriaDensity, const uint64_t somaUserData,
-                     const SectionSynapseMap& synapses, const double distanceToSoma);
+                     const SectionSynapseMap& synapses, const double distanceToSoma,
+                     const common::Neighbours& somaNeighbours);
 
     void _addSpine(common::ThreadSafeContainer& container, const uint64_t neuronId, const uint64_t morphologyId,
                    const uint64_t sectionId, const Synapse& synapse, const size_t baseMaterialId,

bioexplorer/pythonsdk/bioexplorer/bio_explorer.py

@@ -3040,6 +3040,52 @@ def add_sdf_demo(self):
 
         return self._invoke_and_check("add-sdf-demo")
 
+    def add_torus(self, name, position, outer_radius, inner_radius, displacement_parameters=Vector3()):
+        """
+        Add a torus to the scene
+
+        :return: Result of the request submission
+        """
+        if self._client is None:
+            return
+
+        assert isinstance(name, str)
+        assert isinstance(position, Vector3)
+        assert isinstance(outer_radius, float)
+        assert isinstance(inner_radius, float)
+        assert isinstance(displacement_parameters, Vector3)
+
+        params = dict()
+        params["name"] = name
+        params["position"] = position.to_list()
+        params["outerRadius"] = outer_radius
+        params["innerRadius"] = inner_radius
+        params["displacement"] = displacement_parameters.to_list()
+        return self._invoke_and_check("add-torus", params)
+
+    def add_vesica(self, name, source_position, target_position, radius, displacement_parameters=Vector3()):
+        """
+        Add a vesica to the scene
+
+        :return: Result of the request submission
+        """
+        if self._client is None:
+            return
+
+        assert isinstance(name, str)
+        assert isinstance(source_position, Vector3)
+        assert isinstance(target_position, Vector3)
+        assert isinstance(radius, float)
+        assert isinstance(displacement_parameters, Vector3)
+
+        params = dict()
+        params["name"] = name
+        params["srcPosition"] = source_position.to_list()
+        params["dstPosition"] = target_position.to_list()
+        params["radius"] = radius
+        params["displacement"] = displacement_parameters.to_list()
+        return self._invoke_and_check("add-vesica", params)
+
     def add_streamlines(self, name, indices, vertices, colors):
         """
         Add streamlines to the scene