processors/bilateral/mlbilateral.h

#ifndef __BILATERAL_H__
#define __BILATERAL_H__

#include <vector>

#include <stdint.h>

#include "utils.h"
#include "image.h"
#include "processor.h"
#include "thread.h"

namespace spectral
{


class MlBilateral : public Processor
{
public:
    MlBilateral();
    ~MlBilateral();

    // Get slots & output type.  Returns output colour space.
    // pairs are <slot id, colour space>
    virtual uint32_t GetInterface(
        std::list<std::pair<uint32_t, uint32_t> > &mandatory,
        std::list<std::pair<uint32_t, uint32_t> > &optional) const;

    // Attempt to set an image in a slot.
    virtual bool SetImage(uint32_t slot, const Image *img);

    // Apply parameters to a processor.
    virtual void SetParameters(const Parameters *);

    // Process images.
    virtual Image *Process(void);

    // Clear the image in a slot.
    virtual void ClearImage(uint32_t slot);

protected:

    // Populate a Parameters object.
    virtual void GetParameters(Parameters *) const;

private:
    void CrunchImage(const Image *reference,
                     const Image *input,
                     int32_t radius,
                     bool wrap_horizontal,
                     bool wrap_vertical,
                     uint32_t pass,
                     uint32_t num_passes,
                     Image *result);
                     

    void CleanUp(void);
    void CreateLayers(void);
    Image *Generate(void);

    const Image *m_lumImage;
    Image *m_baseLayer;
    std::vector<Image *> m_layers;

    float m_large_threshold;
    float m_small_threshold;

    float m_large_contrast;
    float m_medium_contrast;
    float m_small_contrast;

    int32_t m_base_radius;
    int32_t m_num_layers;
    bool m_wrap_horizontal, m_wrap_vertical;
};

}

#endif

---