regularizers.h

#ifndef CTL_REGULARIZERS_H
#define CTL_REGULARIZERS_H

#include <QObject>

#include "processing/abstractvolumefilter.h"

namespace CTL {

class IdentityRegularizer : public AbstractVolumeFilter
{
    CTL_TYPE_ID(2010)

    public: void filter(VoxelVolume<float>& volume) override;
};

class MedianFilterRegularizer : public AbstractVolumeFilter
{
    CTL_TYPE_ID(2011)
    Q_GADGET

    public: void filter(VoxelVolume<float>& volume) override;

public:
    enum NeighborHood { Box3x3x3, NearestOnly };
    Q_ENUM(NeighborHood)

    explicit MedianFilterRegularizer(float strength = 0.1f, NeighborHood neighbors = NearestOnly);

    void setNeighborHoodType(NeighborHood neighbors);
    void setRegularizationStrength(float strength);

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

private:
    float _strength = 0.1f;
    NeighborHood _neighbors = NearestOnly;

    void applyMedian3(VoxelVolume<float>& volume);
    void applyMedianNN(VoxelVolume<float>& volume);

    static QMetaEnum metaEnum();
};

class TVRegularizer : public AbstractVolumeFilter
{
    CTL_TYPE_ID(2012)
    Q_GADGET

    public: void filter(VoxelVolume<float>& volume) override;

public:
    enum NeighborHood { Box3x3x3, NearestOnly };
    Q_ENUM(NeighborHood)

    explicit TVRegularizer(float maxChangeIn10HU = 1.0f, NeighborHood neighbors = NearestOnly);

    void setNeighborHoodType(NeighborHood neighbors);
    void setRegularizationStrength(float maxChangeIn10HU);    // max change in 10 HU

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

private:
    static constexpr float _step = 0.02269f / 1000.0f; // ~1 HU (at 50 keV)
    float _strength = 10.0f;                           // default 10 HU max. change
    NeighborHood _neighbors = NearestOnly;

    void applyTV3(VoxelVolume<float>& volume);
    void applyTVNN(VoxelVolume<float>& volume);

    static QMetaEnum metaEnum();
};

class HuberRegularizer : public AbstractVolumeFilter
{
    CTL_TYPE_ID(2013)

    public: void filter(VoxelVolume<float>& volume) override;

public:
    explicit HuberRegularizer(float strength = 1.0f, float huberEdgeIn100HU = 1.0,
                              float weightZ = 1.0f, float weightXY = 1.0f,
                              float directZweight = 1.0f);

    void setRegularizationStrength(float strength);
    void setHuberEdge(float edgeIn100HU);
    void setRelativeWeighting(float weightZ, float weightXY = 1.0f);
    void setDirectZNeighborWeight(float weight);

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

private:
    float _strength = 0.01f;
    float _huberEdge = 100.0f * 0.02269f/1000.0f;
    float _betaZ = 1.0f;
    float _betaXY = 1.0f;
    float _directZ = 1.0f;
};

namespace assist {
constexpr float clamp(float val, float low, float high)
{
    return (val<low) ? low : ((val>high) ? high : val);
}
} // namespace assist

} //namespace CTL

#endif // CTL_REGULARIZERS_H