backprojectorbase.h

Go to the documentation of this file.

#ifndef CTL_BACKPROJECTORBASE_H
#define CTL_BACKPROJECTORBASE_H

#include "abstractreconstructor.h"
#include "acquisition/acquisitionsetup.h"
#include "mat/matrix_types.h"
#include "ocl/pinnedmem.h"

namespace CTL {

class SingleViewGeometry;
class FullGeometry;

namespace OCL {

class BackprojectorBase : public AbstractReconstructor
{
    CTL_TYPE_ID(1)
    Q_GADGET

    // abstract interface
    public: void configure(const AcquisitionSetup& setup) override;

public:
    using ProjectionWeights = std::vector<std::vector<float>>;
    enum class WeightingType { DistanceWeightsOnly, GeometryFactors };
    Q_ENUM(WeightingType)

    // AbstractReconstructor interface
    bool reconstructToPlain(const ProjectionDataView& projections,
                            VoxelVolume<float>& targetVolume) override;

    bool isConfigConsistentWith(const ProjectionDataView& projections) const;
    bool customWeightsValid(const ProjectionDataView& projections) const;

    const AcquisitionSetup& setup() const;
    WeightingType weightingType() const;
    void setWeightingType(WeightingType weigthType);
    void setCustomWeights(ProjectionWeights weights);

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

protected:
    BackprojectorBase(cl::Kernel* backsmearKernel, WeightingType weightingType);

    virtual void transferAdditionalData(uint startView, uint nbViews);
    virtual float weighting(uint view, uint module) const;

    // reset kernel
    void setBacksmearKernel(cl::Kernel* backsmearKernel);

    cl::Kernel* backsmearKernel() const;
    const cl::CommandQueue& queue() const;

    float precomputedGeometryFactor(uint view, uint module) const;

    static uint viewsPerBlock(const ProjectionData::Dimensions& projDim);
    static QMetaEnum metaEnum();

private:
    // the setup (copied via `configure`)
    AcquisitionSetup _setup;

    // weighting type
    WeightingType _weightingType;

    // precomputed geometry factors
    ProjectionWeights _precompGeomFactors;

    // custom weights
    ProjectionWeights _customWeights;

    // OCL related
    cl::CommandQueue _queue;

    cl::Kernel* _kernelBacksmear;
    cl::Kernel* _kernelNullifier;

    // regular buffers
    cl::Buffer _volCornerBuffer;
    cl::Buffer _voxSizeBuffer;
    cl::Buffer _pMatBuffer;
    cl::Buffer _sliceBuffer;

    // pinned memory
    std::unique_ptr<PinnedImg3DHostWrite> _projBuf;

    // dimension info
    std::array<uint, 3> _nbVoxels{ 0, 0, 0 };
    Vector3x1 _voxelSize{ 0.0 };
    Vector3x1 _corner{ 0.0 };
    cl::size_t<3> _zeroVec, _projBufferDim;
    size_t _bytesLocPMatMem;
    uint _nbModules, _viewsPerBlock;

    // helper functions
    void createBuffers();
    void createCommandQueue();
    void createPinnedMemory();
    void freeGPUMemory();
    void initNullifierKernel();
    void readoutResult(VoxelVolume<float>& targetVolume, uint z);
    void setDimensions(const ProjectionData::Dimensions& projDim,
                       const VoxelVolume<float>& targetVolume);
    void setFixedKernelArgs();
    void startBacksmearKernel(uint slice, uint view);
    void startNullifierKernel();
    void transferProjectionData(const ProjectionDataView& projections,
                                uint startView, uint nbViews);
    void transferProjectionMatrices(const float* src, uint startView, uint nbViews);
    void transferSlice(const VoxelVolume<float>& targetVolume, uint z);
    void writeFixedBuffers();

    void precomputeGeometryFactors(float volumeOfSingleVoxel, const FullGeometry& pMats);
    static std::vector<float> computeGeometryFactors(float volumeOfSingleVoxel,
                                                     const SingleViewGeometry& modPMats);
};

} // namespace OCL

using BackprojectorWeighting = OCL::BackprojectorBase::WeightingType;

namespace assist {
bool isConsistentPair(const AcquisitionSetup& setup, const ProjectionDataView& projections);

template<typename T>
QVariantList vectorToVariantList(const std::vector<T>& vector)
{
    QVariantList ret;
    ret.reserve(static_cast<int>(vector.size()));

    for(const auto& val : vector)
        ret.append(val);

    return ret;
}

template<typename T>
std::vector<T> variantListToVector(const QVariantList& list)
{
    std::vector<T> ret;
    ret.reserve(list.size());

    for(const auto& val : list)
        ret.push_back(qvariant_cast<T>(val));

    return ret;
}
}

} // namespace CTL

#endif // CTL_BACKPROJECTORBASE_H