|| || || || || || || ||

---

GetRgbPixels.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_GetRgbPixels_h
#define Impala_Core_Array_GetRgbPixels_h

#include <string>
#include "Core/Array/Pattern/PatRgbOp.h"
#include "Core/Array/Trait/RgbLabel.h"
#include "Core/Array/Trait/RgbLabel60.h"
#include "Core/Array/Trait/RgbLabelN.h"
#include "Core/Array/Trait/RgbBinary.h"
#include "Core/Array/Trait/RgbDirect.h"
#include "Core/Array/Trait/RgbStretch.h"
#include "Core/Array/Trait/RgbLogMag.h"
#include "Core/Geometry/GeoIntType.h"
#include "Core/Array/PixMin.h"
#include "Core/Array/PixMax.h"
#include "Core/Array/PixStat.h"
#include "Core/Array/PixMinMax.h"
#include "Core/Array/Element/E1Min.h"
#include "Core/Array/Element/E1Max.h"

#undef max

namespace Impala
{
namespace Core
{
namespace Array
{


template<class ArrayT>
inline void
GetRgbPixels(ArrayT* src, UInt8* pixels, std::string displayMode,
             int resWidth = -1, int resHeight = -1,
             Geometry::GeoIntType gi = Geometry::NEAREST)
{
    typedef typename ArrayT::ArithType ArithT;

    if (displayMode == std::string("Stretch"))
    {
        ArithT minVal, maxVal;
//      PixMinMax(src, &minVal, &maxVal);
        minVal = PixMin(src);
        maxVal = PixMax(src);
        Real64 lowVal = Element::E1Min(minVal);
        Real64 highVal = Element::E1Max(maxVal);
        //std::cout << "min = " << lowVal << " max = " << highVal << std::endl;
        Trait::RgbStretch<ArithT> rgbOpStretch(lowVal, highVal);
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpStretch);
    }
    else if (displayMode == std::string("Sigma"))
    {
        ArithT minVal, maxVal, mean, stdev;
        PixStat(src, &minVal, &maxVal, &mean, &stdev);
        //Real64 lowVal = Element::E1Min(minVal);
        Real64 lowVal = Element::E1Max(mean) - Element::E1Max(stdev) * 5;
        Real64 highVal = Element::E1Max(mean) + Element::E1Max(stdev) * 5;
        std::cout << "min " << minVal << " max " << maxVal << " mean " << mean 
                  << " stdev " << stdev
                  << " stretch " << lowVal << " - " << highVal << std::endl;
        Trait::RgbStretchClip<ArithT> rgbOpStretch(lowVal, highVal);
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpStretch);
    }
    else if (displayMode == std::string("StrMax"))
    {
        ArithT minVal, maxVal;
        PixMinMax(src, &minVal, &maxVal);
        Real64 lowVal = Element::E1Min(minVal);
        Real64 highVal = Element::E1Max(maxVal) / 4;
        Trait::RgbStretchClip<ArithT> rgbOpStretch(lowVal, highVal);
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpStretch);
    }
    else if (displayMode == std::string("LogMagnitude"))
    {
        ArithT minVal, maxVal;
        PixMinMax(src, &minVal, &maxVal);
        Real64 lowVal = Element::E1Min(minVal);
        Real64 highVal = Element::E1Max(maxVal);
        Trait::RgbLogMag<ArithT> rgbOpLogMag(lowVal, highVal);
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpLogMag);
    }
    else if (displayMode == std::string("Binary"))
    {
        Trait::RgbBinary<ArithT> rgbOpBinary;
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpBinary);
    }
    else if (displayMode == std::string("Label"))
    {
        Trait::RgbLabel<ArithT> rgbOpLabel;
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpLabel);
    }
    else if (displayMode == std::string("Label60"))
    {
        Trait::RgbLabel60<ArithT> rgbOpLabel60;
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpLabel60);
    }
    else if (displayMode == std::string("LabelN"))
    {
        Trait::RgbLabelN<ArithT> rgbOpLabelN;
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpLabelN);
    }
    else
    {
        // assume DirectNC
        Trait::RgbDirectNC<ArithT> rgbOpDirect;
        Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpDirect);
    }
}

template<class ArrayT>
inline void
GetRgbPixelsLM(ArrayT* src, UInt8* pixels, Real64 logScale,
               int resWidth = -1, int resHeight = -1,
               Geometry::GeoIntType gi = Geometry::NEAREST)
{
    typedef typename ArrayT::ArithType ArithT;

    ArithT val;
    val = PixMin(src);
    Real64 lowVal = Element::E1Min(val);
    val = PixMax(src);
    Real64 highVal = Element::E1Max(val);
    Trait::RgbLogMag<ArithT> rgbOpLogMag(lowVal, highVal, logScale);
    Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpLogMag);
}

template<class ArrayT>
inline void
GetRgbPixelsSt(ArrayT* src, UInt8* pixels, Real64 lowVal, Real64 highVal,
               int resWidth = -1, int resHeight = -1,
               Geometry::GeoIntType gi = Geometry::NEAREST)
{
    typedef typename ArrayT::ArithType ArithT;

    Trait::RgbStretchClip<ArithT> rgbOpStretch(lowVal, highVal);
    Pattern::PatRgbOp(src, pixels, resWidth, resHeight, gi, rgbOpStretch);
}

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---