/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/operator/ConversionOperators.cpp

Aller à la documentation de ce fichier.

/******************************************************************************
 *       __    _    _   _       _       _   _____                             *
 *       | \  / |  | | | |     | |     | |  | ___|                            *
 *       |  \/  |  | | | |     | |     | |  | |_                              *
 *       |      |  | | | |     | |     | |  |  _|                             *
 *       | |\/| |  | | | |__   | |__   | |  | |__                             *
 *       |_|  |_|  |_| |____|  |____|  |_|  |____|                            *
 * __________________________________________________________________________ *
 *                 Multifunctional Library For Image Processing               *
 *                                                                            *
 *                                                                            *
 *                                                                            *
 *      (c) Copyright 2007 by Humbert Florent                                 *
 *                                                                            *
 *      This program is free software; you can redistribute it and/or modify  *
 *      it under the terms of the GNU General Public License as published by  *
 *      the Free Software Foundation; only version 2 of the License.          *
 *                                                                            *
 *      This program is distributed in the hope that it will be useful,       *
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *      GNU General Public License for more details.                          *
 *                                                                            *
 *      You should have received a copy of the GNU General Public License     *
 *      along with this program; if not, write to the Free Software           *
 *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA             *
 *      02111-1307, USA.                                                      *
 ******************************************************************************/

#include "operator/ConversionOperators.hpp"
#include <iostream>

using namespace Millie;

void Millie::ModuleImageComplexToVisibleImage(Image & out, const ImageComplex& in)
{
  if(out.getNumComponents() != in.getNumComponents())
    throw IllegalArgument("ModuleImageComplexToVisibleImage");

  float max = 0;

  out.resize(in.getWidth(), in.getHeight());

  for(int canal = 0; canal< in.getNumComponents(); canal++)
  {
    for(int j = 0;  j< in.getHeight(); j++)
      for(int i=0; i < in.getWidth(); i++)
      {
        std::complex<float> tempo = in.getPixel(i,j, canal);
        if(log(1+std::norm(tempo)) > max)
          max = log(1+std::norm(tempo));
        out.setPixel(i, j, canal, log(1+std::norm(tempo)));
      }

    for(int j = 0;  j< out.getHeight(); j++)
      for(int i=0; i < out.getWidth(); i++)
      {
        out.setPixel(i, j, canal, 255 / max * out.getPixel(i,j, canal));
      }

  }


}



void Millie::RGBToHSL(ImageHSL& out, const ImageRGB& in)
{
 out.resize(in.getWidth(), in.getHeight());

 for(int j=0; j<in.getHeight(); j++)
  for(int i = 0; i<in.getWidth(); i++)
  {
    float r = in.getRedPixel(i,j)/ 255.0f;
    float g = in.getGreenPixel(i,j)/ 255.0f;
    float b = in.getBluePixel(i,j)/ 255.0f;
    float max = r;
    float min = r;
    if(max<g)
      max = g;
    if(max<b)
      max = b;
    if(min>g)
      min = g;
    if(min>b)
      min = b;
    float h;
    float s;
    float l;

    if(max==min)
     h = 0.0f;
    else if(max==r && g>=b)
      h = 60 * (g-b)/(max-min);
    else if(max==r && g<b)
      h = 60 * (g-b)/(max-min) + 360;
    else if(max==g)
      h = 60 * (b-r)/(max-min) + 120;
    else /*max == b*/
      h = 60 * (r-g) /(max-min) +240;

    l = 0.5 * (max+min);

    if(l==0 || max==min)
     s = 0;
    else
     if(l>0 && l<= 0.5)
      s = (max-min)/(2*l);
    else
     s = (max - min)/(2-2*l);

  out.setHuePixel(i,j,h);
  out.setSaturationPixel(i,j, s);
  out.setLightnessPixel(i,j, l);

  }
}

void Millie::HSLToRGB(ImageRGB& out, const ImageHSL& in)
{
 out.resize(in.getWidth(), in.getHeight());

 for(int j=0; j<in.getHeight(); j++)
  for(int i = 0; i<in.getWidth(); i++)
  {

     float h = in.getHuePixel(i,j);
     float s =  in.getSaturationPixel(i,j);
     float l =  in.getLightnessPixel(i,j);

    float r;
    float g;
    float b;

    float q;
    if(l<0.5f)
     q = l * (1.0f+s);
    else
     q = l + s - (l*s);

    float p = 2.0f * l -q;
    float hk = h/360.0f;

    float tr = hk + 1.0f/3.0f;
    float tg = hk;
    float tb = hk - 1.0f/3.0f;

    if(tr<0)
      tr++;
    if(tr>1)
      tr--;

    if(tg<0)
      tg++;
    if(tg>1)
      tg--;

    if(tb<0)
      tb++;
    if(tb>1)
      tb--;

    if(tr< 1.0f/6.0f)
     r = p + ((q-p) * 6.0f * tr);
    else if(tr<0.5f)
     r = q;
    else if(tr<2.0f/3.0f)
     r = p + ((q-p) * (2.0f / 3.0f - tr) * 6.0f);
    else
     r = p;

    if(tg< 1.0f/6.0f)
     g = p + ((q-p) * 6.0f * tg);
    else if(tg<0.5f)
     g = q;
    else if(tg<2.0f/3.0f)
     g = p + ((q-p) * (2.0f / 3.0f - tg) * 6.0f);
    else
     g = p;

    if(tb< 1.0f/6.0f)
     b = p + ((q-p) * 6.0f * tb);
    else if(tb<0.5f)
     b = q;
    else if(tb<2.0f/3.0f)
     b = p + ((q-p) * (2.0f / 3.0f - tb) * 6.0f);
    else
     b = p;

    out.setRedPixel(i,j,255 * r);
    out.setGreenPixel(i,j,255 * g);
    out.setBluePixel(i,j,255 * b);



  }
}

void Millie::RGBToYUV(ImageYUV& out, const ImageRGB& in)
{

 out.resize(in.getWidth(), in.getHeight());

 for(int j=0; j<in.getHeight(); j++)
  for(int i = 0; i<in.getWidth(); i++)
  {
    float R = in.getRedPixel(i,j);
    float G = in.getGreenPixel(i,j);
    float B = in.getBluePixel(i,j);

    float Y = 0.299 * R + 0.587 * G + 0.114 * B;
    float U =  -0.14713*R - 0.2886*G + 0.436 * B;
    float V = 0.615 * R - 0.51499 * G - 0.10001 * B;

    out.setYPixel(i,j, Y);
    out.setUPixel(i,j, U);
    out.setVPixel(i,j, V);

  }
}

void Millie::YUVToRGB(ImageRGB& out, const ImageYUV& in)
{

 out.resize(in.getWidth(), in.getHeight());

 for(int j=0; j<in.getHeight(); j++)
  for(int i = 0; i<in.getWidth(); i++)
  {
    float Y = in.getYPixel(i,j);
    float U = in.getUPixel(i,j);
    float V = in.getVPixel(i,j);

    float R = Y + 1.13983*V;
    float G = Y - 0.39466*U - 0.58060*V;
    float B = Y + 2.03211*U;

    out.setRedPixel(i,j, R);
    out.setBluePixel(i,j, B);
    out.setGreenPixel(i,j, G);

  }
}

---