oclprojectionfilters.h

#ifndef CTL_OCLPROJECTIONFILTERS_H
#define CTL_OCLPROJECTIONFILTERS_H

#include "genericoclprojectionfilter.h"
#include <algorithm>
#include <complex>

namespace CTL {
class AcquisitionSetup;
class FullGeometry;

namespace OCL {

class CosineWeighting : public GenericOCLProjectionFilter
{
    CTL_TYPE_ID(3101)

public:
    CosineWeighting();
    void filter(ProjectionData& projections, const FullGeometry& pMats);
    void filter(ProjectionData& projections, const AcquisitionSetup& setup);

protected:
    bool autoCombine() const override;
    cl::NDRange globalWorksize(const ProjectionData& projections) const override;

private:
    void filter(ProjectionData&) override{};
};

class ParkerWeightingRev : public GenericOCLProjectionFilter
{
    CTL_TYPE_ID(3102)

public:
    explicit ParkerWeightingRev(float q = 1.0f);
    void filter(ProjectionData& projections, const FullGeometry& pMats);
    void filter(ProjectionData& projections, const AcquisitionSetup& setup);

    float lastAngularRange() const;

private:
    void filter(ProjectionData&) override{};
    float _q = 1.0f;
    float _lastAngularRange = 0.0f;
};

class ApodizationFilter : public GenericOCLProjectionFilter
{
    CTL_TYPE_ID(3103)
    Q_GADGET

public:
    void filter(ProjectionData& projections) override;

public:
    enum FilterType { RamLak, SheppLogan, Cosine, Hann };
    Q_ENUM(FilterType)

    explicit ApodizationFilter(FilterType filterType, float frequencyScaling = 1.0f);

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

private:
    FilterType _filterType;
    float _frequencyScaling = 1.0f;
    std::vector<float> _filter;

    ApodizationFilter();
    std::vector<float> generateCoefficients(unsigned filterSize) const;

    static QMetaEnum metaEnum();
};

class RamLakFilter : public GenericOCLProjectionFilter
{
    CTL_TYPE_ID(3104)

public:
    explicit RamLakFilter(float scaling = 1.0f);
};

class HilbertFilter : public GenericOCLProjectionFilter
{
    CTL_TYPE_ID(3105)

public:
    explicit HilbertFilter(float scaling = 1.0f);
};

} // namespace OCL

namespace assist {

// shifts the zero-frequency component to the center of the spectrum
template <typename T>
void fftshift(std::vector<T>& v)
{
    std::rotate(v.rbegin(), v.rbegin() + v.size() / 2, v.rend());
}

// inverse of fftshift
template <typename T>
void ifftshift(std::vector<T>& v)
{
    std::rotate(v.begin(), v.begin() + v.size() / 2, v.end());
}

std::vector<std::complex<double>> dft(const std::vector<float>& image);
std::vector<float> idft(const std::vector<std::complex<double>>& fourier);

} // namespace assist
} // namespace CTL

#endif // CTL_OCLPROJECTIONFILTERS_H