objectPalette.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
 
#ifndef ANA_COLOR_OBJECTPALETTE_H
#define ANA_COLOR_OBJECTPALETTE_H
 
#include <anatomist/color/palette.h>
#include <cartodata/volume/volume.h>
#include <aims/rgb/rgb.h>
#include <cartobase/object/object.h>
 
class QImage;
 
namespace anatomist
{
  class AObject;
  class GLComponent;
 
  class AObjectPalette
  {
  public:
    enum Palette1DMapping
    {
      FIRSTLINE,
      DIAGONAL
    };
 
    typedef AimsRGBA (*MixMethod)(
      const carto::Volume<AimsRGBA> & map1,
      const carto::Volume<AimsRGBA> *map2,
      unsigned x, unsigned y,
      const AObjectPalette & pal );
 
    AObjectPalette( carto::rc_ptr<APalette> pal );
    AObjectPalette( const AObjectPalette & x );
    virtual ~AObjectPalette();
 
    virtual AObjectPalette* clone() const;
 
    virtual AObjectPalette & operator = ( const AObjectPalette & x );
 
    carto::rc_ptr<APalette> refPalette( int dim = 0 ) const
    { if( dim == 1 ) return _refPal2; else return( _refPal ); }
    carto::rc_ptr<APalette> refPalette2() const { return( _refPal2 ); }
    void setRefPalette( int dim, carto::rc_ptr<APalette> pal )
    { if( dim == 1 ) setRefPalette2( pal );
      else setRefPalette1( pal ); }
    void setRefPalette( carto::rc_ptr<APalette> pal )
    { setRefPalette1( pal ); } // FIXME to be removed
    void setRefPalette1( carto::rc_ptr<APalette> pal )
    { if( _refPal != pal ) { clearColors(); _refPal = pal; } }
    void setRefPalette2( carto::rc_ptr<APalette> pal ) { _refPal2 = pal; }
    const carto::Volume<AimsRGBA>* colors() const
    { if( !_colors.get() ) const_cast<AObjectPalette *>(this)->fill();
      return _colors.get(); }
    carto::Volume<AimsRGBA>* colors()
    { if( !_colors.get() ) fill(); return _colors.get(); }
    void create( unsigned dimx, unsigned dimy = 1, unsigned dimz = 1, 
                 unsigned dimt = 1 );
    virtual void fill();
    double min1() const { return( _min ); }
    double max1() const { return( _max ); }
    double min2() const { return( _min2 ); }
    double max2() const { return( _max2 ); }
    double min( int dim = 0 ) const { return dim == 1 ? min2() : min1(); }
    double max( int dim = 0 ) const { return dim == 1 ? max2() : max1(); }
    int palette1DMapping() const { return (_palette1DMapping) ; }
    std::string palette1DMappingName() const 
    { return (_palette1DMapping == 1 ? "Diagonal" : "FirstLine" ) ; }
    void setMin1( double x )
    { _min = x; if( isnan( x ) || isinf( x ) ) _min = 0; }
    void setMax1( double x )
    { _max = x; if( isnan( x ) || isinf( x ) ) _max = 0; }
    void setMin2( double x ) { _min2 = x; }
    void setMax2( double x ) { _max2 = x; }
    void setMin( int dim, double x )
    { if( dim == 1 ) setMin2( x ); else setMin1( x ); }
    void setMax( int dim, double x )
    { if( dim == 1 ) setMax2( x ); else setMax1( x ); }

    double absMin1( const AObject * obj ) const;
    double absMax1( const AObject * obj ) const;
    double absMin2( const AObject * obj ) const;
    double absMax2( const AObject * obj ) const;
    double absMin( int dim, const AObject* obj ) const
    { return dim == 1 ? absMin2( obj ) : absMin1( obj ); }
    double absMax( int dim, const AObject* obj ) const
    { return dim == 1 ? absMax2( obj ) : absMax1( obj ); }

    void setAbsMin1( const AObject * obj, double x );
    void setAbsMax1( const AObject * obj, double x );
    void setAbsMin2( const AObject * obj, double x );
    void setAbsMax2( const AObject * obj, double x );
    void setAbsMin( int dim, const AObject *obj, double x )
    { if( dim == 1 ) setAbsMin2( obj, x ); else setAbsMin1( obj, x ); }
    void setAbsMax( int dim, const AObject *obj, double x )
    { if( dim == 1 ) setAbsMax2( obj, x ); else setAbsMax1( obj, x ); }

    double absMin1( const GLComponent *glcj ) const;
    double absMax1( const GLComponent *glc ) const;
    double absMin2( const GLComponent *glc ) const;
    double absMax2( const GLComponent *glc ) const;
    double absMin( int dim, const GLComponent *glc ) const
    { return dim == 1 ? absMin2( glc ) : absMin1( glc ); }
    double absMax( int dim, const GLComponent *glc ) const
    { return dim == 1 ? absMax2( glc ) : absMax1( glc ); }

    void setAbsMin1( const GLComponent *glc, double x );
    void setAbsMax1( const GLComponent *glc, double x );
    void setAbsMin2( const GLComponent *glc, double x );
    void setAbsMax2( const GLComponent *glc, double x );
    void setAbsMin( int dim, const GLComponent *glc, double x )
    { if( dim == 1 ) setAbsMin2( glc, x ); else setAbsMin1( glc, x ); }
    void setAbsMax( int dim, const GLComponent *glc, double x )
    { if( dim == 1 ) setAbsMax2( glc, x ); else setAbsMax1( glc, x ); }
 
    double relValue1( const AObject *obj, double absval ) const;
    double relValue2( const AObject *obj, double absval ) const;
    double relValue( int dim, const AObject *obj, double absval ) const
    { return dim == 1 ? relValue2( obj, absval ) : relValue1( obj, absval ); }
    double absValue1( const AObject *obj, double relval ) const;
    double absValue2( const AObject *obj, double relval ) const;
    double absValue( int dim, const AObject* obj, double relval ) const
    { return dim == 1 ? absValue2( obj, relval ) : absValue1( obj, relval ); }
 
    double relValue1( const GLComponent *glc, double absval ) const;
    double relValue2( const GLComponent *glc, double absval ) const;
    double relValue( int dim, const GLComponent *glc, double absval ) const
    { return dim == 1 ? relValue2( glc, absval ) : relValue1( glc, absval ); }
    double absValue1( const GLComponent *glc, double relval ) const;
    double absValue2( const GLComponent *glc, double relval ) const;
    double absValue( int dim, const GLComponent* glc, double relval ) const
    { return dim == 1 ? absValue2( glc, relval ) : absValue1( glc, relval ); }
 
    void setPalette1DMapping( Palette1DMapping palette1DMapping )
    { _palette1DMapping = palette1DMapping ; }
    void setPalette1DMappingName( std::string palette1DMappingName ) 
    { _palette1DMapping = ( palette1DMappingName == "FirstLine" ? 
                            FIRSTLINE : DIAGONAL ) ; }
    std::string mixMethodName() const { return( _mixMethodName ); }
    void setMixMethod( const std::string & name );
    double linearMixFactor() const { return( _linMixFactor ); }
    void setLinearMixFactor( double x ) { _linMixFactor = x; }
    bool is2dMode() const { return _mode2d; }
    void set2dMode( bool x ) { _mode2d = x; }
    bool isTransparent() const { return _transp; }
    AimsRGBA normColor( double x, double y = 0 ) const;
    AimsRGBA normColor( const Point2df & pos ) const;
    bool zeroCenteredAxis1() const { return _zeroCentered1; }
    bool zeroCenteredAxis2() const { return _zeroCentered2; }
    bool zeroCenteredAxis( int dim = 0 ) const
    { return dim == 1 ? zeroCenteredAxis2() : zeroCenteredAxis1(); }
    void setZeroCenteredAxis1( bool x ) { _zeroCentered1 = x; }
    void setZeroCenteredAxis2( bool x ) { _zeroCentered2 = x; }
    void setZeroCenteredAxis( int dim, bool x )
    { if( dim == 1 ) setZeroCenteredAxis2( x ); else setZeroCenteredAxis1( x );
    }
 
    static AimsRGBA palette2DMixMethod( const carto::Volume<AimsRGBA> & map1,
                                        const carto::Volume<AimsRGBA> *map2,
                                        unsigned x, unsigned y,
                                        const AObjectPalette & pal );
    static AimsRGBA linearMixMethod( const carto::Volume<AimsRGBA> & map1,
                                     const carto::Volume<AimsRGBA> *map2,
                                     unsigned x, unsigned y,
                                     const AObjectPalette & pal );
    static AimsRGBA geometricMixMethod( const carto::Volume<AimsRGBA> & map1,
                                        const carto::Volume<AimsRGBA> *map2,
                                        unsigned x, unsigned y,
                                        const AObjectPalette & pal );
    bool set( const carto::GenericObject & );
    carto::Object genericDescription() const;
    int maxSizeX() const { return _maxSizeX; }
    int maxSizeY() const { return _maxSizeY; }
    void setMaxSize( int maxsizex, int maxsizey );
    int glMaxSizeX() const { return _glMaxSizeX; }
    int glMaxSizeY() const { return _glMaxSizeY; }
    void glSetMaxSize( int glmaxsizex, int glmaxsizey );
    void clearColors();
    void copyColors( const AObjectPalette & pal );
    void copyOrFillColors( const AObjectPalette & pal );
 
    static std::map<std::string, MixMethod>     mixMethods;
    QImage* toQImage( int w = 0, int h = 0, double min1 = 0., double max1 = 1.,
                      double zero1 = 0.5, double min2 = 0., double max2 = 1.,
                      double zero2 = 0.5 ) const;
    carto::rc_ptr<carto::Volume<AimsRGBA> >
      toVolume( int w = 0, int h = 0, bool scaled = true ) const;
 
  protected:
    static std::map<std::string, MixMethod> defaultMixMethods();
 
    carto::rc_ptr<APalette> _refPal;
    carto::VolumeRef<AimsRGBA>        _colors;
    double              _min;
    double              _max;
    carto::rc_ptr<APalette> _refPal2;
    double              _min2;
    double              _max2;
    MixMethod          _mixMethod;
    std::string         _mixMethodName;
    double              _linMixFactor;
    Palette1DMapping    _palette1DMapping;
    bool                _mode2d;
    bool                _transp;
    int                 _maxSizeX;
    int                 _maxSizeY;
    int                 _glMaxSizeX;
    int                 _glMaxSizeY;
    bool                _zeroCentered1;
    bool                _zeroCentered2;
  };
 
}
 
 
#endif