abstractdetector.h

Go to the documentation of this file.

#ifndef CTL_ABSTRACTDETECTOR_H
#define CTL_ABSTRACTDETECTOR_H

#include "systemcomponent.h"
#include "mat/matrix_utils.h"   // for definition of mat::Location
#include "img/singleviewdata.h" // for definition of SingleViewData::Dimensions
#include "models/abstractdatamodel.h"
#include "models/xydataseries.h"

#include <QJsonArray>
#include <QSize>
#include <QVariantMap>

/*
 * NOTE: This is header only.
 */

namespace CTL {

class GenericDetector;

class AbstractDetector : public SystemComponent
{
    CTL_TYPE_ID(100)
    DECLARE_ELEMENTAL_TYPE

public:
    typedef mat::Location ModuleLocation;
    enum SaturationModelType { Extinction, PhotonCount, Intensity, Undefined };

    // abstract interface
    public:virtual QVector<ModuleLocation> moduleLocations() const = 0;

public:
    AbstractDetector(const QSize& nbPixelPerModule,
                     const QSizeF& pixelSize,
                     const QString& name);

    // virtual methods
    QString info() const override;
    void fromVariant(const QVariant& variant) override; // de-serialization
    QVariant toVariant() const override; // serialization

    // setter methods
    void setSaturationModel(AbstractDataModel* model, SaturationModelType type);
    void setSaturationModel(std::unique_ptr<AbstractDataModel> model, SaturationModelType type);
    void setSpectralResponseModel(AbstractDataModel* model);
    void setSpectralResponseModel(std::unique_ptr<AbstractDataModel> model);

    // getter methods
    uint nbDetectorModules() const;
    const QSize& nbPixelPerModule() const;
    Q_DECL_DEPRECATED_X("Within the CTL 'dimension' is use for a count of something, use pixelSize() instead.")
    const QSizeF& pixelDimensions() const;
    const QSizeF& pixelSize() const;
    ModuleLocation moduleLocation(uint module) const;
    const AbstractDataModel* saturationModel() const;
    const AbstractDataModel* spectralResponseModel() const;
    XYDataSeries inputResponse(float from, float to, uint nbSamples) const;
    XYDataSeries spectralResponse(float from, float to, uint nbSamples) const;
    SaturationModelType saturationModelType() const;
    double skewAngle() const;

    // other methods
    bool hasSaturationModel() const;
    bool hasSpectralResponseModel() const;
    QSizeF moduleDimensions() const;
    SingleViewData::Dimensions viewDimensions() const;

    // converter
    std::unique_ptr<GenericDetector> toGeneric() const;

    ~AbstractDetector() override = default;

protected:
    AbstractDetector() = default;
    AbstractDetector(const QString& name);

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

    QSize _nbPixelPerModule; 
    QSizeF _pixelSize;       
    double _skewAngle = 0.0; 

    AbstractDataModelPtr _spectralResponseModel; 
    AbstractDataModelPtr _saturationModel; 
    SaturationModelType _saturationModelType = Undefined; 
};

inline uint AbstractDetector::nbDetectorModules() const { return moduleLocations().count(); }

inline const QSize& AbstractDetector::nbPixelPerModule() const { return _nbPixelPerModule; }

inline const QSizeF& AbstractDetector::pixelDimensions() const { return _pixelSize; }

inline const QSizeF& AbstractDetector::pixelSize() const { return _pixelSize; }

inline QSizeF AbstractDetector::moduleDimensions() const
{
    return { _nbPixelPerModule.width()*_pixelSize.width(),
             _nbPixelPerModule.height()*_pixelSize.height() };
}

inline SingleViewData::Dimensions AbstractDetector::viewDimensions() const
{
    SingleViewData::Dimensions ret;
    ret.nbChannels = _nbPixelPerModule.width();
    ret.nbRows     = _nbPixelPerModule.height();
    ret.nbModules  = nbDetectorModules();
    return ret;
}

inline AbstractDetector::ModuleLocation AbstractDetector::moduleLocation(uint module) const
{
    Q_ASSERT(module < nbDetectorModules());
    return moduleLocations().at(module);
}

inline const AbstractDataModel* AbstractDetector::saturationModel() const
{
    return _saturationModel.get();
}

inline AbstractDetector::SaturationModelType AbstractDetector::saturationModelType() const
{
    return _saturationModelType;
}

inline const AbstractDataModel* AbstractDetector::spectralResponseModel() const
{
    return _spectralResponseModel.get();
}

inline double AbstractDetector::skewAngle() const { return _skewAngle; }

inline XYDataSeries AbstractDetector::inputResponse(float from, float to, uint nbSamples) const
{
    if(!_saturationModel)
        return XYDataSeries();
    return XYDataSeries::sampledFromModel(*_saturationModel, from, to, nbSamples);
}

inline XYDataSeries AbstractDetector::spectralResponse(float from, float to, uint nbSamples) const
{
    if(!_spectralResponseModel)
        return XYDataSeries();
    return XYDataSeries::sampledFromModel(*_spectralResponseModel, from, to, nbSamples);
}

inline bool AbstractDetector::hasSaturationModel() const
{
    return static_cast<bool>(_saturationModel);
}

inline bool AbstractDetector::hasSpectralResponseModel() const
{
    return static_cast<bool>(_spectralResponseModel);
}

inline AbstractDetector::AbstractDetector(const QString &name)
    : SystemComponent(name)
{
}

inline AbstractDetector::AbstractDetector(const QSize& nbPixelPerModule,
                                          const QSizeF& pixelSize,
                                          const QString& name)
    : SystemComponent(name)
    , _nbPixelPerModule(nbPixelPerModule)
    , _pixelSize(pixelSize)
{
}

inline QString AbstractDetector::info() const
{
    QString ret(SystemComponent::info());

    // clang-format off
    ret +=
       typeInfoString(typeid(this)) +
       "\tNb. of modules: "            + QString::number(nbDetectorModules()) + "\n"
       "\tNb. of pixels per module: "  + QString::number(_nbPixelPerModule.width()) + " x " +
                                         QString::number(_nbPixelPerModule.height()) + "\n"
       "\tPixel size: "                + QString::number(_pixelSize.width()) + " mm x " +
                                         QString::number(_pixelSize.height()) + " mm\n";

    ret += (this->type() == AbstractDetector::Type) ? QLatin1String("}\n") : QLatin1String("");
    // clang-format on

    return ret;
}

// Use SerializationInterface::fromVariant() documentation.
inline void AbstractDetector::fromVariant(const QVariant& variant)
{
    SystemComponent::fromVariant(variant);

    QVariantMap varMap = variant.toMap();

    auto nbPixels = varMap.value(QStringLiteral("pixel per module")).toMap();
    _nbPixelPerModule.setWidth(nbPixels.value(QStringLiteral("channels")).toInt());
    _nbPixelPerModule.setHeight(nbPixels.value(QStringLiteral("rows")).toInt());

    auto pixelDim = varMap.value(QStringLiteral("pixel size")).toMap();
    _pixelSize.setWidth(pixelDim.value(QStringLiteral("width")).toDouble());
    _pixelSize.setHeight(pixelDim.value(QStringLiteral("height")).toDouble());

    QVariant saturationModel = varMap.value(QStringLiteral("saturation model"));
    _saturationModel.reset(SerializationHelper::parseDataModel(saturationModel));

    int satModTypeVal = varMap.value(QStringLiteral("saturation model type")).toMap().value(QStringLiteral("enum value")).toInt();
    _saturationModelType = SaturationModelType(satModTypeVal);
}

// Use SerializationInterface::toVariant() documentation.
inline QVariant AbstractDetector::toVariant() const
{
    QVariantMap ret = SystemComponent::toVariant().toMap();

    QVariantMap nbPixels;
    nbPixels.insert(QStringLiteral("channels"),_nbPixelPerModule.width());
    nbPixels.insert(QStringLiteral("rows"), _nbPixelPerModule.height());

    QVariantMap pixelDim;
    pixelDim.insert(QStringLiteral("width"),_pixelSize.width());
    pixelDim.insert(QStringLiteral("height"), _pixelSize.height());

    QVariant saturationModel = hasSaturationModel() ? _saturationModel->toVariant()
                                                    : QVariant();

    QVariantMap satModelType;
    satModelType.insert(QStringLiteral("enum value"), _saturationModelType);
    satModelType.insert(QStringLiteral("meaning"), "0: Extinction, 1: Photon count, 2: Intensity, 3: Undefined");

    ret.insert(QStringLiteral("pixel per module"), nbPixels);
    ret.insert(QStringLiteral("pixel size"), pixelDim);
    ret.insert(QStringLiteral("saturation model"), saturationModel);
    ret.insert(QStringLiteral("saturation model type"), satModelType);

    return ret;
}

inline void AbstractDetector::setSaturationModel(AbstractDataModel* model,
                                                 AbstractDetector::SaturationModelType type)
{
    _saturationModel.reset(model);
    _saturationModelType = type;
}

inline void AbstractDetector::setSaturationModel(std::unique_ptr<AbstractDataModel> model,
                                                 SaturationModelType type)
{
    _saturationModel = std::move(model);
    _saturationModelType = type;
}

inline void AbstractDetector::setSpectralResponseModel(AbstractDataModel* model)
{
    _spectralResponseModel.reset(model);
}

inline void AbstractDetector::setSpectralResponseModel(std::unique_ptr<AbstractDataModel> model)
{
    _spectralResponseModel = std::move(model);
}

} // namespace CTL



#endif // CTL_ABSTRACTDETECTOR_H