---

grayimage.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 "grayimage.h"
#include "alphaimage.h"

GrayImage::GrayImage(const int height, const int width): AlphaImage(height,width)
{
  luminancedata = new Channel<unsigned char>(height,width);
  luminancefilter = luminancedata;
}

GrayImage::~GrayImage()
{
  delete luminancedata;
}

inline unsigned char GrayImage::GetLuminance(const int x, const int y)
{
  return(luminancefilter->Get(x,y));
}

inline void GrayImage::SetLuminance(const int x, const int y, const unsigned char val)
{
  luminancefilter->Set(x,y,val);
}

void GrayImage::AttachLuminanceFilter(ChannelFilter<unsigned char>* filter)
{
  filter->SetSubChannel(luminancefilter);
  luminancefilter = filter;
}

void GrayImage::RemoveLuminanceFilters()
{
  luminancefilter->ResetChannel();
  luminancefilter = luminancedata;
}

double GrayImage::Draw()
{
  GLdouble xFract, yFract, zoom;
  GLint vp[4];
  glGetIntegerv(GL_VIEWPORT, vp);
  xFract = (GLdouble)vp[2] / luminancedata->GetWidth();
  yFract = (GLdouble)vp[3] / luminancedata->GetHeight();
  zoom = (xFract < yFract) ? xFract : yFract;
  if(zoom > 1.0)
    zoom = (int)zoom;
  /* set up OpenGL projection matrix */
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0, luminancedata->GetWidth(), luminancedata->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(luminancedata->GetWidth(), luminancedata->GetHeight(),GL_LUMINANCE,GL_UNSIGNED_BYTE,*(luminancedata->GetRawData()));
  glutSwapBuffers();
  return((double)zoom);
}   

GrayImage* GrayImage::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);
    GrayImage* result = new GrayImage(height,width);
    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--)
          result->SetLuminance(c,q,(unsigned char)(((65536*30/100)*TIFFGetR(p[c])+(65536*59/100)*TIFFGetG(p[c])
            +(65536*11/100)*TIFFGetB(p[c]))/65536));
    }
    else
    {
      delete result;
      result = 0;
    }
    delete [] buf;
    TIFFClose(tif);
    return result;
  }
  return 0;
}

void GrayImage::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, 1);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
    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);
    unsigned char *data = *(luminancedata->GetRawData());
    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;
}

---