processors/multilevel/mlfilter.h

#ifndef __MLFILTER_H__
#define __MLFILTER_H__

#include <vector>

#include <stdint.h>

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

namespace multilevel
{

class MlFilter;

class HPassJob : public thread::Job
{
public:
    HPassJob(const spectral::Image *sourceImage, 
             const std::vector<float> &kernel,
             uint32_t first,
             uint32_t last,
             bool wrap,
             spectral::Image *destImage);

    virtual void Process(void);

private:
    const spectral::Image *m_sourceImage;
    spectral::Image       *m_destImage;
    const std::vector<float> &m_kernel;
    const uint32_t m_first, m_last;
    const bool m_wrap;
};


class VPassJob : public thread::Job
{
public:
    VPassJob(const spectral::Image *sourceImage, 
             const std::vector<float> &kernel,
             uint32_t first,
             uint32_t last,
             bool wrap,
             spectral::Image *destImage);

    virtual void Process(void);

private:
    const spectral::Image *m_sourceImage;
    spectral::Image       *m_destImage;
    const std::vector<float> &m_kernel;
    const uint32_t m_first, m_last;
    const bool m_wrap;
};


class MlFilterFarmer : public thread::Farmer
{
public:
    MlFilterFarmer(MlFilter*,
                   float initialProgress,
                   float jobWeight);
    virtual void ProcessCompletedJob(thread::Job *);
private:
    MlFilter *m_owner;
    float m_initialProgress, m_jobWeight;
};



class MlFilter : public spectral::Processor
{
public:
    MlFilter();
    ~MlFilter();

    // 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 spectral::Image *img);

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

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

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

protected:

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

private:
    void ClearLayers(void);
    spectral::Image *CreateLayer(const spectral::Image *input, uint32_t layer, float start, float weight);

    const spectral::Image *m_lumImage;
    std::vector<spectral::Image *>m_layers;
    float  m_tolerance;
    int32_t m_num_layers;
    bool m_wrap_horizontal, m_wrap_vertical;
    bool m_density;
};

}

#endif

---