Types.h

Go to the documentation of this file.

/*
 *
 * 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>
 *
 * Copyright 2020-2024 Blue BrainProject / EPFL
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program 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 General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <Defines.h>
 
#include <platform/core/common/geometry/SDFGeometry.h>
#include <platform/core/engineapi/Scene.h>
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
namespace bioexplorer
{
const std::string CONTENTS_DELIMITER = "||||";
 
// Metadata
const std::string METADATA_ASSEMBLY = "Assembly";
const std::string METADATA_PDB_ID = "PDBId";
const std::string METADATA_HEADER = "Header";
const std::string METADATA_ATOMS = "Atoms";
const std::string METADATA_BONDS = "Bonds";
const std::string METADATA_SIZE = "Size";
const std::string METADATA_BRICK_ID = "BrickId";
 
// Command line arguments
// - Database
const std::string ARG_DB_HOST = "--db-host";
const std::string ARG_DB_PORT = "--db-port";
const std::string ARG_DB_NAME = "--db-name";
const std::string ARG_DB_USER = "--db-user";
const std::string ARG_DB_PASSWORD = "--db-password";
const std::string ARG_DB_NB_CONNECTIONS = "--db-nb-connections";
const std::string ARG_DB_BATCH_SIZE = "--db-batch-size";
const size_t DEFAULT_DB_NB_CONNECTIONS = 8;
const size_t DEFAULT_BATCH_SIZE = 1000; // Max number of records returned by a batch query
 
// - Out-of-core
const std::string ARG_OOC_ENABLED = "--ooc-enabled";
const std::string ARG_OOC_VISIBLE_BRICKS = "--ooc-visible-bricks";
const std::string ARG_OOC_UPDATE_FREQUENCY = "--ooc-update-frequency";
const std::string ARG_OOC_UNLOAD_BRICKS = "--ooc-unload-bricks";
const std::string ARG_OOC_SHOW_GRID = "--ooc-show-grid";
const std::string ARG_OOC_NB_BRICKS_PER_CYCLE = "--ooc-nb-bricks-per-cycle";
 
// Environment variables
const std::string ENV_ROCKETS_DISABLE_SCENE_BROADCASTING = "ROCKETS_DISABLE_SCENE_BROADCASTING";
 
// Bezier curves parameters
const size_t DEFAULT_BEZIER_STEP = 4;
 
// Grid geometry alignment
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>;
 
class Assembly;
using AssemblyPtr = std::shared_ptr<Assembly>;
using AssemblyMap = std::map<std::string, AssemblyPtr>;
 
enum class AssemblyConstraintType
{
    inside = 0,
    outside = 1
};
using AssemblyConstraint = std::pair<AssemblyConstraintType, AssemblyPtr>;
using AssemblyConstraints = std::vector<AssemblyConstraint>;
 
typedef struct
{
    core::Vector3d position;
    double radius;
    uint64_t sectionId{0};
    uint64_t graphId{0};
    uint64_t type{0};
    uint64_t pairId{0};
    uint64_t entryNodeId{0};
    uint64_t regionId{0};
} GeometryNode;
using GeometryNodes = std::map<uint64_t, GeometryNode>;
using GeometryEdges = std::map<uint64_t, uint64_t>;
using Bifurcations = std::map<uint64_t, uint64_ts>;
 
// Thread safe container
class ThreadSafeContainer;
using ThreadSafeContainers = std::vector<ThreadSafeContainer>;
 
// SDF structures
class SDFGeometries;
using SDFGeometriesPtr = std::shared_ptr<SDFGeometries>;
 
struct SDFMorphologyData
{
    std::vector<core::SDFGeometry> geometries;
    std::vector<std::set<size_t>> neighbours;
    size_ts materials;
    size_ts localToGlobalIdx;
    size_ts bifurcationIndices;
    std::unordered_map<size_t, int> geometrySection;
    std::unordered_map<int, size_ts> sectionGeometries;
};
 
enum class ReportType
{
    undefined = 0,
    spike = 1,
    soma = 2,
    compartment = 3,
    synapse_efficacy = 4
};
 
typedef struct
{
    ReportType type{ReportType::undefined};
    std::string description;
    double startTime;
    double endTime;
    double timeStep;
    std::string timeUnits;
    std::string dataUnits;
    bool debugMode{false};
    uint64_tm guids;
} SimulationReport;
 
enum class XYZFileFormat
{
    unspecified = 0,
    xyz_binary = 1,
    xyzr_binary = 2,
    xyzrv_binary = 3,
    xyz_ascii = 4,
    xyzr_ascii = 5,
    xyzrv_ascii = 6
};
} // namespace common
 
namespace molecularsystems
{
using ModelDescriptors = std::vector<core::ModelDescriptorPtr>;
 
class Membrane;
using MembranePtr = std::shared_ptr<Membrane>;
 
class Protein;
using ProteinPtr = std::shared_ptr<Protein>;
using ProteinMap = std::map<std::string, ProteinPtr>;
using Proteins = std::vector<ProteinPtr>;
 
class Glycans;
using GlycansPtr = std::shared_ptr<Glycans>;
using GlycansMap = std::map<std::string, GlycansPtr>;
 
class RNASequence;
using RNASequencePtr = std::shared_ptr<RNASequence>;
using RNASequenceMap = std::map<std::string, RNASequencePtr>;
 
class EnzymeReaction;
using EnzymeReactionPtr = std::shared_ptr<EnzymeReaction>;
using EnzymeReactionMap = std::map<std::string, EnzymeReactionPtr>;
 
enum class ProteinRepresentation
{
    atoms = 0,
    atoms_and_sticks = 1,
    contour = 2,
    surface = 3,
    union_of_balls = 4,
    debug = 5,
    mesh = 6
};
 
typedef struct
{
    std::string name;
    std::string altLoc;
    std::string resName;
    std::string chainId;
    size_t reqSeq;
    std::string iCode;
    core::Vector3d position;
    double occupancy;
    double tempFactor;
    std::string element;
    std::string charge;
    double radius;
} Atom;
using AtomMap = std::multimap<size_t, Atom, std::less<size_t>>;
 
typedef struct
{
    size_t numRes;
    strings resNames;
    size_t offset;
} ResidueSequence;
using ResidueSequenceMap = std::map<std::string, ResidueSequence>;
 
using BondsMap = std::map<size_t, size_ts>;
 
typedef struct
{
    std::string name;
    std::string shortName;
} AminoAcid;
using AminoAcidMap = std::map<std::string, AminoAcid>;
 
using Residues = std::set<std::string>;
 
using AtomicRadii = std::map<std::string, double>;
 
} // namespace molecularsystems
 
namespace atlas
{
class Atlas;
using AtlasPtr = std::shared_ptr<Atlas>;
} // namespace atlas
 
namespace vasculature
{
class Vasculature;
using VasculaturePtr = std::shared_ptr<Vasculature>;
} // namespace vasculature
 
namespace morphology
{
class Morphologies;
using MorphologiesPtr = std::shared_ptr<Morphologies>;
 
class Astrocytes;
using AstrocytesPtr = std::shared_ptr<Astrocytes>;
class Neurons;
using NeuronsPtr = std::shared_ptr<Neurons>;
class Synapses;
using SynapsesPtr = std::shared_ptr<Synapses>;
 
enum class MorphologySynapseType
{
    none = 0,
    afferent = 1,
    efferent = 2,
    debug = 4,
    all = 8
};
 
typedef struct
{
    MorphologySynapseType type;
    uint64_t postSynapticNeuronId;
    uint64_t postSynapticSectionId;
    uint64_t postSynapticSegmentId;
    double preSynapticSegmentDistance;
    double postSynapticSegmentDistance;
    core::Vector3d preSynapticSurfacePosition;
    core::Vector3d postSynapticSurfacePosition;
} Synapse;
using SynapsesMap = std::map<uint64_t, Synapse>;
using SegmentSynapseMap = std::map<uint64_t, std::vector<Synapse>>;
using SectionSynapseMap = std::map<uint64_t, SegmentSynapseMap>;
 
typedef struct
{
    core::Vector3d center;
    double radius;
    uint64_ts children;
} AstrocyteSoma;
using AstrocyteSomaMap = std::map<uint64_t, AstrocyteSoma>;
 
typedef struct
{
    core::Vector3d position;
    core::Quaterniond rotation;
    uint64_t eType{0};
    uint64_t mType{0};
    uint64_t layer{0};
    uint64_t morphologyId{0};
} NeuronSoma;
using NeuronSomaMap = std::map<uint64_t, NeuronSoma>;
 
typedef struct
{
    core::Vector4fs points;
    size_t type;
    int64_t parentId;
    double length;
} Section;
using SectionMap = std::map<uint64_t, Section>;
 
typedef struct
{
    uint64_t vasculatureSectionId;
    uint64_t vasculatureSegmentId;
    double length;
    double radius;
    core::Vector4fs nodes;
} EndFoot;
using EndFootMap = std::map<uint64_t, EndFoot>;
 
typedef struct
{
    core::Vector3d position;
    core::Quaterniond rotation;
    uint64_t type{0};
    int64_t eType{0};
    uint64_t region{0};
} Cell;
using CellMap = std::map<uint64_t, Cell>;
 
const double mitochondrionSegmentSize = 0.25;
const double mitochondrionRadius = 0.1;
 
const double spineRadiusRatio = 0.5;
 
const double myelinSteathLength = 10.0;
const double myelinSteathRadiusRatio = 3.0;
 
const uint64_t nbMinSegmentsForVaricosity = 10;
 
enum class PopulationColorScheme
{
    none = 0,
    id = 1
};
 
enum class MorphologyColorScheme
{
    none = 0,
    section_type = 1,
    section_orientation = 2,
    distance_to_soma = 3
};
 
enum class MorphologyRepresentation
{
    graph = 0,
    section = 1,
    segment = 2,
    orientation = 3,
    bezier = 4,
    contour = 5,
    surface = 6
};
 
enum class MorphologyRealismLevel
{
    none = 0,
    soma = 1,
    axon = 2,
    dendrite = 4,
    internals = 8,
    externals = 16,
    spine = 32,
    end_foot = 64,
    all = 255,
};
 
enum class MicroDomainRepresentation
{
    mesh = 0,
    convex_hull = 1,
    surface = 2
};
using SpikesMap = std::map<uint64_t, float>;
} // namespace morphology
 
namespace connectomics
{
class WhiteMatter;
using WhiteMatterPtr = std::shared_ptr<WhiteMatter>;
using WhiteMatterStreamlines = std::vector<core::Vector3fs>;
 
class SynapseEfficacy;
using SynapseEfficacyPtr = std::shared_ptr<SynapseEfficacy>;
 
class Synaptome;
using SynaptomePtr = std::shared_ptr<Synaptome>;
} // namespace connectomics
 
namespace io
{
// Out of core brick manager
class OOCManager;
using OOCManagerPtr = std::shared_ptr<OOCManager>;
 
namespace db
{
class DBConnector;
using DBConnectorPtr = std::shared_ptr<DBConnector>;
 
namespace fields
{
class FieldsHandler;
typedef std::shared_ptr<FieldsHandler> FieldsHandlerPtr;
} // namespace fields
 
} // namespace db
} // namespace io
namespace details
{
typedef struct
{
    bool status{true};
    std::string contents;
} Response;
 
typedef struct
{
    size_t modelId{0};
    size_t instanceId{0};
    doubles direction;
    double distance{0.0};
} FocusOnDetails;
 
typedef struct
{
    std::string meshFolder;
    uint32_t loggingLevel;
    uint32_t databaseLoggingLevel;
    bool v1Compatibility{false};
    bool cacheEnabled{false};
} GeneralSettingsDetails;
 
typedef struct
{
    uint32_t seed{0};
    uint32_t positionSeed{0};
    double positionStrength{0.f};
    uint32_t rotationSeed{0};
    double rotationStrength{0.f};
    double morphingStep{0.f};
} MolecularSystemAnimationDetails;
 
enum class AssemblyShape
{
    point = 0,
    empty_sphere = 1,
    plane = 2,
    sinusoid = 3,
    cube = 4,
    fan = 5,
    bezier = 6,
    mesh = 7,
    helix = 8,
    filled_sphere = 9,
    spherical_cell_diffusion = 10
};
 
enum class RNAShapeType
{
    trefoilKnot = 0,
    torus = 1,
    star = 2,
    spring = 3,
    heart = 4,
    thing = 5,
    moebius = 6
};
 
typedef struct
{
    bool hit;
    std::string assemblyName;
    std::string proteinName;
    size_t modelId;
    size_t instanceId;
    doubles position;
} ProteinInspectionDetails;
 
typedef struct
{
    doubles origin;
    doubles direction;
} InspectionDetails;
 
typedef struct
{
    std::string name;
    AssemblyShape shape;
    doubles shapeParams;
    std::string shapeMeshContents;
    doubles position;
    doubles rotation;
    doubles clippingPlanes;
} AssemblyDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    doubles transformations;
} AssemblyTransformationsDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    std::string lipidPDBIds;
    std::string lipidContents;
    doubles lipidRotation;
    double lipidDensity;
    double atomRadiusMultiplier{1.0};
    bool loadBonds{false};
    bool loadNonPolymerChemicals{false};
    molecularsystems::ProteinRepresentation representation{molecularsystems::ProteinRepresentation::atoms};
    size_ts chainIds;
    bool recenter{false};
    doubles animationParams;
} MembraneDetails;
 
// Protein
typedef struct
{
    std::string assemblyName;
    std::string name;
    std::string pdbId;
    std::string contents;
    double atomRadiusMultiplier{1.f};
    bool loadBonds{false};
    bool loadNonPolymerChemicals{false};
    bool loadHydrogen{false};
    molecularsystems::ProteinRepresentation representation{molecularsystems::ProteinRepresentation::atoms};
    size_ts chainIds;
    bool recenter{false};
    size_t occurrences{1};
    size_ts allowedOccurrences;
    doubles transmembraneParams;
    doubles animationParams;
    doubles position;
    doubles rotation;
    std::string constraints;
} ProteinDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    std::string pdbId;
    std::string contents;
    std::string proteinName;
    double atomRadiusMultiplier{1.0};
    bool loadBonds{false};
    molecularsystems::ProteinRepresentation representation{molecularsystems::ProteinRepresentation::atoms};
    bool recenter{true};
    size_ts chainIds;
    size_ts siteIndices;
    doubles rotation;
    doubles animationParams;
} SugarDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    std::string pdbId;
    std::string contents;
    std::string proteinContents;
    RNAShapeType shape;
    doubles shapeParams;
    doubles valuesRange;
    doubles curveParams;
    double atomRadiusMultiplier{1.0};
    molecularsystems::ProteinRepresentation representation{molecularsystems::ProteinRepresentation::atoms};
    doubles animationParams;
    doubles position;
    doubles rotation;
} RNASequenceDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    std::string sequence;
} AminoAcidSequenceAsStringDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    size_ts ranges;
} AminoAcidSequenceAsRangesDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
} AminoAcidInformationDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    size_t index;
    std::string aminoAcidShortName;
    size_ts chainIds;
} AminoAcidDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    std::string enzymeName;
    std::string substrateNames;
    std::string productNames;
} EnzymeReactionDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    size_t instanceId{0};
    double progress{0.0};
} EnzymeReactionProgressDetails;
 
typedef struct
{
    double minValue{0.0};
    double maxValue{100.0};
    double steps{10.0};
    double radius{1.0};
    double planeOpacity{1.0};
    bool showAxis{true};
    bool showPlanes{true};
    bool showFullGrid{false};
    bool useColors{true};
    doubles position;
} AddGridDetails;
 
typedef struct
{
    std::string name;
    doubles positions;
    doubles radii;
    doubles color{1.0, 1.0, 1.0};
    double opacity{1.0};
} AddSpheresDetails;
 
typedef struct
{
    std::string name;
    doubles origins;
    doubles targets;
    doubles originsRadii;
    doubles targetsRadii;
    doubles color{1.0, 1.0, 1.0};
    double opacity;
} AddConesDetails;
 
typedef struct
{
    std::string name;
    doubles bottomLeft;
    doubles topRight;
    double radius{1.0};
    doubles color{1.0, 1.0, 1.0};
} AddBoundingBoxDetails;
 
typedef struct
{
    std::string name;
    doubles bottomLeft;
    doubles topRight;
    doubles color;
} AddBoxDetails;
 
typedef struct
{
    std::string name;
    uint64_ts indices;
    doubles vertices;
    doubles colors;
} AddStreamlinesDetails;
 
enum class ProteinColorScheme
{
    none = 0,
    atoms = 1,
    chains = 2,
    residues = 3,
    amino_acid_sequence = 4,
    glycosylation_site = 5,
    region = 6
};
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    ProteinColorScheme colorScheme;
    doubles palette;
    size_ts chainIds;
} ProteinColorSchemeDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string name;
    size_t instanceIndex;
    doubles position;
    doubles rotation;
} ProteinInstanceTransformationDetails;
 
typedef struct
{
    size_ts ids;
} IdsDetails;
 
typedef struct
{
    std::string name;
} NameDetails;
 
typedef struct
{
    size_t modelId;
    size_t maxNbInstances;
} ModelIdDetails;
 
typedef struct
{
    doubles translation;
    doubles rotation;
    doubles rotationCenter;
    doubles scale;
} ModelTransformationDetails;
 
typedef struct
{
    size_t modelId;
    doubles translation;
    doubles rotation;
    doubles rotationCenter;
    doubles scale;
} AddModelInstanceDetails;
 
typedef struct
{
    size_t modelId;
    doubles translations;
    doubles rotations;
    doubles rotationCenters;
    doubles scales;
} SetModelInstancesDetails;
 
typedef struct
{
    doubles minAABB;
    doubles maxAABB;
    doubles center;
    doubles size;
} ModelBoundsDetails;
 
typedef struct
{
    int32_ts modelIds;
    int32_ts materialIds;
    doubles diffuseColors;
    doubles specularColors;
    doubles specularExponents;
    doubles reflectionIndices;
    doubles opacities;
    doubles refractionIndices;
    doubles emissions;
    doubles glossinesses;
    bools castUserData;
    int32_ts shadingModes;
    doubles userParameters;
    int32_ts chameleonModes;
    int32_ts clippingModes;
} MaterialsDetails;
 
enum class FieldDataType
{
    point = 0,
    vector = 1
};
 
typedef struct
{
    double voxelSize;
    double density;
    FieldDataType dataType;
    uint32_ts modelIds;
} BuildFieldsDetails;
 
// IO
typedef struct
{
    size_t modelId;
    std::string filename;
} ModelIdFileAccessDetails;
 
typedef struct
{
    std::string filename;
    doubles lowBounds;
    doubles highBounds;
    common::XYZFileFormat fileFormat;
} FileAccessDetails;
 
typedef struct
{
    int32_t brickId;
    doubles lowBounds;
    doubles highBounds;
} DatabaseAccessDetails;
 
typedef struct
{
    double radius;
} BuildPointCloudDetails;
 
enum class ModelLoadingTransactionAction
{
    start = 0,
    commit = 1
};
 
typedef struct
{
    ModelLoadingTransactionAction action;
} ModelLoadingTransactionDetails;
 
typedef struct
{
    std::string description;
    core::Vector3d sceneSize;
    uint32_t nbBricks;
    core::Vector3d brickSize;
} OOCSceneConfigurationDetails;
 
typedef struct
{
    uint32_t nbModels{0};
    uint32_t nbMaterials{0};
    uint32_t nbSpheres{0};
    uint32_t nbCylinders{0};
    uint32_t nbCones{0};
    uint32_t nbVertices{0};
    uint32_t nbIndices{0};
    uint32_t nbNormals{0};
    uint32_t nbColors{0};
} SceneInformationDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    bool loadCells{true};
    double cellRadius{1.f};
    bool loadMeshes{true};
    std::string cellSqlFilter;
    std::string regionSqlFilter;
    doubles scale{1.0, 1.0, 1.0};
    doubles meshPosition;
    doubles meshRotation;
    doubles meshScale{1.0, 1.0, 1.0};
} AtlasDetails;
 
// -------------------------------------------------------------------------------------------------
// Vasculature
// -------------------------------------------------------------------------------------------------
enum class VasculatureRealismLevel
{
    none = 0,
    section = 1,
    bifurcation = 2,
    all = 255,
};
 
enum class VasculatureColorScheme
{
    none = 0,
    node = 1,
    section = 2,
    subgraph = 3,
    pair = 4,
    entry_node = 5,
    radius = 6,
    section_points = 7,
    section_orientation = 8,
    region = 9
};
 
enum class VasculatureRepresentation
{
    graph = 0,
    section = 1,
    segment = 2,
    optimized_segment = 3,
    bezier = 4
};
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    VasculatureColorScheme colorScheme{VasculatureColorScheme::none};
    int64_t realismLevel{0};
    uint32_ts gids;
    VasculatureRepresentation representation{VasculatureRepresentation::segment};
    double radiusMultiplier{1.0};
    std::string sqlFilter;
    doubles scale{1.0, 1.0, 1.0};
    doubles animationParams;
    doubles displacementParams;
    double alignToGrid{0.0};
} VasculatureDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    uint64_t simulationReportId;
    bool showEvolution;
} VasculatureReportDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    uint64_t simulationReportId{0};
    uint64_t frame{0};
    double amplitude{1.0};
} VasculatureRadiusReportDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    std::string vasculaturePopulationName;
    bool loadSomas{true};
    bool loadDendrites{true};
    bool generateInternals{false};
    bool loadMicroDomains{false};
    int64_t realismLevel{0};
    morphology::MorphologyRepresentation morphologyRepresentation{morphology::MorphologyRepresentation::segment};
    morphology::MicroDomainRepresentation microDomainRepresentation{morphology::MicroDomainRepresentation::mesh};
    morphology::MorphologyColorScheme morphologyColorScheme{morphology::MorphologyColorScheme::none};
    morphology::PopulationColorScheme populationColorScheme{morphology::PopulationColorScheme::none};
    double radiusMultiplier{1.0};
    std::string sqlFilter;
    doubles scale{1.0, 1.0, 1.0};
    doubles animationParams;
    doubles displacementParams;
    double maxDistanceToSoma{0.0};
    double alignToGrid{0.0};
} AstrocytesDetails;
 
enum class NeuronSectionType
{
    undefined = 0,
    soma = 1,
    axon = 2,
    basal_dendrite = 3,
    apical_dendrite = 4
};
 
typedef struct
{
    int64_t reportId{-1};
    core::Vector2d valueRange{-100, 100};
    core::Vector2d scalingRange{1.0, 1.0};
    uint64_t initialSimulationFrame{0};
    bool loadNonSimulatedNodes{false};
} NeuronsReportParameters;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    bool loadSomas{true};
    bool loadAxon{true};
    bool loadBasalDendrites{true};
    bool loadApicalDendrites{true};
    morphology::MorphologySynapseType synapsesType{morphology::MorphologySynapseType::none};
    bool generateInternals{false};
    bool generateExternals{false};
    bool showMembrane{true};
    bool generateVaricosities{false};
    int64_t realismLevel{0};
    morphology::MorphologyRepresentation morphologyRepresentation{morphology::MorphologyRepresentation::segment};
    morphology::MorphologyColorScheme morphologyColorScheme{morphology::MorphologyColorScheme::none};
    morphology::PopulationColorScheme populationColorScheme{morphology::PopulationColorScheme::none};
    double radiusMultiplier{1.0};
    doubles reportParams;
    std::string sqlNodeFilter;
    std::string sqlSectionFilter;
    doubles scale{1.0, 1.0, 1.0};
    doubles animationParams;
    doubles displacementParams;
    double maxDistanceToSoma{0.0};
    double alignToGrid{0.0};
} NeuronsDetails;
 
typedef struct
{
    std::string assemblyName;
    uint64_t neuronId{0};
    uint64_t sectionId{0};
} NeuronIdSectionIdDetails;
 
typedef struct
{
    std::string assemblyName;
    uint64_t neuronId{0};
} NeuronIdDetails;
 
typedef struct
{
    bool status{true};
    doubles points;
} NeuronPointsDetails;
 
typedef struct
{
    doubles source;
    doubles target;
} LookAtDetails;
 
typedef struct
{
    doubles rotation;
} LookAtResponseDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    double radius{1.0};
    std::string sqlFilter;
    doubles scale{1.0, 1.0, 1.0};
} WhiteMatterDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    double radius{1.0};
    double force{1.0};
    std::string sqlNodeFilter;
    std::string sqlEdgeFilter;
} SynaptomeDetails;
 
enum class SynapseRepresentation
{
    sphere = 0,
    spine = 1
};
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    double radiusMultiplier{1.0};
    SynapseRepresentation representation{SynapseRepresentation::sphere};
    int64_t realismLevel{0};
    std::string sqlFilter;
    doubles displacementParams;
} SynapsesDetails;
 
typedef struct
{
    std::string assemblyName;
    std::string populationName;
    double radius{1.0};
    std::string sqlFilter;
    int64_t simulationReportId{-1};
    double alignToGrid{0.0};
} SynapseEfficacyDetails;
 
typedef struct
{
    uint64_t modelId;
    float restVoltage;
    float spikingVoltage;
    float timeInterval;
    float decaySpeed;
} SpikeReportVisualizationSettingsDetails;
 
typedef struct
{
    uint32_t seed{0};
    uint32_t offset{0};
    double amplitude{1.0};
    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;
 
typedef struct
{
    std::string name;
    doubles position;
    doubles radii;
    doubles displacement;
} SDFEllipsoidDetails;
} // namespace details
} // namespace bioexplorer