abstractprojector.h

Go to the documentation of this file.

#ifndef CTL_ABSTRACTPROJECTOR_H
#define CTL_ABSTRACTPROJECTOR_H

#include "img/projectiondata.h"
#include "img/spectralvolumedata.h"
#include "io/serializationinterface.h"

#include <memory>

namespace CTL {

// forward declarations
class AcquisitionSetup;
class CompositeVolume;
class SparseVoxelVolume;
typedef SpectralVolumeData VolumeData;

class ProjectorNotifier : public QObject
{
    Q_OBJECT

public:
    void connectToMessageHandler(bool includeProgress);

Q_SIGNALS:
    void projectionFinished(int viewNb);
    void information(QString info);

private:
    QMetaObject::Connection _progressConnection;
};

class AbstractProjector : public SerializationInterface
{
    CTL_TYPE_ID(0)

    // abstract interface
    public:virtual void configure(const AcquisitionSetup& setup) = 0;
    public:virtual ProjectionData project(const VolumeData& volume) = 0;

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

    virtual bool isLinear() const;
    virtual ProjectionData projectComposite(const CompositeVolume& volume);
    virtual ProjectionData projectSparse(const SparseVoxelVolume& volume);

    ProjectionData configureAndProject(const AcquisitionSetup& setup, const VolumeData& volume);
    ProjectionData configureAndProject(const AcquisitionSetup& setup, const CompositeVolume& volume);
    ProjectionData configureAndProject(const AcquisitionSetup& setup, const SparseVoxelVolume& volume);

    void fromVariant(const QVariant& variant) override;
    QVariant toVariant() const override;
    virtual QVariant parameter() const;
    virtual void setParameter(const QVariant& parameter);

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

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

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

} // namespace CTL



#endif // CTL_ABSTRACTPROJECTOR_H