Ejemplo n.º 1
0
//******************************************************************
void PNGImageIFile::setupPalette() 
  throw(ImageException, std::bad_alloc)
{
  png_color * cpal = 0;   //the c palette
  int color_num = 0;      //the number of entries in the palette
  RGBPixel tpixel;       //temporary pixel
  int counter = 0;        //counter for loops

  //get a pointer to the palette or throw
  if (!png_get_PLTE(png_ptr, info_ptr, &cpal, &color_num))
  {
    throw ImageException(IMAGE_FILE_READ_ERR);
  }
  
  //that went well so create the class palette
  if (!(palette = new (std::nothrow) RGBPalette(color_num)))
    throw std::bad_alloc();

  //May need to add something here to handle grayscale palette
  //stuff. CBB
  for(; counter < color_num; ++counter)
  {
    tpixel.setRed(cpal[counter].red);
    tpixel.setGreen(cpal[counter].green);
    tpixel.setBlue(cpal[counter].blue);
    palette->setEntry(counter, tpixel);
  }
}
Ejemplo n.º 2
0
void cbbViewImage::setData(dtkAbstractData* data) {
    DTK_D(cbbViewImage);

    if (!data) 
        return;

    Images::Image* image = static_cast<Images::Image*>(data->data());

    if (!image || image->dimension()!=2)
        return;

    using namespace Images;
    using namespace Images::Pixels;

    typedef RGB<unsigned char> RGBPixel;
    typedef Polymorphic::MultiDim<2> Images2D;
    typedef Images2D::MultiType<float,Images2D::MultiType<double,Images2D::MultiType<unsigned char,Images2D::MultiType<unsigned> > > > Scalar2D;
    typedef Images2D::MultiType<RGBPixel,Scalar2D> Accepted;

    typedef RGB<double>        RGBDouble;
    Accepted::Converter<RGBDouble> convert;
    const Image2D<RGBDouble>& im = convert(image);

    const IntensityMap<RGBDouble> map(im);
    QImage qim(im.dimx(),im.dimy(),QImage::Format_RGB888);
    const Image2D<RGBDouble>::Shape& shape = im.shape();
    for (typename Image2D<RGBDouble>::Shape::const_iterator i=shape.begin();i!=shape.end();++i) {
        RGBPixel pix = map(im(i));
        qim.setPixel(i(1),i(2),(pix.red() << 8 | pix.green()) << 8 | pix.blue());
    }

    QGraphicsPixmapItem* item = new QGraphicsPixmapItem(QPixmap::fromImage(qim));
    d->scene->addItem(item);
    d->view->show();
}
Ejemplo n.º 3
0
    void operator()(const Mat& mat, char* data) {
      ImageAccessor<RGBPixel> acc;
      typename Mat::const_row_iterator row = mat.row_begin();
      typename Mat::const_col_iterator col;
      char* i = data;
      for (; row != mat.row_end(); ++row) {
	for (col = row.begin(); col != row.end(); ++col) {
	  RGBPixel tmp = acc.get(col);
	  *(i++) = (unsigned char)tmp.red();
	  *(i++) = (unsigned char)tmp.green();
	  *(i++) = (unsigned char)tmp.blue();
	}
      }
    }
Ejemplo n.º 4
0
//***********************************************************
void PNGImageIFile::getPixel(long x, long y, AbstractPixel* inpixel)
    throw(ImageException, std::bad_alloc)
{
  
  if (Photometric == PHOTO_PALETTE)
  {
    unsigned char tpixel; // temporarily pixel
    unsigned short int tcolor; //temporary color
    RGBPixel entry;
    
    //get the raw pixel
    getRawPixel(x, y, &tpixel);
    
    //get the entry out of the palette.
    palette->getEntry(tpixel, entry);
    
    entry.getRed(tcolor);
    inpixel->setRed(tcolor);
    
    entry.getGreen(tcolor);
    inpixel->setGreen(tcolor);
    
    entry.getBlue(tcolor);
    inpixel->setBlue(tcolor);
    return;
  }
  else 
    if (Photometric == PHOTO_GRAY)
    {
      unsigned char tpixel;
      getRawPixel(x, y, &tpixel);
      inpixel->setGrey(tpixel);
      return;
    }
  else 
    if (Photometric == PHOTO_RGB)
    {
      unsigned char tpixel[3];
      getRawPixel(x, y, tpixel);
      inpixel->setRed(tpixel[0]);
      inpixel->setGreen(tpixel[1]);
      inpixel->setBlue(tpixel[2]);
      return;
    }

}
Ejemplo n.º 5
0
//****************************************************************
void PNGImageIFile::getScanline(long row, GreyPixel* inarray)
  throw(ImageException, std::bad_alloc)
{
  unsigned char * trow = 0;            //for 8 bit samples case
  short unsigned int * trow16 = 0;     //for 16 bit samples case
  short unsigned int color = 0;        //temporary color
  long int size(Width*samplesPerPixel);
  long int counter = 0;                //temporary counter
  RGBPixel tpixel;                    //temp pixel

  try
  {
    if (bitsPerSample != 16)
    {
      if(!(trow = new (std::nothrow) unsigned char[bytesperline]))
        throw std::bad_alloc();
      getRawScanline(row, trow);
    }
    else
    {
      if(!(trow16 = new (std::nothrow) short unsigned int [size]))
        throw std::bad_alloc();
      getRawScanline(row, trow16);
    }
    
    switch(Photometric)
    {
    case PHOTO_PALETTE:
      //check the palette
      if (!palette)
        throw ImageException(IMAGE_INVALID_OP_ERR);
      
      for(counter = 0; counter < Width; ++counter)
      {
          palette->getEntry(trow[counter], tpixel);
          
          tpixel.getRed(color);
          inarray[counter].setRed(color);
          tpixel.getGreen(color);
          inarray[counter].setGreen(color);
          tpixel.getBlue(color);
          inarray[counter].setBlue(color);

      }
      break;
    case PHOTO_RGB:
      //see if its 8 or 16 bit data
      if (bitsPerSample == 8)
      {
        for (counter = 0; counter < Width; ++counter)
        {
          inarray[counter].setRed(trow[counter*samplesPerPixel]);
          inarray[counter].setGreen(trow[counter*samplesPerPixel+1]);
          inarray[counter].setBlue(trow[counter*samplesPerPixel+2]);
        }
      }
      else
      {
        //16 bit
        for (counter = 0; counter < Width; ++counter)
        {
          inarray[counter].setRed(trow16[counter*samplesPerPixel]);
          inarray[counter].setGreen(trow16[counter*samplesPerPixel + 1]);
          inarray[counter].setBlue(trow16[counter*samplesPerPixel + 2]);
        }
      }
      break;
    case PHOTO_GRAY:
      //the 8 bit case
      if (bitsPerSample <= 8)
      {
        for(counter = 0; counter < Width; ++counter)
        {
          inarray[counter].setGrey(trow[counter]);
        }
      }
      else //16 bits per sample
      {
        for (counter = 0; counter < Width; ++counter)
        {
          inarray[counter].setGrey(trow16[counter]);
        }
      }
      break;
    default:
      throw ImageException(IMAGE_FILE_READ_ERR);
    }
    
    delete [] trow;
    delete [] trow16;
  }
  catch(ImageException & e)
  {
    //just rethrow 
    delete [] trow;
    delete [] trow16;
    throw e;
  }
  catch(...)
  {
    if(trow)
    {
      delete [] trow;
      delete [] trow16;
    }
    throw ImageException(IMAGE_FILE_READ_ERR);
  }
}