MapperFunction.h

Go to the documentation of this file.

//************************************************************************
//                                  *
//           Copyright (C)  2004                *
//     University Corporation for Atmospheric Research          *
//           All Rights Reserved                *
//                                  *
//************************************************************************/
//
//  File:       MapperFunction.h
//
//  Author:     Alan Norton
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       August 2005
//
//  Description:    Defines the MapperFunction class
//      This is the mathematical definition of a function
//      that can be used to map data to either colors or opacities
//      Subclasses can either implement color or transparency
//      mapping (or both), and/or identify one or more isovalues.
 
#ifndef MAPPERFUNCTION_H
#define MAPPERFUNCTION_H
 
#include <vapor/OpacityMap.h>
#include <vapor/ColorMap.h>
#include <vapor/TFInterpolator.h>
#include <vapor/ParamsBase.h>
 
namespace VAPoR {
 
class XmlNode;
class ParamNode;
 
class PARAMS_API MapperFunction : public ParamsBase {
public:
    MapperFunction(ParamsBase::StateSave *ssave);
 
    MapperFunction(ParamsBase::StateSave *ssave, XmlNode *node);
 
    MapperFunction(const MapperFunction &rhs);
 
    MapperFunction &operator=(const MapperFunction &rhs);
 
    virtual ~MapperFunction();
 
    //
    int SaveToFile(string path);
 
    //
    int LoadFromFile(string path);
 
    int LoadColormapFromFile(string path);
 
    // Get static string identifier for this params class
    //
    static string GetClassType() { return ("MapperFunctionParams"); }
 
    float getOpacityValueData(float point) const;
 
    void hsvValue(float point, float *h, float *sat, float *val) const;
 
    void rgbValue(float point, float rgb[3]) const
    {
        float hsv[3];
        hsvValue(point, hsv, hsv + 1, hsv + 2);
        hsvToRgb(hsv, rgb);
    }
 
    void rgbaValue(float point, float rgba[4]) const
    {
        float hsv[3];
        hsvValue(point, hsv, hsv + 1, hsv + 2);
        hsvToRgb(hsv, rgba);
        rgba[3] = getOpacityValueData(point);
    }
 
    void setOpaque();
 
    bool isOpaque() const;
 
    void makeLut(float *clut) const;
 
    void makeLut(std::vector<float> &clut) const;
    std::vector<float> makeLut() const;
 
    float getMinMapValue() const { return (getMinMaxMapValue()[0]); };
 
    float getMaxMapValue() const { return (getMinMaxMapValue()[1]); };
 
    void setMinMaxMapValue(float val1, float val2);
 
    void setMinMapValue(float val) { setMinMaxMapValue(val, getMaxMapValue()); }
 
    void setMaxMapValue(float val) { setMinMaxMapValue(getMinMapValue(), val); }
 
    vector<double> getMinMaxMapValue() const;
 
    vector<double> GetCustomMappingSliderRange() const;
    bool           IsUsingCustomMappingSliderRange() const;
 
    void SetCustomMappingSliderRange(const vector<double> &range);
    void SetUsingCustomMappingSliderRange(bool b);
 
    virtual OpacityMap *createOpacityMap(OpacityMap::Type type = OpacityMap::CONTROL_POINT);
 
    //
    void DeleteOpacityMap(const OpacityMap *omap);
 
    virtual OpacityMap *GetOpacityMap(int index) const;
 
    int getNumOpacityMaps() const { return (m_opacityMaps->Size()); };
 
    void setOpacityScale(double val) { SetValueDouble(_opacityScaleTag, "Set Opacity Scale", val); }
 
    double getOpacityScale() const { return GetValueDouble(_opacityScaleTag, 1.0); }
 
    enum CompositionType { ADDITION = 0, MULTIPLICATION = 1 };
 
    void setOpacityComposition(CompositionType t) { SetValueLong(_opacityCompositionTag, "Set Opacity Composition Type", (long)t); }
 
    CompositionType getOpacityComposition() const { return (CompositionType)GetValueLong(_opacityCompositionTag, ADDITION); }
 
    static void hsvToRgb(float *hsv, float *rgb);
 
    static void rgbToHsv(float *rgb, float *hsv);
    static vector<float> rgbToHsv(vector<float> rgb);
 
    int getNumEntries() const { return _numEntries; }
 
    int mapFloatToIndex(float point) const
    {
        int indx = mapPosition(point, getMinMapValue(), getMaxMapValue(), _numEntries - 1);
        if (indx < 0) indx = 0;
        if (indx > _numEntries - 1) indx = _numEntries - 1;
        return indx;
    }
 
    float mapIndexToFloat(int indx) const { return (float)(getMinMapValue() + ((float)indx) * (float)(getMaxMapValue() - getMinMapValue()) / (float)(_numEntries - 1)); }
 
    TFInterpolator::type getColorInterpType()
    {
        ColorMap *cmap = GetColorMap();
        if (cmap) return cmap->GetInterpType();
        return TFInterpolator::diverging;
    }
 
    void setColorInterpType(TFInterpolator::type t)
    {
        ColorMap *cmap = GetColorMap();
        if (cmap) cmap->SetInterpType(t);
    }
 
    void setUseWhitespace(int state)
    {
        ColorMap *cmap = GetColorMap();
        if (cmap) cmap->SetUseWhitespace(state);
    }
 
    int getUseWhitespace() const
    {
        ColorMap *cmap = GetColorMap();
        return cmap->GetUseWhitespace();
    }
 
    virtual ColorMap *GetColorMap() const { return (m_colorMap); }
 
    //
    bool GetAutoUpdateHisto() { return ((bool)GetValueLong(_autoUpdateHistoTag, (int)false)); }
 
    //
    void SetAutoUpdateHisto(bool val) { SetValueLong(_autoUpdateHistoTag, "enable/disable auto update of histogram", val); }
 
    bool GetSecondaryVarMapper() { return ((bool)GetValueLong(_autoUpdateHistoTag, (int)false)); }
 
    //
    void SetSecondaryVarMapper(bool val) { SetValueLong(_secondaryVarMapperTag, "Apply color through a secondary color", val); }
 
public:
    //
    // XML tags
    //
    static const string _dataBoundsTag;
    static const string _opacityCompositionTag;
    static const string _opacityScaleTag;
    static const string _opacityMapsTag;
    static const string _opacityMapTag;
    static const string _autoUpdateHistoTag;
    static const string _secondaryVarMapperTag;
    static const string CustomMappingSliderRangeTag;
    static const string IsUsingCustomMappingSliderRangeTag;
 
private:
    //
    // Size of lookup table.  Always 1<<8 currently!
    //
    const int _numEntries;
 
    ParamsContainer *m_opacityMaps;
    ColorMap *       m_colorMap;
 
    static int mapPosition(float x, float minValue, float maxValue, int hSize);
 
    // Construct name for new parent of opac map node, unique for this instance;
    string getNewOpacMapTag(int *tagIndex);
 
    // Construct a map tag for a specific index
    string getOpacMapTag(int index) const;
 
    // Extract the index from the opacity map tag
    int getOpacMapNum(string tag);
 
    string _make_omap_name(int index) const;
};
 
#ifdef VAPOR3_0_0_ALPHA
 
class PARAMS_API MFContainer : public MyBase {
public:
    MFContainer();
 
    //
    MFContainer(RenderParams *p, string tag);
 
    ~MFContainer();
 
    //
    void Insert(string name, MapperFunction *mf);
 
    MapperFunction *GetMF(string name) const;
 
    //
    void Clear();
 
    //
    void Erase(string name);
 
    //
    vector<string> GetNames() const;
 
private:
    RenderParams *_params;
    string        _tag;
};
#endif
 
};        // namespace VAPoR
#endif    // MAPPERFUNCTION_H