gliftUtil.h

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////
// 8/11/02      Aaron Lefohn    Scientific Computing and Imaging Institute
// School of Computing          University of Utah
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library 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
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef GL_UTIL_GLIFT_H_
#define GL_UTIL_GLIFT_H_

#include "gliftNrrd.h"
#include <GL/glew.h>
#include <GL/glUtil.h>
#include <sstream>
#include <mathGutz.h>
#include <arrayGutz.h>
#include "../texture/singleTex.h"

namespace glift {

#define NUM_TEX_UNIT_NAMES 32
extern const GLenum g_texUnitName[NUM_TEX_UNIT_NAMES];

/////////////////////////////////////////////////////////////////////////
///
/// Smattering of OpenGL utility routines
/// - IMPORTANT: All Glift apps MUST call 'gliftInit()' to function properly
///
///////////////////////////////////////////////////////////////////////

/// Draw a 2D tile of pixels from 'data' into 'tex'
/// - 'dataOrig' and 'dimen' denote the data tile
/// - 'texOrig' and 'dimen' denote where in the texture the data is written
/// - Number of color channels is determined by 'data.dim(2)'
/// - Data is sent to texture via render-to-texture or by glCopySubTexImage2D(...). 
void drawSubPixels( const gutz::vec2i& dataOrig, const gutz::vec2i& texOrig, const gutz::vec2i& dimen,
                   const gutz::arrayw3ub& data, SingleTex* tex, GLenum drawBuffer = GL_FRONT_LEFT );

/// Draw pixels in 'data' into the texture, 'tex'.
/// Dimensions of pixel rectangle are 'data.dim(0)' x 'data.dim(1)'
void drawPixels( const gutz::arrayw3ub& data, SingleTex* tex, GLenum drawBuffer = GL_FRONT_LEFT );

/// - Draw pixels in 'data' into the texture, 'tex'
/// - Dimensions of pixel rectangle are 'data.dim(1)' x 'data.dim(0)'
/// - Number of color channels is determined by 'data.dim(2)'
/// - Draws to the currenly set surface UNLESS 'tex->pbuff()' is a SubPBuff.
///   If that is the case, the surface defined in the SubPBuff is used instead
///
/// WARNINGS:
/// 1) Assumes an orthographic projection is already set up in the pbuffer context
/// 2) Leaves pbuffer context enabled after drawing
void drawPixels( const gutz::arrayw3f& data, SingleTex* tex );

/// Draw a quad to the screen that is of size 'tex->dimen()'
/// Will draw 'tex->pbuff()' if 'drawToPbuff' is true
/// Assumes that render mode is in appropriate state ( glOrtho2D(...)? )
void drawSingleTexQuad( SingleTex* tex, bool drawToPbuff=false );
void drawSingleTexQuad( SingleTex* tex, const gutz::vec2i& dimen, bool drawToPbuff=false );

/// Draw a quad of 'color' to lowerLeft=origin, upperRight=origin + dimen to 
/// 'tex' or current context (if pbuff==NULL)
void drawColoredTile( const gutz::vec2i& origin,          const gutz::vec2i& dimen, 
                     const gutz::vec2i& fullQuadDim, const gutz::vec3f& color, 
                     SingleTex* tex );

/// Get header info from PNM
//int readDimenPNM( char* fileName, gutz::vec2i& dimen );

/// Get header info from 'fileName's header
/// - 'fileName' can be a PGM, PPM, or any Nrrd-compatible file
/// - 'dimen' will hold the size of each dimension of the dataset
/// - 'dimen.size()' is the dimensionality of the dataset
/// - Note 1: Ordering of the dimensions is Glift-like. 
///   - i.e. slowest index first, fastest index last (opposite of Nrrd convention)
///   - Example: y, x, color
/// - Note 2: Scalar data is a dimension of size 1 (counter to Nrrd convention!) 
/// - Note 3: 'isPNM' is true if file is PGM or PPM
int readDimenNrrd( const char* fileName, gutz::arrayo1i& dimen, bool& isPNM );

/// Read the PNM file, 'inFileName', sets 'width' and 'height' based on input file,
/// and returns image in 'rgbaImage'
/// - If file is PGM, all 'channels' have the replicated, scalar value
/// - If file is PPM, up to 'channels' are output.
/// - If format is RGBA and file is PPM, alpha channel is set to 255
/// - If 'makeScalar' is true, PPMs are averaged down to scalar value (replicated as necessary)
///   If false, RGB data is retained and alpha channel is padded with 255 if necessary
/// - 'dimen' returns the size of each dimension: x,y,channels
/// - Returns nrrd error code (0 is alles klar)
int loadPNM( GLenum channels, bool makeScalar, const char* inFileName, 
            gutz::arrayo3ub& data );

/// Read the Nrrd file, 'inFileName'.
/// - WARNING: 'inFileName' MUST be a scalar volume or this fcn will return an error
///             and 'dimen' and 'data' will be unaltered. Must also be uchar data.
/// - 'channels' is GL_RED, GL_RGB, GL_RGBA, etc and sets how many times the scalar
///    voxel value is copied.
/// - 'dimen' contains the size of each dimension of the volume.
/// - 'data'  contains the scalar volume data. Accessors are: z, y, x, channel
int loadNrrd3D( GLenum channels, const char* inFileName, gutz::arrayo4ub& data );

/// Read framebuffer to CPU memory and write to file.
void writeFBtoPPM( GLenum channels, const gutz::vec2i& origin, const gutz::vec2i& dimen, 
                  char* baseFileName, bool sepChannels=false );

/// Write to a pgm or ppm file called 'baseFileName.pgm' or 'baseFileName.ppm'
/// - 'data' has dimens: height, width, numChannels
/// - PGM is written if 'numChannels' == 1, otherwise a PPM is written
/// - If 'numChannels' == 4, the last channel (alpha) is written to a separate pgm.
void writePNM( char* baseFileName, const gutz::arrayw3ub& data, bool sepChannels );

/// Write to a nrrd file called 'baseFileName.nrrd'
/// - 'data' has dimens: numSlabs, height, width, numChannels
void writeNrrd3D( const char* baseFileName, const gutz::arrayw4ub& data );

/// Take a scalar volume and pack into an RGB volume
/// - maxZ is the number of slabs in 'data' to process 
/// - maxZ MUST be a multiple of 3!!!
/// - Returned data MUST be deleted to avoid memory leaks :(
///      TODO: This could be fixed with a transfer operation?
gutz::arrayw4ub packScalarToRGB( const gutz::arrayw4ub& data, int maxZ );

/// Take an RGB-packed, scalar volume and unpack it into scalar slabs
/// - Returned data MUST be deleted to avoid memory leaks :(
///      TODO: This could be fixed with a transfer operation?
/// - 'unpackZ' is the maxZ value for the unpacked data
gutz::arrayw4ub unpackRGBToScalar( const gutz::arrayw4ub& data, int unpackZ );

inline std::string itoa( int i ) {
   std::stringstream stream;
   stream << i;

   std::string str;
   stream >> str;
   return str;
}

} /// End of namespace glift

#endif

---

Send questions, comments, and bug reports to: