---

rgbimage.cpp

/**********************************************************************************
* Copyright (c) 2003, Christoph Rueegg <opendev@cdrnet.ch> and Matthias Bader     *
* Partially based on ideas of Tim Weyrich <weyrich@inf.ethz.ch>                   *
* and/or the Swiss Federal Institute of Technology http://www.ethz.ch             *
* All rights reserved.                                                            *
*                                                                                 *
* Project Website: http://www.cdrnet.net/projects/painter/                        *
*                                                                                 *
* Redistribution and use in source and binary forms, with or without modification,*
* are permitted provided that the following conditions are met:                   *
*                                                                                 *
* 1. Redistributions of source code must retain the above copyright notice,       *
* this list of conditions and the following disclaimer.                           *
*                                                                                 *
* 2. Redistributions in binary form must reproduce the above copyright notice,    *
* this list of conditions and the following disclaimer in the documentation       *
* and/or other materials provided with the distribution.                          *
*                                                                                 *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"     *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE       *
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE      *
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE        *
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR             *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF            *
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS        *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN         *
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)         *
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF          *
* THE POSSIBILITY OF SUCH DAMAGE.                                                 *
**********************************************************************************/

#include "rgbimage.h"
#include "alphaimage.h"
#include "hybridchannel.cpp"

RgbImage::RgbImage(HybridRgbaChannel<unsigned char>* red, HybridRgbaChannel<unsigned char>* green, HybridRgbaChannel<unsigned char>* blue): AlphaImage(red->GetHeight(),red->GetWidth())
{
  reddata = red;
  greendata = green;
  bluedata = blue;
  redfilter = reddata;
  greenfilter = greendata;
  bluefilter = bluedata;
  reddata->SetId(1);
  greendata->SetId(2);
  bluedata->SetId(3);
}

RgbImage::RgbImage(const int height, const int width): AlphaImage(height,width)
{
  reddata = new HybridRgbaChannel<unsigned char>(height,width);
  greendata = new HybridRgbaChannel<unsigned char>(height,width);
  bluedata = new HybridRgbaChannel<unsigned char>(height,width);
  redfilter = reddata;
  greenfilter = greendata;
  bluefilter = bluedata;
  reddata->SetId(1);
  greendata->SetId(2);
  bluedata->SetId(3);
}

RgbImage::~RgbImage()
{
  delete bluedata;
  delete greendata;
  delete reddata;
}        

inline unsigned char RgbImage::GetLuminance(const int x, const int y)
{
  return(char(float(reddata->Get(x,y)+greendata->Get(x,y)+bluedata->Get(x,y))/3.0f));
}

inline void RgbImage::SetLuminance(const int x, const int y, const unsigned char val)
{
  redfilter->Set(x,y,val);
  greenfilter->Set(x,y,val);
  bluefilter->Set(x,y,val);
}

inline unsigned char RgbImage::GetRed(const int x, const int y)
{
  return(redfilter->Get(x,y));
}

inline void RgbImage::SetRed(const int x, const int y, const unsigned char val)
{
  redfilter->Set(x,y,val);
}

inline unsigned char RgbImage::GetGreen(const int x, const int y)
{
  return(greenfilter->Get(x,y));
}

inline void RgbImage::SetGreen(const int x, const int y, const unsigned char val)
{
  greenfilter->Set(x,y,val);
}

inline unsigned char RgbImage::GetBlue(const int x, const int y)
{
  return(bluefilter->Get(x,y));
}

inline void RgbImage::SetBlue(const int x, const int y, const unsigned char val)
{
  bluefilter->Set(x,y,val);
}

void RgbImage::AttachLuminanceFilter(ChannelFilter<unsigned char>* filter)
{
  ChannelFilter<unsigned char>* filter2 = filter->EmptyClone();
  ChannelFilter<unsigned char>* filter3 = filter->EmptyClone();  
  AttachRedFilter(filter);
  AttachGreenFilter(filter2);
  AttachBlueFilter(filter3);
}

void RgbImage::RemoveLuminanceFilters()
{
  RemoveRedFilters();
  RemoveGreenFilters();
  RemoveBlueFilters();
}

void RgbImage::AttachRedFilter(ChannelFilter<unsigned char>* filter)
{
  filter->SetSubChannel(redfilter);
  redfilter = filter;
  filter->SetId(1);
}

void RgbImage::RemoveRedFilters()
{
  redfilter->ResetChannel();
  redfilter = reddata;
}

void RgbImage::AttachGreenFilter(ChannelFilter<unsigned char>* filter)
{
  filter->SetSubChannel(greenfilter);
  greenfilter = filter;
  filter->SetId(2);
}

void RgbImage::RemoveGreenFilters()
{
  greenfilter->ResetChannel();
  greenfilter = greendata;
}

void RgbImage::AttachBlueFilter(ChannelFilter<unsigned char>* filter)
{
  filter->SetSubChannel(bluefilter);
  bluefilter = filter;
  filter->SetId(3);
}

void RgbImage::RemoveBlueFilters()
{
  bluefilter->ResetChannel();
  bluefilter = bluedata;
}

double RgbImage::Draw()
{
  GLdouble xFract, yFract, zoom;
  GLint vp[4];
  glGetIntegerv(GL_VIEWPORT, vp);
  xFract = (GLdouble)vp[2] / reddata->GetWidth();
  yFract = (GLdouble)vp[3] / reddata->GetHeight();
  zoom = (xFract < yFract) ? xFract : yFract;
  if(zoom > 1.0)
    zoom = (int)zoom;
  /* set up OpenGL projection matrix */
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0, reddata->GetWidth(), reddata->GetHeight(), 0, -1, 1);
  glMatrixMode(GL_MODELVIEW);
  /* set up memory alignment */
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  /* clear buffer and draw image */
  glClearColor(0.3,0.4,0.4,1.0);
  glClear(GL_COLOR_BUFFER_BIT);
  glRasterPos2d(0, 0);
  glPixelZoom(zoom, -zoom);
  glDrawPixels(reddata->GetWidth(), reddata->GetHeight(),GL_RGBA,GL_UNSIGNED_BYTE,*(reddata->GetRawRgbData()));
  glutSwapBuffers();
  return((double)zoom);
  //no output; clear buffers ...
  //glClear(GL_COLOR_BUFFER_BIT);
  //glutSwapBuffers();
  //return(1.0);
}

RgbImage* RgbImage::CreateFromTiff(const char* filename)
{
  TIFF *tif;
  if ((tif = TIFFOpen(filename, "r")) != NULL)
  {
    uint32 width, height;
    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
    TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
    HybridRgbaChannel<unsigned char>* red = new HybridRgbaChannel<unsigned char>(height,width);
    HybridRgbaChannel<unsigned char>* green = (HybridRgbaChannel<unsigned char>*) red->EmptyClone();
    HybridRgbaChannel<unsigned char>* blue = (HybridRgbaChannel<unsigned char>*) red->EmptyClone();
    red->SetId(1);
    green->SetId(2);
    blue->SetId(3);
    RgbImage* result = new RgbImage(red,green,blue);
    uint32 *buf = new uint32[width*height];
    if (TIFFReadRGBAImage(tif, width, height, buf, 0))
    {
      uint32  *p;
      int q,c;
      for (p=buf+width*(height-1),q=0;p >= buf;p-=width, q++)
        for (c=width-1; c>=0; c--)
        {
          red->Set(c,q,(unsigned char)TIFFGetR(p[c]));
          green->Set(c,q,(unsigned char)TIFFGetG(p[c]));
          blue->Set(c,q,(unsigned char)TIFFGetB(p[c]));
        }  
    }
    else
    {
      delete result;
      result = 0;
    }
    delete [] buf;
    TIFFClose(tif);
    return result;
  }
  return 0;
}

void RgbImage::WriteToTiff(const char* filename)
{
  TIFF  *tif;
  if ((tif = TIFFOpen(filename, "w")) != NULL)
  {
    int  y;

    TIFFSetField(tif, TIFFTAG_SUBFILETYPE, 0);
    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, GetWidth());
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, GetHeight());
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 4);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8, 8, 8, 8);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
    TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, filename);
    TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Created With My Personal Painter Application :-)");
    TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 64);
    TIFFSetField(tif, TIFFTAG_XRESOLUTION, 75.0);
    TIFFSetField(tif, TIFFTAG_YRESOLUTION, 75.0);
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
    RgbaPixel<unsigned char> *data = *(reddata->GetRawRgbData());
    for (y=0; y<GetHeight(); y++)
      if (TIFFWriteScanline(tif, data+y*GetWidth(), y, 0) < 0)
        break;
    if (y < GetHeight())
      cerr << "Error while writing to TIFF file." << endl;
    TIFFClose(tif);
  }
  else
    cerr << "Couldn't open `" << filename << "' for writing." << endl;
}

---