standardpipeline.h

Go to the documentation of this file.

#ifndef CTL_STANDARDPIPELINE_H
#define CTL_STANDARDPIPELINE_H

#include "projectionpipeline.h"

namespace CTL {

namespace OCL {
    class RayCasterProjector;
} // namespace OCL
class ArealFocalSpotExtension;
class DetectorSaturationExtension;
class PoissonNoiseExtension;
class SpectralEffectsExtension;


class StandardPipeline : public AbstractProjector
{
    CTL_TYPE_ID(201)

    class SettingsAFS;
    class SettingsDetectorSaturation;
    class SettingsPoissonNoise;
    class SettingsSpectralEffects;
    class SettingsRayCaster;

public:
    enum ApproximationPolicy
    {
        No_Approximation,
        Default_Approximation,
        Full_Approximation,
    };

    explicit StandardPipeline(ApproximationPolicy policy = StandardPipeline::Default_Approximation);
    StandardPipeline(const StandardPipeline&)            = delete;
    StandardPipeline& operator=(const StandardPipeline&) = delete;
    StandardPipeline(StandardPipeline&& other) noexcept;
    StandardPipeline& operator=(StandardPipeline&& other) noexcept;
    ~StandardPipeline() override;

    void configure(const AcquisitionSetup& setup) override;
    ProjectionData project(const VolumeData& volume) override;
    ProjectionData projectComposite(const CompositeVolume& volume) override;
    ProjectionData projectSparse(const SparseVoxelVolume& volume) override;
    bool isLinear() const override;
    ProjectorNotifier* notifier() override;

    // SerializationInterface interface
    void fromVariant(const QVariant& variant) override;
    QVariant toVariant() const override;

    // configuration methods
    void enableArealFocalSpot(bool enable = true);
    void enableDetectorSaturation(bool enable = true);
    void enablePoissonNoise(bool enable = true);
    void enableSpectralEffects(bool enable = true);

    SettingsAFS& settingsArealFocalSpot();
    SettingsDetectorSaturation& settingsDetectorSaturation();
    SettingsPoissonNoise& settingsPoissonNoise();
    SettingsSpectralEffects& settingsSpectralEffects();
    SettingsRayCaster& settingsRayCaster();

private:
    ProjectionPipeline _pipeline; 

    OCL::RayCasterProjector* _projector;     
    ArealFocalSpotExtension* _extAFS;        
    DetectorSaturationExtension* _extDetSat; 
    PoissonNoiseExtension* _extPoisson;      
    SpectralEffectsExtension* _extSpectral;  

    template <class Ext>
    class Settings
    {
    public:
        Settings(const Settings&)            = delete;
        Settings& operator=(const Settings&) = delete;

    protected:
        Settings(Settings&&)                 = default;
        Settings& operator=(Settings&&)      = default;
        ~Settings()                          = default;

        explicit Settings(Ext& ext) : _instance(ext) {}
        Ext& extension() const { return _instance.get(); }

    private:
        std::reference_wrapper<Ext> _instance;
    };

    class SettingsRayCaster : public Settings<OCL::RayCasterProjector>
    {
    public:
        void setInterpolation(bool enabled);
        void setRaysPerPixel(const QSize& sampling);
        void setRaySampling(float sampling);
        void setVolumeUpSampling(uint upSamplingFactor);

    private:
        using Settings::Settings;

        friend class StandardPipeline;
    } _settingsRayCaster;

    class SettingsAFS : public Settings<ArealFocalSpotExtension>
    {
    public:
        void setDiscretization(const QSize& discretization);
        void enableLowExtinctionApproximation(bool enable = true);

    private:
        using Settings::Settings;

        friend class StandardPipeline;
    } _settingsAFS;

    class SettingsDetectorSaturation : public Settings<DetectorSaturationExtension>
    {
    public:
        void setSpectralSamples(uint nbSamples);

    private:
        using Settings::Settings;

        friend class StandardPipeline;
    } _settingsDetSat;

    class SettingsPoissonNoise : public Settings<PoissonNoiseExtension>
    {
    public:
        void setFixedSeed(uint seed);
        void setRandomSeedMode();
        void setParallelizationMode(bool enabled);

    private:
        using Settings::Settings;

        friend class StandardPipeline;
    } _settingsPoisson;

    class SettingsSpectralEffects : public Settings<SpectralEffectsExtension>
    {
    public:
        void setSamplingResolution(float energyBinWidth);

    private:
        using Settings::Settings;

        friend class StandardPipeline;
    } _settingsSpectral;

    uint posAFS() const;
    uint posDetSat() const;
    uint posPoisson() const;
    uint posSpectral() const;

    ApproximationPolicy _approxMode;  
    bool _arealFSEnabled = false;     
    bool _detSatEnabled = false;      
    bool _spectralEffEnabled = false; 
    bool _poissonEnabled = false;     
};

} // namespace CTL


#endif // CTL_STANDARDPIPELINE_H