fdkreconstructor.h

#ifndef CTL_FDKRECONSTRUCTOR_H
#define CTL_FDKRECONSTRUCTOR_H

#include "acquisition/acquisitionsetup.h"
#include "mat/matrix.h"
#include "recon/sfpbackprojector.h"

namespace CTL {

class AbstractProjectionFilter;

namespace OCL {

class FDKReconstructor : public AbstractReconstructor
{ 
    CTL_TYPE_ID(100)

public: void configure(const AcquisitionSetup& setup) override;
public: bool reconstructToPlain(const ProjectionDataView& projections,
                                VoxelVolume<float>& targetVolume) override;
public:
    using ProjectionFilter = AbstractProjectionFilter;

    explicit FDKReconstructor(float q = 1.0f,
                              bool useSFPBackprojector = false);
    explicit FDKReconstructor(std::unique_ptr<ProjectionFilter> projectionFilter,
                              float q = 1.0f,
                              bool useSFPBackprojector = false);
    explicit FDKReconstructor(ProjectionFilter* projectionFilter,
                              float q = 1.0f,
                              bool useSFPBackprojector = false);
    void setProjectionFilter(std::unique_ptr<ProjectionFilter> projectionFilter);
    void setProjectionFilter(ProjectionFilter* projectionFilter);
    void setRevisedParkerWeightQ(float q);
    void useSFPBackprojector(SFPBackprojector::FootprintType footprintType = SFPBackprojector::TR);
    void useSimpleBackrojector();

    SFPBackprojector::FootprintType footprintType() const;
    bool isSFPBackprojectorInUse() const;
    bool isSimpleBackprojectorInUse() const;
    float revisedParkerWeightQ() const;

    bool isApplicableTo(const AcquisitionSetup& setup) const override;

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

private:
    AcquisitionSetup _setup;
    std::unique_ptr<ProjectionFilter> _projectionFilter;
    float _q = 1.0f;
    bool _useSFPBackprojector = false;
    SFPBackprojector::FootprintType _footprintType = SFPBackprojector::TR;

    bool consistencyChecks(const ProjectionDataView& projections) const;

    static float estimateSDD(AcquisitionSetup& setup);
    static float estimateSID(AcquisitionSetup& setup);
    static bool isCircularSourceOrbit(AcquisitionSetup& setup);
    static bool isDetectorTangentialToOrbit(AcquisitionSetup& setup);
};

} // namespace OCL

namespace assist{

struct Circle3D{
    mat::Matrix<3,1> center;
    mat::Matrix<3,1> normal;
    double radius;

    double distanceToPoint(const mat::Matrix<3,1>& pt) const;

    static Circle3D fromThreePoints(const mat::Matrix<3,1>& p1,
                                    const mat::Matrix<3,1>& p2,
                                    const mat::Matrix<3,1>& p3);
};

} // namespace assist

} // namespace CTL

#endif // CTL_FDKRECONSTRUCTOR_H