spectralvolumedata.h

#ifndef CTL_SPECTRALVOLUMEDATA_H
#define CTL_SPECTRALVOLUMEDATA_H

#include "voxelvolume.h"
#include "models/abstractdatamodel.h"

namespace CTL {
class SpectralVolumeData : public VoxelVolume<float>
{
public:
    SpectralVolumeData(VoxelVolume<float> muValues);
    SpectralVolumeData(VoxelVolume<float> muValues,
                       std::shared_ptr<AbstractIntegrableDataModel> absorptionModel,
                       float referenceEnergy,
                       const QString& materialName = QString());
    SpectralVolumeData(VoxelVolume<float> materialDensity,
                       std::shared_ptr<AbstractIntegrableDataModel> absorptionModel,
                       const QString& materialName = QString());

    ~SpectralVolumeData() override = default;
    virtual SpectralVolumeData* clone() const;

    // getter methods
    std::shared_ptr<AbstractIntegrableDataModel> absorptionModel() const;
    std::unique_ptr<SpectralVolumeData> densityVolume() const;
    bool hasSpectralInformation() const;
    bool isDensityVolume() const;
    bool isMuVolume() const;
    float massAttenuationCoeff(float atEnergy) const;
    const QString& materialName() const;
    float meanMassAttenuationCoeff(float centerEnergy, float binWidth) const;
    std::unique_ptr<SpectralVolumeData> muVolume(float referenceEnergy) const;
    std::unique_ptr<SpectralVolumeData> muVolume(float centerEnergy, float binWidth) const;
    float referenceEnergy() const;
    float referenceMassAttenuationCoeff() const;

    static SpectralVolumeData ball(float radius, float voxelSize, float density,
                                   std::shared_ptr<AbstractIntegrableDataModel> absorptionModel);
    static SpectralVolumeData cube(uint nbVoxel, float voxelSize, float density,
                                   std::shared_ptr<AbstractIntegrableDataModel> absorptionModel);
    static SpectralVolumeData cylinderX(float radius, float height, float voxelSize, float density,
                                        std::shared_ptr<AbstractIntegrableDataModel> absorptionModel);
    static SpectralVolumeData cylinderY(float radius, float height, float voxelSize, float density,
                                        std::shared_ptr<AbstractIntegrableDataModel> absorptionModel);
    static SpectralVolumeData cylinderZ(float radius, float height, float voxelSize, float density,
                                        std::shared_ptr<AbstractIntegrableDataModel> absorptionModel);

    // setter methods
    void replaceAbsorptionModel(AbstractIntegrableDataModel* absorptionModel);
    void replaceAbsorptionModel(std::shared_ptr<AbstractIntegrableDataModel> absorptionModel);
    void setDensity(VoxelVolume<float> density);
    void setMaterialName(const QString& name);

    using VoxelVolume<float>::operator=;

    SpectralVolumeData(const SpectralVolumeData&) = default;
    SpectralVolumeData(SpectralVolumeData&&) = default;
    SpectralVolumeData& operator=(const SpectralVolumeData&) = default;
    SpectralVolumeData& operator=(SpectralVolumeData&&) = default;

    // factory methods
    static SpectralVolumeData fromMuVolume(VoxelVolume<float> muValues,
                                           std::shared_ptr<AbstractIntegrableDataModel> absorptionModel,
                                           float referenceEnergy = 50.0f);
    static SpectralVolumeData fromHUVolume(VoxelVolume<float> HUValues,
                                           std::shared_ptr<AbstractIntegrableDataModel> absorptionModel,
                                           float referenceEnergy = 50.0f);

    // transform data representation
    void transformToAttenuationCoeff(float referenceEnergy);
    void transformToDensity();

private:
    std::shared_ptr<AbstractIntegrableDataModel> _absorptionModel;
    QString _materialName;

    bool _hasNonDefaultAbsModel{ false };    
    bool _isMu{ false };                     
    float _refEnergy{ -1.0f };               
    float _refMassAttenuationCoeff{ -1.0f }; 

    // other methods
    void changeReferenceEnergy(float newReferenceEnergy);
    void changeReferenceMassAttCoeff(float newReferenceMassAttCoeff, float correspondingRefEnergy);
    void transformToAttenuationCoeff(float referenceMassAttCoeff, float correspondingRefEnergy);
};

}

#endif // CTL_SPECTRALVOLUMEDATA_H