processors/compressor/compressor.h

#ifndef __COMPRESSOR_H__
#define __COMPRESSOR_H__

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>

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

namespace compressor {

class Compressor : public spectral::Processor
{
public:
    Compressor();
    virtual ~Compressor();

    // 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 type, 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 type);

protected:

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

private:

    float tone_map(float (*cmp)(float, float *),
                   float *opts,
                   float clmin,
                   float clmax,
                   float ldmax,
                   float l);

    float local_tone_map(float (*cmp)(float, float *),
                         float *opts,
                         float clmin,
                         float clmax,
                         float ldmax,
                         float l,
                         float la,
                         float contrast = 1.0f);

    // compression functions.
    static float compress_ashikhmin(float l, float *options);
    static float compress_exponent(float l, float *options);
    static float compress_log(float l, float *options);
    static float compress_gamma(float l, float *options);
    static float compress_linear(float l, float *options);

    // data members
    const spectral::Image *m_picture, *m_lal;
    float m_min_luminance, m_max_luminance;
    float m_gamma;
    float m_contrast;
    float (*m_compression_function)(float, float *);
    int  m_discard_dark, m_discard_bright;
    bool m_normalise;
};

}

#endif

---