ApplicationParameters.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 "AbstractParameters.h"
 
#include <platform/core/common/Types.h>
#include <string>
#include <vector>
 
SERIALIZATION_ACCESS(ApplicationParameters)
 
namespace core
{
class ApplicationParameters : public AbstractParameters
{
public:
    ApplicationParameters();
 
    void print() final;
 
    const std::string& getEngine() const { return _engine; }
    const std::vector<std::string>& getOsprayModules() const { return _modules; }
 
    bool getDynamicLoadBalancer() const { return _dynamicLoadBalancer; }
    void setDynamicLoadBalancer(const bool value) { _updateValue(_dynamicLoadBalancer, value); }
 
    const Vector2ui getWindowSize() const { return Vector2ui(_windowSize); }
    void setWindowSize(const Vector2ui& size)
    {
        Vector2d value(size);
        _updateValue(_windowSize, value);
    }
    bool isBenchmarking() const { return _benchmarking; }
    void setBenchmarking(bool enabled) { _benchmarking = enabled; }
    void setJpegCompression(const size_t compression) { _updateValue(_jpegCompression, compression); }
    size_t getJpegCompression() const { return _jpegCompression; }
    size_t getImageStreamFPS() const { return _imageStreamFPS; }
    void setImageStreamFPS(const size_t fps) { _updateValue(_imageStreamFPS, fps); }
 
    bool useVideoStreaming() const { return _useVideoStreaming; }
    size_t getMaxRenderFPS() const { return _maxRenderFPS; }
    bool isStereo() const { return _stereo; }
    bool getParallelRendering() const { return _parallelRendering; }
    const std::string& getHttpServerURI() const { return _httpServerURI; }
    void setHttpServerURI(const std::string& httpServerURI) { _updateValue(_httpServerURI, httpServerURI); }
 
    const std::string& getEnvMap() const { return _envMap; }
    const std::string& getSandboxPath() const { return _sandBoxPath; }
    const strings& getInputPaths() const { return _inputPaths; }
    po::positional_options_description& posArgs() { return _positionalArgs; }
 
protected:
    void parse(const po::variables_map& vm) final;
 
    std::string _engine{ENGINE_OSPRAY};
    std::vector<std::string> _modules;
    Vector2d _windowSize;
    bool _benchmarking{false};
    size_t _jpegCompression;
    bool _stereo{false};
    size_t _imageStreamFPS{60};
    size_t _maxRenderFPS{std::numeric_limits<size_t>::max()};
    std::string _httpServerURI;
    bool _parallelRendering{false};
    bool _dynamicLoadBalancer{false};
    bool _useVideoStreaming{false};
    std::string _envMap;
    std::string _sandBoxPath;
 
    strings _inputPaths;
 
    po::positional_options_description _positionalArgs;
 
    SERIALIZATION_FRIEND(ApplicationParameters)
};
} // namespace core