Logo Search packages:      
Sourcecode: passage version File versions  Download package

RGBAImage.h

/*
 * Modification History
 *
 * 2000-December-21           Jason Rohrer
 * Created. 
 *
 * 2001-January-15      Jason Rohrer
 * Added an overridden copy() method.  
 *
 * 2001-January-19      Jason Rohrer
 * Fixed so that filter( filter, channelNum ) could be called on
 * this class type. 
 *
 * 2001-January-31            Jason Rohrer
 * Fixed a bug in getRGBABytes().
 *
 * 2001-September-15          Jason Rohrer
 * Added a constructor that copies data from an Image.
 *
 * 2006-September-7           Jason Rohrer
 * Optimized constructor.
 */
 
 
#ifndef RGBA_IMAGE_INCLUDED
#define RGBA_IMAGE_INCLUDED

#include <stdio.h> 
#include <string.h>
 
#include "Image.h"
 
/**
 * An RGBA extension of Image.
 *
 * @author Jason Rohrer 
 */
00038 class RGBAImage : public Image { 
      
      public:
            
            /**
             * Constructs an RGBA image.  All channels are initialized to 0.
             *
             * @param inWidth width of image in pixels.
             * @param inHeight height of image in pixels.
             */
            RGBAImage( int inWidth, int inHeight );
            
            
            /**
             * Constructs an RGBAImage by copying a given image.
             * The image data is truncated or expaned (with black channels)
             * to fit the 4 channel RGBA model,
             * and any selection in inImage is ignored.
             *
             * @param inImage the image to copy.  Copied internally, so must be
             *   destroyed by the caller.
             */
            RGBAImage( Image *inImage );
            
            
            /**
             * Gets the pixel data from this image as a byte array.
             *
             * @return a byte array containing pixel data for this image.
             *   Stored in row-major order, with each pixel represented
             *   by 4 bytes in the order RGBA.
             *   Must be destroyed by caller.
             */
            virtual unsigned char *getRGBABytes();
            
            
            // overrides the Image::filter function
            virtual void filter( ChannelFilter *inFilter );
            virtual void filter( ChannelFilter *inFilter, int inChannel );
            
            
            // overrides the Image::copy function
            // since the function is non-virtual in the parent class,
            // the pointer type should determine which function gets called.
            RGBAImage *copy();
            
      };



00088 inline RGBAImage::RGBAImage( int inWidth, int inHeight )
      : Image( inWidth, inHeight, 4 ) {
      
      }



00095 inline RGBAImage::RGBAImage( Image *inImage )
    // Only init our image's channels to black of inImage doesn't have enough
    // channels.
    // This saves time if inImage has 4 or more channels.
    // Optimization found with profiler.
      : Image( inImage->getWidth(), inImage->getHeight(), 4,
             ( inImage->getNumChannels() < 4 ) ) {
      
      int minNumChannels = 4;
      if( inImage->getNumChannels() < minNumChannels ) {
            minNumChannels = inImage->getNumChannels();
            }

      // if inImage does not have at least 4 channels,
      // leave our additional channels black
      // if inImage has extra channels, skip them

      // copy channels from inImage
      for( int c=0; c<minNumChannels; c++ ) {
            double *inChannel = inImage->getChannel( c );
            
            memcpy( mChannels[c], inChannel, mNumPixels * sizeof( double ) ); 
            }
      }

      
/*    
inline unsigned char *RGBAImage::getRGBABytes() {
      int numBytes = mNumPixels * 4; 
      unsigned char *bytes = new unsigned char[ numBytes ];
      int pixel = 0;
      for( int i=0; i<numBytes; i=i+4 ) {
            bytes[i] = (unsigned char)( mChannels[0][pixel] * 255 );
            bytes[i + 1] = (unsigned char)( mChannels[1][pixel] * 255 );
            bytes[i + 2] = (unsigned char)( mChannels[2][pixel] * 255 );
            bytes[i + 3] = (unsigned char)( mChannels[3][pixel] * 255 );
            pixel++;
            }
      return bytes;
      }
*/

// optimized version
00138 inline unsigned char *RGBAImage::getRGBABytes() {
      int numBytes = mNumPixels * 4; 
      unsigned char *bytes = new unsigned char[ numBytes ];

    double *channelZero = mChannels[0];
    double *channelOne = mChannels[1];
    double *channelTwo = mChannels[2];
    double *channelThree = mChannels[3];
    
    
    register int i = 0;
    for( int p=0; p<mNumPixels; p++ ) {
            bytes[i++] = (unsigned char)( channelZero[p] * 255 );
            bytes[i++] = (unsigned char)( channelOne[p] * 255 );
            bytes[i++] = (unsigned char)( channelTwo[p] * 255 );
            bytes[i++] = (unsigned char)( channelThree[p] * 255 );
            }
      return bytes;
      }

      

00160 inline void RGBAImage::filter( ChannelFilter *inFilter ) {
      // different from standard Image implementation in that we
      // skip the alpha channel when filtering
      for( int i=0; i<mNumChannels-1; i++ ) {
            Image::filter( inFilter, i );
            }     
      }



00170 inline void RGBAImage::filter( ChannelFilter *inFilter, int inChannel ) {
      // provided as a bridge to the Image function, just to
      // get around compile problems.
      Image::filter( inFilter, inChannel );     
      }



00178 inline RGBAImage *RGBAImage::copy() {
      RGBAImage *copiedImage = new RGBAImage( mWide, mHigh );
      copiedImage->paste( this );
      
      return copiedImage;
      }
      
            
#endif

Generated by  Doxygen 1.6.0   Back to index