Model.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2024, EPFL/Blue Brain Project
 *
 * The Blue Brain BioExplorer is a tool for scientists to extract and analyse
 * scientific data from visualization
 *
 * This file is part of Blue Brain BioExplorer <https://github.com/BlueBrain/BioExplorer>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <platform/core/common/Api.h>
#include <platform/core/common/BaseObject.h>
#include <platform/core/common/CommonTypes.h>
#include <platform/core/common/PropertyMap.h>
#include <platform/core/common/Transformation.h>
#include <platform/core/common/Types.h>
#include <platform/core/common/geometry/Cone.h>
#include <platform/core/common/geometry/Curve.h>
#include <platform/core/common/geometry/Cylinder.h>
#include <platform/core/common/geometry/SDFGeometry.h>
#include <platform/core/common/geometry/Sphere.h>
#include <platform/core/common/geometry/Streamline.h>
#include <platform/core/common/geometry/TriangleMesh.h>
#include <platform/core/common/transferFunction/TransferFunction.h>
 
#include <set>
 
SERIALIZATION_ACCESS(Model)
SERIALIZATION_ACCESS(ModelParams)
SERIALIZATION_ACCESS(ModelDescriptor)
SERIALIZATION_ACCESS(ModelInstance)
 
namespace core
{
struct SDFGeometryData
{
    std::vector<SDFGeometry> geometries;         // A vector of SDFGeometry objects
    std::map<size_t, uint64_ts> geometryIndices; // A map where the keys are size_t values that represent
                                                 // the indices of geometries vector. The map values are
                                                 // vectors of uint64_t values that represent the indices of
                                                 // vertices that belong to the geometry.
    std::vector<uint64_ts> neighbours;           // A vector of vectors of uint64_t values that represent the indices
                                                 // of neighbouring vertices for each  vertex.
    std::vector<uint64_t> neighboursFlat; // A vector of uint64_t values that represents the indices of neighbouring
                                          // vertices flattened into a single vector.
 
    void clear()
    {
        geometries.clear();
        geometryIndices.clear();
        neighbours.clear();
        neighboursFlat.clear();
    }
};
 
class ModelInstance : public BaseObject
{
public:
    PLATFORM_API ModelInstance() = default;
 
    PLATFORM_API ModelInstance(const bool visible, const bool boundingBox, const Transformation& transformation)
        : _visible(visible)
        , _boundingBox(boundingBox)
        , _transformation(transformation)
    {
    }
 
    PLATFORM_API bool getVisible() const { return _visible; }
 
    PLATFORM_API void setVisible(const bool visible) { _updateValue(_visible, visible); }
 
    PLATFORM_API bool getBoundingBox() const { return _boundingBox; }
 
    PLATFORM_API void setBoundingBox(const bool enabled) { _updateValue(_boundingBox, enabled); }
 
    PLATFORM_API const Transformation& getTransformation() const { return _transformation; }
 
    PLATFORM_API void setTransformation(const Transformation& transformation)
    {
        _updateValue(_transformation, transformation);
    }
 
    PLATFORM_API void setModelID(const size_t id) { _updateValue(_modelID, id); }
 
    PLATFORM_API size_t getModelID() const { return _modelID; }
 
    PLATFORM_API void setInstanceID(const size_t id) { _updateValue(_instanceID, id); }
 
    PLATFORM_API size_t getInstanceID() const { return _instanceID; }
 
protected:
    size_t _modelID{0};             // A size_t representing the ID of the model
    size_t _instanceID{0};          // A size_t representing the ID of the instance
    bool _visible{true};            // A boolean indicating if the model instance is visible
    bool _boundingBox{false};       // A boolean indicating if the model instance has a bounding box
    Transformation _transformation; // A Transformation object representing the model's transformation
 
    SERIALIZATION_FRIEND(ModelInstance)
};
 
class ModelParams : public ModelInstance
{
public:
    /* Default constructor */
    PLATFORM_API ModelParams() = default;
 
    PLATFORM_API ModelParams(const std::string& path);
 
    PLATFORM_API ModelParams(const std::string& name, const std::string& path);
 
    PLATFORM_API ModelParams(const std::string& name, const std::string& path, const PropertyMap& loaderProperties);
 
    PLATFORM_API ModelParams(ModelParams&& rhs) = default;
 
    PLATFORM_API ModelParams& operator=(ModelParams&& rhs) = default;
 
    PLATFORM_API ModelParams(const ModelParams& rhs) = default;
 
    PLATFORM_API ModelParams& operator=(const ModelParams& rhs) = default;
 
    PLATFORM_API void setName(const std::string& name) { _updateValue(_name, name); }
 
    PLATFORM_API const std::string& getName() const { return _name; }
 
    PLATFORM_API void setPath(const std::string& path) { _updateValue(_path, path); }
 
    PLATFORM_API const std::string& getPath() const { return _path; }
 
    PLATFORM_API void setLoaderName(const std::string& loaderName) { _updateValue(_loaderName, loaderName); }
 
    PLATFORM_API const std::string& getLoaderName() const { return _loaderName; }
 
    PLATFORM_API const PropertyMap& getLoaderProperties() const { return _loaderProperties; }
 
    PLATFORM_API void setLoaderProperties(const PropertyMap& pm) { _loaderProperties = pm; }
 
protected:
    std::string _name;             // name of the model
    std::string _path;             // path of the model
    std::string _loaderName;       // loader name of the model
    PropertyMap _loaderProperties; // loader properties of the model
 
    SERIALIZATION_FRIEND(ModelParams)
};
 
class ModelDescriptor : public ModelParams
{
public:
    ModelDescriptor() = default;
 
    ModelDescriptor(ModelDescriptor&& rhs) = default;
 
    ModelDescriptor& operator=(ModelDescriptor&& rhs) = default;
 
    ModelDescriptor(ModelPtr model, const std::string& path);
 
    ModelDescriptor(ModelPtr model, const std::string& path, const ModelMetadata& metadata);
 
    ModelDescriptor(ModelPtr model, const std::string& name, const std::string& path, const ModelMetadata& metadata);
 
    ModelDescriptor& operator=(const ModelParams& rhs);
 
    bool getEnabled() const { return _visible || _boundingBox; }
 
    void setMetadata(const ModelMetadata& metadata)
    {
        _metadata = metadata;
        markModified();
    }
 
    const ModelMetadata& getMetadata() const { return _metadata; }
 
    const Model& getModel() const { return *_model; }
 
    Model& getModel() { return *_model; }
 
    void addInstance(const ModelInstance& instance);
 
    void removeInstance(const size_t id);
 
    void clearInstances();
 
    ModelInstance* getInstance(const size_t id);
 
    const ModelInstances& getInstances() const { return _instances; }
 
    Boxd getBounds() const { return _bounds; }
 
    void computeBounds();
 
    void setProperties(const PropertyMap& properties)
    {
        _properties = properties;
        markModified();
    }
 
    const PropertyMap& getProperties() const { return _properties; }
 
    using RemovedCallback = std::function<void(const ModelDescriptor&)>;
    void onRemoved(const RemovedCallback& callback) { _onRemovedCallback = callback; }
 
    void callOnRemoved()
    {
        if (_onRemovedCallback)
            _onRemovedCallback(*this);
    }
 
    void markForRemoval() { _markedForRemoval = true; }
 
    bool isMarkedForRemoval() const { return _markedForRemoval; }
 
    ModelDescriptorPtr clone(ModelPtr model) const;
 
private:
    size_t _nextInstanceID{0};
    Boxd _bounds;
    ModelMetadata _metadata;
    ModelPtr _model;
    ModelInstances _instances;
    PropertyMap _properties;
    RemovedCallback _onRemovedCallback;
    bool _markedForRemoval = false;
 
    SERIALIZATION_FRIEND(ModelDescriptor)
};
 
class Model
{
public:
    PLATFORM_API Model(AnimationParameters& animationParameters, VolumeParameters& volumeParameters,
                       GeometryParameters& geometryParameters, FieldParameters& fieldParameters);
 
    PLATFORM_API virtual ~Model();
 
    PLATFORM_API virtual void commitGeometry() = 0;
 
    PLATFORM_API bool commitTransferFunction();
 
    PLATFORM_API bool commitSimulationData();
 
    PLATFORM_API MaterialPtr createMaterial(const size_t materialId, const std::string& name,
                                            const PropertyMap& properties = {});
 
    PLATFORM_API virtual SharedDataVolumePtr createSharedDataVolume(const Vector3ui& dimensions,
                                                                    const Vector3f& spacing, const DataType type) = 0;
 
    PLATFORM_API virtual BrickedVolumePtr createBrickedVolume(const Vector3ui& dimensions, const Vector3f& spacing,
                                                              const DataType type) = 0;
 
    PLATFORM_API virtual FieldPtr createField(const Vector3ui& dimensions, const Vector3f& spacing,
                                              const Vector3f& offset, const uint32_ts& indices, const floats& values,
                                              const OctreeDataType dataType) = 0;
 
    PLATFORM_API virtual void buildBoundingBox() = 0;
 
    PLATFORM_API bool empty() const;
 
    PLATFORM_API bool isDirty() const;
 
    PLATFORM_API const Boxd& getBounds() const { return _bounds; }
 
    void mergeBounds(const Boxd& bounds) { _bounds.merge(bounds); }
 
    PLATFORM_API const SpheresMap& getSpheres() const { return _geometries->_spheres; }
    PLATFORM_API SpheresMap& getSpheres()
    {
        _spheresDirty = true;
        return _geometries->_spheres;
    }
 
    PLATFORM_API uint64_t addSphere(const size_t materialId, const Sphere& sphere);
 
    PLATFORM_API const CylindersMap& getCylinders() const { return _geometries->_cylinders; }
    PLATFORM_API CylindersMap& getCylinders()
    {
        _cylindersDirty = true;
        return _geometries->_cylinders;
    }
 
    PLATFORM_API uint64_t addCylinder(const size_t materialId, const Cylinder& cylinder);
 
    PLATFORM_API const ConesMap& getCones() const { return _geometries->_cones; }
    PLATFORM_API ConesMap& getCones()
    {
        _conesDirty = true;
        return _geometries->_cones;
    }
 
    PLATFORM_API uint64_t addCone(const size_t materialId, const Cone& cone);
 
    PLATFORM_API void addStreamline(const size_t materialId, const Streamline& streamline);
 
    PLATFORM_API const StreamlinesDataMap& getStreamlines() const { return _geometries->_streamlines; }
    PLATFORM_API StreamlinesDataMap& getStreamlines()
    {
        _streamlinesDirty = true;
        return _geometries->_streamlines;
    }
 
    PLATFORM_API void addCurve(const size_t materialId, const Curve& curve);
 
    PLATFORM_API const CurvesMap& getCurves() const { return _geometries->_curves; }
    PLATFORM_API CurvesMap& getCurves()
    {
        _curvesDirty = true;
        return _geometries->_curves;
    }
 
    PLATFORM_API uint64_t addSDFGeometry(const size_t materialId, const SDFGeometry& geom,
                                         const uint64_ts& neighbourIndices);
 
    PLATFORM_API const SDFGeometryData& getSDFGeometryData() const { return _geometries->_sdf; }
    PLATFORM_API SDFGeometryData& getSDFGeometryData()
    {
        _sdfGeometriesDirty = true;
        return _geometries->_sdf;
    }
 
    PLATFORM_API void updateSDFGeometryNeighbours(size_t geometryIdx, const uint64_ts& neighbourIndices);
 
    PLATFORM_API const TriangleMeshMap& getTriangleMeshes() const { return _geometries->_triangleMeshes; }
    PLATFORM_API TriangleMeshMap& getTriangleMeshes()
    {
        _triangleMeshesDirty = true;
        return _geometries->_triangleMeshes;
    }
 
    PLATFORM_API void addVolume(const size_t materialId, VolumePtr);
 
    PLATFORM_API void addField(const size_t materialId, FieldPtr);
 
    PLATFORM_API void removeVolume(const size_t materialId);
 
    PLATFORM_API void logInformation();
 
    PLATFORM_API void setMaterialsColorMap(const MaterialsColorMap colorMap);
 
    PLATFORM_API const MaterialMap& getMaterials() const { return _materials; }
 
    PLATFORM_API MaterialPtr getMaterial(const size_t materialId) const;
 
    PLATFORM_API TransferFunction& getTransferFunction() { return _transferFunction; }
    PLATFORM_API const TransferFunction& getTransferFunction() const { return _transferFunction; }
 
    PLATFORM_API AbstractSimulationHandlerPtr getSimulationHandler() const;
 
    PLATFORM_API void setSimulationHandler(AbstractSimulationHandlerPtr handler);
 
    PLATFORM_API size_t getSizeInBytes() const;
 
    PLATFORM_API void markInstancesDirty() { _instancesDirty = true; }
 
    PLATFORM_API void markInstancesClean() { _instancesDirty = false; }
 
    PLATFORM_API const VolumesMap& getVolumes() const { return _geometries->_volumes; }
 
    PLATFORM_API bool isVolumesDirty() const { return _volumesDirty; }
 
    PLATFORM_API void resetVolumesDirty() { _volumesDirty = false; }
 
    PLATFORM_API void setBVHFlags(std::set<BVHFlag> bvhFlags) { _bvhFlags = std::move(bvhFlags); }
 
    PLATFORM_API const std::set<BVHFlag>& getBVHFlags() const { return _bvhFlags; }
 
    PLATFORM_API void updateBounds();
 
    PLATFORM_API void copyFrom(const Model& rhs);
 
    PLATFORM_API void applyDefaultColormap();
 
protected:
    void _updateSizeInBytes();
 
    PLATFORM_API virtual MaterialPtr createMaterialImpl(const PropertyMap& properties = {}) = 0;
 
    void _markGeometriesClean();
 
    virtual void _commitTransferFunctionImpl(const Vector3fs& colors, const floats& opacities,
                                             const Vector2d valueRange) = 0;
    virtual void _commitSimulationDataImpl(const float* frameData, const size_t frameSize) = 0;
 
    AnimationParameters& _animationParameters;
    VolumeParameters& _volumeParameters;
    GeometryParameters& _geometryParameters;
    FieldParameters& _fieldParameters;
 
    AbstractSimulationHandlerPtr _simulationHandler;
    TransferFunction _transferFunction;
 
    MaterialMap _materials;
 
    struct Geometries
    {
        SpheresMap _spheres;
        CylindersMap _cylinders;
        ConesMap _cones;
        TriangleMeshMap _triangleMeshes;
        StreamlinesDataMap _streamlines;
        SDFGeometryData _sdf;
        VolumesMap _volumes;
        CurvesMap _curves;
        FieldsMap _fields;
 
        Boxd _sphereBounds;
        Boxd _cylindersBounds;
        Boxd _conesBounds;
        Boxd _triangleMeshesBounds;
        Boxd _streamlinesBounds;
        Boxd _sdfGeometriesBounds;
        Boxd _volumesBounds;
        Boxd _curvesBounds;
        Boxd _fieldsBounds;
 
        bool isEmpty() const
        {
            return _spheres.empty() && _cylinders.empty() && _cones.empty() && _triangleMeshes.empty() &&
                   _sdf.geometries.empty() && _streamlines.empty() && _volumes.empty() && _curves.empty();
        }
    };
 
    // the model clone actually shares all geometries to save memory. It will
    // still create engine specific copies though (BVH only ideally) as part of
    // commitGeometry()
    std::shared_ptr<Geometries> _geometries{std::make_shared<Geometries>()};
 
    bool _spheresDirty{false};
    bool _cylindersDirty{false};
    bool _conesDirty{false};
    bool _triangleMeshesDirty{false};
    bool _streamlinesDirty{false};
    bool _sdfGeometriesDirty{false};
    bool _volumesDirty{false};
    bool _curvesDirty{false};
    bool _fieldsDirty{false};
 
    bool _areGeometriesDirty() const
    {
        return _spheresDirty || _cylindersDirty || _conesDirty || _triangleMeshesDirty || _sdfGeometriesDirty ||
               _curvesDirty || _fieldsDirty;
    }
 
    Boxd _bounds;
    bool _instancesDirty{true};
    std::set<BVHFlag> _bvhFlags;
    size_t _sizeInBytes{0};
 
    // Whether this model has set the AnimationParameters "is ready" callback
    bool _isReadyCallbackSet{false};
 
    SERIALIZATION_FRIEND(Model)
};
} // namespace core