abstractreconstructor.h

Go to the documentation of this file.

#ifndef CTL_ABSTRACTRECONSTRUCTOR_H
#define CTL_ABSTRACTRECONSTRUCTOR_H

#include "img/projectiondataview.h"
#include "io/serializationinterface.h"
#include <memory>

namespace CTL {

class AbstractDynamicVolumeData;
class AcquisitionSetup;
class CompositeVolume;
class SparseVoxelVolume;
class SpectralVolumeData;
template <typename> class VoxelVolume;

class ReconstructorNotifier : public QObject
{
public:
    void connectToMessageHandler(bool includeProgress);

    Q_OBJECT
Q_SIGNALS:
    void progress(qreal portionCompleted);
    void information(QString info);

private:
    QMetaObject::Connection _progressConnection;
};

class AbstractReconstructor : public SerializationInterface
{
    CTL_TYPE_ID(0)

    public:virtual void configure(const AcquisitionSetup& setup) = 0;

public:
    AbstractReconstructor() = default;
    AbstractReconstructor(const AbstractReconstructor&) = delete;
    AbstractReconstructor(AbstractReconstructor&&) = default;
    AbstractReconstructor& operator=(const AbstractReconstructor&) = delete;
    AbstractReconstructor& operator=(AbstractReconstructor&&) = default;
    ~AbstractReconstructor() override = default;

    virtual bool isApplicableTo(const AcquisitionSetup& setup) const; // { return true; }

    // reconstruction methods
    virtual bool reconstructToPlain(const ProjectionDataView& projections,
                                    VoxelVolume<float>& targetVolume);
    virtual bool reconstructToSpectral(const ProjectionDataView& projections,
                                       SpectralVolumeData& targetVolume);
    virtual bool reconstructToDynamic(const ProjectionDataView& projections,
                                      AbstractDynamicVolumeData& targetVolume);
    virtual bool reconstructToComposite(const ProjectionDataView& projections,
                                        CompositeVolume& targetVolume);
    virtual bool reconstructToSparse(const ProjectionDataView& projections,
                                     SparseVoxelVolume& targetVolume);

    template <class VolumeType>
    bool reconstructTo(const ProjectionDataView& projections, VolumeType& targetVolume);

    template <class VolumeType>
    bool configureAndReconstructTo(const AcquisitionSetup& setup,
                                   const ProjectionDataView& projections,
                                   VolumeType& targetVolume);

    // value returner
    template <class VolumeType,
              class = typename std::enable_if<!std::is_lvalue_reference<VolumeType>::value>::type>
    Q_REQUIRED_RESULT
    VolumeType reconstruct(const ProjectionDataView& projections,
                           const VolumeType& initialVolume,
                           bool* ok = nullptr);

    template <class VolumeType,
              class = typename std::enable_if<!std::is_lvalue_reference<VolumeType>::value>::type>
    Q_REQUIRED_RESULT
    VolumeType reconstruct(const ProjectionDataView& projections,
                           VolumeType&& initialVolume,
                           bool* ok = nullptr);

    template <class VolumeType,
              class = typename std::enable_if<!std::is_lvalue_reference<VolumeType>::value>::type>
    Q_REQUIRED_RESULT
    VolumeType configureAndReconstruct(const AcquisitionSetup& setup,
                                       const ProjectionDataView& projections,
                                       const VolumeType& initialVolume,
                                       bool* ok = nullptr);

    template <class VolumeType,
              class = typename std::enable_if<!std::is_lvalue_reference<VolumeType>::value>::type>
    Q_REQUIRED_RESULT
    VolumeType configureAndReconstruct(const AcquisitionSetup& setup,
                                       const ProjectionDataView& view,
                                       VolumeType&& initialVolume,
                                       bool* ok = nullptr);

    // SerializationInterface interface
    virtual QVariant parameter() const;
    virtual void setParameter(const QVariant& parameter);

    void fromVariant(const QVariant& variant) override; // { }
    QVariant toVariant() const override; // { return QVariant(); }

    virtual ReconstructorNotifier* notifier();
    void connectNotifierToMessageHandler(bool includeProgress = false);

private:
    std::unique_ptr<ReconstructorNotifier> _notifier{
        new ReconstructorNotifier
    }; 
};

template <>
bool AbstractReconstructor::reconstructTo(const ProjectionDataView& projections,
                                          VoxelVolume<float>& targetVolume);
template <>
bool AbstractReconstructor::reconstructTo(const ProjectionDataView& projections,
                                          SpectralVolumeData& targetVolume);
template <>
bool AbstractReconstructor::reconstructTo(const ProjectionDataView& projections,
                                          CompositeVolume& targetVolume);
template <>
bool AbstractReconstructor::reconstructTo(const ProjectionDataView& projections,
                                          SparseVoxelVolume& targetVolume);
template <class DynamicVolumeType>
bool AbstractReconstructor::reconstructTo(const ProjectionDataView& projections,
                                          DynamicVolumeType& targetVolume)
{
    static_assert(std::is_convertible<DynamicVolumeType*, AbstractDynamicVolumeData*>::value,
        "Method call defaulted to dynamic case, because the passed volume type is not covered "
        "by any available specialization. Consider explicitly providing the required base type "
        "(e.g. reconstruct[To]<SpectralVolumeData>()).");

    return reconstructToDynamic(projections, targetVolume);
}

template <>
bool AbstractReconstructor::configureAndReconstructTo(const AcquisitionSetup& setup,
                                                      const ProjectionDataView& projections,
                                                      VoxelVolume<float>& targetVolume);
template <>
bool AbstractReconstructor::configureAndReconstructTo(const AcquisitionSetup& setup,
                                                      const ProjectionDataView& projections,
                                                      SpectralVolumeData& targetVolume);
template <>
bool AbstractReconstructor::configureAndReconstructTo(const AcquisitionSetup& setup,
                                                      const ProjectionDataView& projections,
                                                      CompositeVolume& targetVolume);
template <>
bool AbstractReconstructor::configureAndReconstructTo(const AcquisitionSetup& setup,
                                                      const ProjectionDataView& projections,
                                                      SparseVoxelVolume& targetVolume);
template <class DynamicVolumeType>
bool AbstractReconstructor::configureAndReconstructTo(const AcquisitionSetup& setup,
                                                      const ProjectionDataView& projections,
                                                      DynamicVolumeType& targetVolume)
{
    static_assert(std::is_convertible<DynamicVolumeType*, AbstractDynamicVolumeData*>::value,
        "Method call defaulted to dynamic case, because the passed volume type is not covered "
        "by any available specialization. Consider explicitly providing the required base type "
        "(e.g. reconstruct[To]<SpectralVolumeData>()).");

    configure(setup);
    return reconstructToDynamic(projections, targetVolume);
}

template <class VolumeType, class>
VolumeType AbstractReconstructor::reconstruct(const ProjectionDataView& projections,
                                              const VolumeType& initialVolume,
                                              bool* ok)
{
    VolumeType ret(initialVolume);

    const auto recoOk = reconstructTo(projections, ret);

    if(ok) *ok = recoOk;

    return ret;
}

template <class VolumeType, class>
VolumeType AbstractReconstructor::reconstruct(const ProjectionDataView& projections,
                                              VolumeType&& initialVolume,
                                              bool* ok)
{
    VolumeType ret(std::move(initialVolume));

    const auto recoOk = reconstructTo(projections, ret);

    if(ok) *ok = recoOk;

    return ret;
}

template <class VolumeType, class>
VolumeType AbstractReconstructor::configureAndReconstruct(const AcquisitionSetup& setup,
                                                          const ProjectionDataView& projections,
                                                          const VolumeType& initialVolume,
                                                          bool* ok)
{
    configure(setup);
    return reconstruct(projections, initialVolume, ok);
}

template <class VolumeType, class>
VolumeType AbstractReconstructor::configureAndReconstruct(const AcquisitionSetup& setup,
                                                          const ProjectionDataView& projections,
                                                          VolumeType&& initialVolume,
                                                          bool* ok)
{
    configure(setup);
    return reconstruct(projections, std::move(initialVolume), ok);
}

// factory function `makeReconstructor`
template <typename ReconstructorType, typename... ConstructorArguments>
auto makeReconstructor(ConstructorArguments&&... arguments) ->
    typename std::enable_if<std::is_convertible<ReconstructorType*, AbstractReconstructor*>::value,
                            std::unique_ptr<ReconstructorType>>::type
{
    return std::unique_ptr<ReconstructorType>(new ReconstructorType(
                                              std::forward<ConstructorArguments>(arguments)...));
}

} // namespace CTL



#endif // CTL_ABSTRACTRECONSTRUCTOR_H