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

---

GetColorChannels.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_GetColorChannels_h
#define Impala_Core_Feature_GetColorChannels_h

#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/Rgb2Ooo.h"
#include "Core/Array/RGB2rg.h"
#include "Core/Array/ColorSpace.h"
#include "Core/Array/ProjectRange.h"
#include "Core/Array/PixSum.h"
#include "Core/Array/PixMax.h"
#include "Core/Array/Add.h"
#include "Core/Array/Sub.h"
#include "Core/Array/Div.h"
#include "Core/Array/Mul.h"
#include "Core/Array/MulVal.h"
#include "Core/Array/AddVal.h"
#include "Core/Array/Atan2.h"
#include "Core/Array/ProjectParameterizedColor.h"
#include "Core/Array/Element/Color.h"
#include "Util/StringParser.h"

#include <set>

namespace Impala
{
namespace Core
{
namespace Feature
{

void
Normalize(Array::Array2dScalarReal64* im)
{
    Real64 maxVal = PixMax(im);
    if(abs(maxVal) < 0.000001)
        maxVal = 1.0;
    MulVal(im, im, 1. / maxVal);
}

std::vector<Array::Array2dScalarReal64*>
GetColorChannels(Array::Array2dVec3Real64* input, String colorModel)
{
    ILOG_FUNCTION(Impala.Core.Feature.GetColorChannels);
    ILOG_DEBUG("colorModel="<< colorModel);
    std::vector<Array::Array2dScalarReal64*> output;
    if((colorModel == "") || (colorModel == "no") ||
       (colorModel == "rg") || (colorModel == "hsv"))
    {
        Array::Array2dScalarReal64* imIntensity = 0;
        RGB2Intensity(imIntensity, input);
        // scale intensity to the range 0..1 instead of 0..255 so it is
        // comparable to Matlab
        Normalize(imIntensity);
        output.push_back(imIntensity);
    }
    if(colorModel == "rg")
    {
        Array::Array2dVec3Real64* rg = 0;
        RGB2rg(rg, input);
        Array::Array2dScalarReal64* r = 0;
        ProjectRange(r, rg, 1);
        output.push_back(r);
        Array::Array2dScalarReal64* g = 0;
        ProjectRange(g, rg, 2);
        output.push_back(g);
        delete rg;
    }
    if(colorModel == "opponent")
    {
        Array::Array2dVec3Real64* ooo = 0;
        Rgb2Ooo(ooo, input);

        Array::Array2dScalarReal64* intensity = 0;
        ProjectRange(intensity, ooo, 1);
        Normalize(intensity);
        output.push_back(intensity);

        Array::Array2dScalarReal64* redGreen = 0;
        ProjectRange(redGreen, ooo, 2);
        MulVal(redGreen, redGreen, 1 / 80.0);
        AddVal(redGreen, redGreen, 0.5);
        output.push_back(redGreen);

        Array::Array2dScalarReal64* blueYellow = 0;
        ProjectRange(blueYellow, ooo, 3);
        MulVal(blueYellow, blueYellow, 1 / 80.0);
        AddVal(blueYellow, blueYellow, 0.5);
        output.push_back(blueYellow);
        delete ooo;
    }
    if((colorModel == "w") || (colorModel == "c"))
    {
        Array::Array2dVec3Real64* ooo = 0;
        Rgb2Ooo(ooo, input);

        Array::Array2dScalarReal64* intensity = 0;
        ProjectRange(intensity, ooo, 1);
        Real64 maxVal = PixMax(intensity);
        if(abs(maxVal) < 0.000001)
            maxVal = 1.0;
        AddVal(intensity, intensity, 1.0);    // add 1 to prevent division by 0
        MulVal(intensity, intensity, 1 / maxVal);
        output.push_back(intensity);

        Array::Array2dScalarReal64* redGreen = 0;
        ProjectRange(redGreen, ooo, 2);
        Div(redGreen, redGreen, intensity);   // divide by intensity
        MulVal(redGreen, redGreen, 1 / 900.0);
        AddVal(redGreen, redGreen, 0.5);
        output.push_back(redGreen);

        Array::Array2dScalarReal64* blueYellow = 0;
        ProjectRange(blueYellow, ooo, 3);
        Div(blueYellow, blueYellow, intensity);   // divide by intensity
        MulVal(blueYellow, blueYellow, 1 / 900.0);
        AddVal(blueYellow, blueYellow, 0.5);
        output.push_back(blueYellow);
        delete ooo;
    }
    if(colorModel == "hsv")
    {
        /* Bosch CIVR 2007 */
        Array::Array2dVec3Real64* hsv = 0;
        ColorSpace(hsv, input, Array::Element::RGB, Array::Element::HSI);

        Array::Array2dScalarReal64* hue = 0;
        ProjectRange(hue, hsv, 1);
        MulVal(hue, hue, 1 / (2 * 3.14159265));
        output.push_back(hue);

        Array::Array2dScalarReal64* saturation = 0;
        ProjectRange(saturation, hsv, 2);
        output.push_back(saturation);
        delete hsv;
    }
    if(colorModel == "transformedcolor")
    {
        for (int d=1 ; d<=input->ElemSize() ; d++)
        {
            Array::Array2dScalarReal64* comp = 0;
            ProjectRange(comp, input, d);
            Real64 pixelCount = comp->CW() * comp->CH();
            Real64 mu = PixSum(comp) / pixelCount;
            AddVal(comp, comp, -mu);
            Array::Array2dScalarReal64* stddev = 0;
            Mul(stddev, comp, comp);    // square it -> (x - mu)^2
            Real64 standardDeviation = sqrt(PixSum(stddev) / pixelCount);
            delete stddev;
            if(standardDeviation < 0.00001)
                standardDeviation = 1.0;
            // scale [-2std,2std] to [-0.5,0.5]
            MulVal(comp, comp, (1.0 / standardDeviation) / 4.0);
            AddVal(comp, comp, 0.5);
            output.push_back(comp);
        }
    }
    if(colorModel == "rgb")
    {
        for(int channel=1 ; channel<=input->ElemSize() ; ++channel)
        {
            Array::Array2dScalarReal64* a = 0;
            ProjectRange(a, input, channel);
            output.push_back(a);
        }
    }
    if(colorModel.substr(0, 7) == "tunergb")
    {
        Array::Array2dVec3Real64* realImage = 0;
        MulVal(realImage, input, 1.0);
        Util::StringParser sp(colorModel.substr(7, colorModel.size()));
        while(!sp.TheEnd())
        {
            String colorChannel = sp.GetString('+', false);
            Util::StringParser sp2(colorChannel);
            Real64 a = sp2.GetDouble('x', true, true);
            Real64 b = sp2.GetDouble('x', true, true);
            Real64 c = sp2.GetDouble('x', true, true);
            Real64 d = sp2.GetDouble('x', true, true);
            Real64 e = sp2.GetDouble('x', true, true);
            Real64 f = sp2.GetDouble('x', true, true);
            Real64 g = sp2.GetDouble('x', false);
            Array::Array2dScalarReal64* channel = 0;
            ProjectParameterizedColor(channel, realImage, a, b, c, d, e, f, g);
            output.push_back(channel);
        }
        delete realImage;
    }
    if(colorModel.substr(0, 9) == "tunechan-")
    {
        Util::StringParser sp(colorModel.substr(9, colorModel.size()));
        std::set<String> channels;
        std::vector<String> orderedChannels;
        while(!sp.TheEnd())
        {
            String colorChannel = sp.GetString('-', false);
            channels.insert(colorChannel);
            orderedChannels.push_back(colorChannel);
        }
        if(channels.find("i") != channels.end())
        {
            // convert to intensity image
            Array::Array2dScalarReal64* intensity = 0;
            RGB2Intensity(intensity, input);
            Normalize(intensity);
            output.push_back(intensity);
        }
        if(channels.find("r") != channels.end())
        {
            Array::Array2dScalarReal64* r = 0;
            ProjectRange(r, input, 1);
            output.push_back(r);
        }
        if(channels.find("g") != channels.end())
        {
            Array::Array2dScalarReal64* g = 0;
            ProjectRange(g, input, 2);
            output.push_back(g);
        }
        if(channels.find("b") != channels.end())
        {
            Array::Array2dScalarReal64* b = 0;
            ProjectRange(b, input, 3);
            output.push_back(b);
        }
        if((channels.find("rg") != channels.end()) ||
           (channels.find("rb") != channels.end()) ||
           (channels.find("rm") != channels.end()) ||
           (channels.find("ry") != channels.end()) ||
           (channels.find("gb") != channels.end()) ||
           (channels.find("gy") != channels.end()))
        {
            Array::Array2dScalarReal64* r = 0;
            ProjectRange(r, input, 1);
            Array::Array2dScalarReal64* g = 0;
            ProjectRange(g, input, 2);
            Array::Array2dScalarReal64* b = 0;
            ProjectRange(b, input, 3);
            if(channels.find("rg") != channels.end())
            {
                Array::Array2dScalarReal64* rg = 0;
                Sub(rg, r, g);
                output.push_back(rg);
            }
            if(channels.find("rb") != channels.end())
            {
                Array::Array2dScalarReal64* rb = 0;
                Sub(rb, r, b); 
                output.push_back(rb);
            }
            if(channels.find("gb") != channels.end())
            {
                Array::Array2dScalarReal64* gb = 0;
                Sub(gb, g, b); 
                output.push_back(gb);
            }
            if(channels.find("rm") != channels.end())
            {
                Array::Array2dScalarReal64* rm = 0;
                Add(rm, r, g); 
                output.push_back(rm);
            }
            if(channels.find("ry") != channels.end())
            {
                Array::Array2dScalarReal64* ry = 0;
                Add(ry, r, b); 
                output.push_back(ry);
            }
            if(channels.find("gy") != channels.end())
            {
                Array::Array2dScalarReal64* gy = 0;
                Add(gy, g, b); 
                output.push_back(gy);
            }
            delete r;
            delete g;
            delete b;
        }
        if(channels.find("o1") != channels.end() ||
           channels.find("o2") != channels.end())
        {
            Array::Array2dVec3Real64* ooo = 0;
            Rgb2Ooo(ooo, input);
            if(channels.find("o1") != channels.end())
            {
                Array::Array2dScalarReal64* redGreen = 0;
                ProjectRange(redGreen, ooo, 2);
                MulVal(redGreen, redGreen, 1 / 80.0);
                AddVal(redGreen, redGreen, 0.5);
                output.push_back(redGreen);
            }
            if(channels.find("o2") != channels.end())
            {
                Array::Array2dScalarReal64* blueYellow = 0;
                ProjectRange(blueYellow, ooo, 3);
                MulVal(blueYellow, blueYellow, 1 / 80.0);
                AddVal(blueYellow, blueYellow, 0.5);
                output.push_back(blueYellow);
            }
            delete ooo;
        }
        if(channels.find("c1") != channels.end() ||
           channels.find("c2") != channels.end())
        {
            Array::Array2dVec3Real64* ooo = 0;
            Rgb2Ooo(ooo, input);
            /* first channel: intensity (0..270) */
            Array::Array2dScalarReal64* intensity = 0;
            ProjectRange(intensity, ooo, 1);
            Real64 maxVal = PixMax(intensity);
            if(abs(maxVal) < 0.000001)
                maxVal = 1.0;
            AddVal(intensity, intensity, 1.0);
            MulVal(intensity, intensity, 1 / maxVal);
            if(channels.find("c1") != channels.end())
            {
                Array::Array2dScalarReal64* redGreen = 0;
                ProjectRange(redGreen, ooo, 2);
                Div(redGreen, redGreen, intensity);   // divide by intensity
                MulVal(redGreen, redGreen, 1 / 900.0);
                AddVal(redGreen, redGreen, 0.5);
                output.push_back(redGreen);
            }
            if(channels.find("c2") != channels.end())
            {
                Array::Array2dScalarReal64* blueYellow = 0;
                ProjectRange(blueYellow, ooo, 3);
                Div(blueYellow, blueYellow, intensity); // divide by intensity
                MulVal(blueYellow, blueYellow, 1 / 900.0);
                AddVal(blueYellow, blueYellow, 0.5);
                output.push_back(blueYellow);
            }
            delete intensity;
            delete ooo;
        }
        
        if(channels.find("nr") != channels.end() ||
           channels.find("ng") != channels.end() ||
           channels.find("nb") != channels.end())
        {
            Array::Array2dVec3Real64* rg = 0;
            RGB2rg(rg, input);
            if(channels.find("nr") != channels.end())
            {
                Array::Array2dScalarReal64* r = 0;
                ProjectRange(r, rg, 1);
                output.push_back(r);
            }
            if(channels.find("ng") != channels.end())
            {
                Array::Array2dScalarReal64* g = 0;
                ProjectRange(g, rg, 2);
                output.push_back(g);
            }
            if(channels.find("nb") != channels.end())
            {
                Array::Array2dScalarReal64* b = 0;
                ProjectRange(b, rg, 3);
                output.push_back(b);
            }
            delete rg;
        }

        if(channels.find("p1") != channels.end())
        {
            // polar coordinates arctan(R/G)
            Array::Array2dScalarReal64* r = 0;
            ProjectRange(r, input, 1);
            Array::Array2dScalarReal64* g = 0;
            ProjectRange(g, input, 2);
            Array::Array2dScalarReal64* ratio = 0;
            Atan2(ratio, r, g);
            output.push_back(ratio);
            delete r;
            delete g;
        }
        if(channels.find("p2") != channels.end())
        {
            // polar coordinates arctan(R/B)
            Array::Array2dScalarReal64* r = 0;
            ProjectRange(r, input, 1);
            Array::Array2dScalarReal64* b = 0;
            ProjectRange(b, input, 3);
            Array::Array2dScalarReal64* ratio = 0;
            Atan2(ratio, r, b);
            output.push_back(ratio);
            delete r;
            delete b;
        }
        if(channels.find("p3") != channels.end())
        {
            // polar coordinates arctan(G/B)
            Array::Array2dScalarReal64* g = 0;
            ProjectRange(g, input, 2);
            Array::Array2dScalarReal64* b = 0;
            ProjectRange(b, input, 3);
            Array::Array2dScalarReal64* ratio = 0;
            Atan2(ratio, g, b);
            output.push_back(ratio);
            delete g;
            delete b;
        }
        for(std::vector<String>::iterator iter = orderedChannels.begin(); 
            iter != orderedChannels.end(); iter++)
        {
            String chan = *iter;
            if(StringStartsWith(chan,"seed"))
            {
                // we have a seed :)
                Util::StringParser sp2(chan.substr(4,chan.size()));
                String A = sp2.GetString(',', true);
                String B = sp2.GetString(',', true);
                String C = sp2.GetString(',', false);
                Real64 a = 0;
                Real64 b = 0;
                Real64 c = 0;
                if(A[0] == 'm')
                    a = -atof(A.substr(1,A.size()));
                else
                    a = atof(A);

                if(B[0] == 'm')
                    b = -atof(B.substr(1,B.size()));
                else
                    b = atof(B);

                if(C[0] == 'm')
                    c = -atof(C.substr(1,C.size()));
                else
                    c = atof(C);
                    
                ILOG_DEBUG("Seed a " << a << " b " << b << " c " << c);
                Array::Array2dScalarReal64* channel = 0;
                ProjectParameterizedColor(channel, input, a, b, c, 0, 0, 0, 1);
                output.push_back(channel);
            }
        }
    }
    return output;
}

std::vector<Array::Array2dScalarReal64*>
GetColorChannels(Array::Array2dVec3UInt8* inputInt, String colorModel)
{
    Array::Array2dVec3Real64* input = 0;
    MulVal(input, inputInt, 1.0);
    std::vector<Array::Array2dScalarReal64*> output = 
                                  GetColorChannels(input, colorModel);
    delete input;
    return output;
}

} // namespace Koen
} // namespace Sandbox
} // namespace Impala

#endif

---