---

equalization.h

Go to the documentation of this file.

#ifndef __INANNA_EQUALIZER_H__
#define __INANNA_EQUALIZER_H__

#include <magic/mobject.h>
#include <magic/mmath.h>
#include <magic/mmatrix.h>
#include <magic/mpararr.h>
#include <magic/mtextstream.h>

// XML format ios flag
extern int xmlflag;



//                 -----                  | o                               //
//                 |                 ___  |   ___  ___                      //
//                 |---   __  |   |  ___| | |   / /   ) |/\                 //
//                 |     /  \ |   | (   | | |  /  |---  |                   //
//                 |____ \__|  \__!  \__| | | /__  \__  |                   //
//                          |                                               //

class Equalizer : public Object {
    decl_dynamic (Equalizer);
  public:
                        Equalizer       () {mHandleMissing=false;}
                        Equalizer       (const Equalizer& o) {mHandleMissing=o.mHandleMissing;}
    
    virtual void        analyze         (const Vector& vec, bool additive=false) {MUST_OVERLOAD}

    virtual void        equalize        (Vector& vec) const  {MUST_OVERLOAD}

    virtual void        unequalize      (Vector& vec) const {MUST_OVERLOAD}

    virtual Equalizer*  clone           () const  {MUST_OVERLOAD; return NULL;}

    virtual TextOStream&    operator>>		(TextOStream&) const {MUST_OVERLOAD; return sout;}

    virtual void        handleMissing   (bool enable=true) {mHandleMissing=enable;}

  protected:
    bool    mHandleMissing;
};



//          |   | o                                      -----               //
//          |   |    ____  |                  ___        |                   //
//          |---| | (     -+-  __   ___  |/\  ___| |/|/| |---   __           //
//          |   | |  \__   |  /  \ (   \ |   (   | | | | |     /  \          //
//          |   | | ____)   \ \__/  ---/ |    \__| | | | |____ \__|          //
//                                  __/                           |          //

class HistogramEq : public Equalizer {
    decl_dynamic (HistogramEq);
  public:
                            HistogramEq (int precision=100000, double floor=0.0, double ceiling=1.0);
                            HistogramEq (const HistogramEq& orig);
    virtual HistogramEq*    clone       () const {return new HistogramEq (*this);}
    
    virtual void            analyze     (const Vector& vec, bool additive=false);
    virtual void            equalize    (Vector& vec) const;
    virtual void            unequalize  (Vector& vec) const;
    
    virtual TextOStream&    operator>>	(TextOStream&) const;

  private:
    static int      determineDomain (float x, int precision, float lowBound, float upBound);
    void            finalize        ();
    void            analyze2        (const Vector& vec);

    double          mLowBound;  // Bound in the unequalized data
    double          mUpBound;   // Bound in the unequalized data
    double          mMin;       // Desired lower bound in the equalized data
    double          mMax;       // Desired upper bound in the equalized data
    Array<Vector>   mData;      // Accumulated additive analysis data
    Vector          mHistogram; // Histogram formed by analysis
};



//           ----                         o             -----               //
//          |      ___         ____  ____    ___    _   |                   //
//          | ---  ___| |   | (     (     |  ___| |/ \  |---   __           //
//          |   \ (   | |   |  \__   \__  | (   | |   | |     /  \          //
//          |___/  \__|  \__! ____) ____) |  \__| |   | |____ \__|          //
//                                                               |          //

class GaussianEq : public Equalizer {
    decl_dynamic (GaussianEq);
  public:
                        GaussianEq  (double avg=0.0, double stddev=0.0) {mAverage=0; mStdDev=0;}
                        GaussianEq  (const GaussianEq& orig);
    virtual GaussianEq* clone       () const {return new GaussianEq (*this);}
    
    virtual void        analyze     (const Vector& vec, bool additive=false);
    virtual void        equalize    (Vector& vec) const;
    virtual void        unequalize  (Vector& vec) const;

  private:
    double  mAverage;
    double  mStdDev;
};



//                 |   | o                       -----                      //
//                 |\ /|     _          ___      |                          //
//                 | V | | |/ \  |/|/|  ___| \ / |---   __                  //
//                 | | | | |   | | | | (   |  X  |     /  \                 //
//                 |   | | |   | | | |  \__| / \ |____ \__|                 //
//                                                        |                 //

class MinmaxEq : public Equalizer {
    decl_dynamic (MinmaxEq);
  public:
                        MinmaxEq    (double trgMin=0.0, double trgMax=1.0);
                        MinmaxEq    (const MinmaxEq& orig);
    virtual MinmaxEq*   clone       () const {return new MinmaxEq (*this);}
    
    virtual void        analyze     (const Vector& vec, bool additive=false);
    virtual void        equalize    (Vector& vec) const;
    virtual void        unequalize  (Vector& vec) const;
    
    virtual TextOStream&    operator>>	(TextOStream& out) const;

    virtual TextIStream&    operator<<	(TextIStream& in);
    
  private:
    double  mTrgMin;
    double  mTrgMax;
    double  mDataMin;
    double  mDataMax;
};



//    |   |               o     -----                  | o                  //
//    |\ /|  ___   |            |                 ___  |   ___  ___         //
//    | V |  ___| -+- |/\ | \ / |---   __  |   |  ___| | |   / /   ) |/\    //
//    | | | (   |  |  |   |  X  |     /  \ |   | (   | | |  /  |---  |      //
//    |   |  \__|   \ |   | / \ |____ \__|  \__!  \__| | | /__  \__  |      //
//                                       |                                  //

class MatrixEqualizer : public Equalizer {
    decl_dynamic (MatrixEqualizer);
  public:

                        MatrixEqualizer     (Equalizer* prototype=NULL);

    void                analyze             (const Matrix& mat, bool additive=false);

    void                equalize            (Matrix& mat) const;

    void                unequalize          (Matrix& mat) const;

    const Equalizer&    getPlane            (int plane) const {return *mPlaneEqualizers.getp(plane);}

    int                 planes              () const {return mPlaneEqualizers.size();}
    
    virtual TextOStream&    operator>>	(TextOStream& out) const;

    virtual TextIStream&    operator<<	(TextIStream& in);

    virtual void        handleMissing   (bool enable=true);
    
  private:
    void                bothEqualize        (Matrix& mat, bool uneq) const;

    Array<Equalizer>    mPlaneEqualizers;
};


Equalizer* readEqualizer (TextIStream& in);

#endif

---