"""Image-handling routines ### Unresolved: Following methods are not yet resolved due to my not being sure how the function should be wrapped: glCompressedTexImage3D glCompressedTexImage2D glCompressedTexImage1D glCompressedTexSubImage3D glCompressedTexSubImage2D glCompressedTexSubImage1D """ from OpenGL.raw import GL as simple from OpenGL import images, arrays, wrapper, platform import ctypes def asInt( value ): if isinstance( value, float ): return int(round(value,0)) return value ## update the image tables with standard image types... #images.FORMAT_BITS.update( { # simple.GL_BITMAP : 1, # must be GL_UNSIGNED_BYTE # # simple.GL_RED : 8, # simple.GL_GREEN : 8, # simple.GL_BLUE : 8, # simple.GL_ALPHA : 8, # simple.GL_LUMINANCE : 8, # simple.GL_LUMINANCE_ALPHA : 8, # simple.GL_COLOR_INDEX : 8, # simple.GL_STENCIL_INDEX : 8, # simple.GL_DEPTH_COMPONENT : 8, # simple.GL_RGB : 24, # simple.GL_BGR : 24, # # simple.GL_RGBA : 32, # simple.GL_BGRA : 32, # simple.GL_ABGR_EXT : 32, # simple.GL_CMYK_EXT : 32, # # simple.GL_CMYKA_EXT : 40, # # simple.GL_YCRCB_422_SGIX : 8, # must be GL_UNSIGNED_BYTE # simple.GL_YCRCB_444_SGIX : 8, # must be GL_UNSIGNED_SHORT # # simple.GL_FORMAT_SUBSAMPLE_24_24_OML : 32, # must be GL_UNSIGNED_INT_10_10_10_2 # simple.GL_FORMAT_SUBSAMPLE_244_244_OML : 32, # must be GL_UNSIGNED_INT_10_10_10_2 #} ) images.COMPONENT_COUNTS.update( { simple.GL_BITMAP : 1, # must be GL_UNSIGNED_BYTE simple.GL_RED : 1, simple.GL_GREEN : 1, simple.GL_BLUE : 1, simple.GL_ALPHA : 1, simple.GL_LUMINANCE : 1, simple.GL_LUMINANCE_ALPHA : 2, simple.GL_COLOR_INDEX : 1, simple.GL_STENCIL_INDEX : 1, simple.GL_DEPTH_COMPONENT : 1, simple.GL_RGB : 3, simple.GL_BGR : 3, simple.GL_RGBA : 4, simple.GL_BGRA : 4, simple.GL_ABGR_EXT : 4, simple.GL_CMYK_EXT : 4, simple.GL_CMYKA_EXT : 5, simple.GL_YCRCB_422_SGIX : 1, # must be GL_UNSIGNED_BYTE simple.GL_YCRCB_444_SGIX : 1, # must be GL_UNSIGNED_SHORT simple.GL_FORMAT_SUBSAMPLE_24_24_OML : 1, # must be GL_UNSIGNED_INT_10_10_10_2 simple.GL_FORMAT_SUBSAMPLE_244_244_OML : 1, # must be GL_UNSIGNED_INT_10_10_10_2 } ) #images.TYPE_TO_BITS.update( { # simple.GL_UNSIGNED_BYTE_3_3_2 : 8, # simple.GL_UNSIGNED_BYTE_2_3_3_REV : 8, # simple.GL_UNSIGNED_SHORT_4_4_4_4 : 16, # simple.GL_UNSIGNED_SHORT_4_4_4_4_REV : 16, # simple.GL_UNSIGNED_SHORT_5_5_5_1 : 16, # simple.GL_UNSIGNED_SHORT_1_5_5_5_REV : 16, # simple.GL_UNSIGNED_SHORT_5_6_5 : 16, # simple.GL_UNSIGNED_SHORT_5_6_5_REV : 16, # simple.GL_UNSIGNED_INT_8_8_8_8 : 32, # simple.GL_UNSIGNED_INT_8_8_8_8_REV : 32, # simple.GL_UNSIGNED_INT_10_10_10_2 : 32, # simple.GL_UNSIGNED_INT_2_10_10_10_REV : 32, # simple.GL_UNSIGNED_BYTE : ctypes.sizeof(simple.GLubyte) * 8, # simple.GL_BYTE: ctypes.sizeof(simple.GLbyte) * 8, # simple.GL_UNSIGNED_SHORT : ctypes.sizeof(simple.GLushort) * 8, # simple.GL_SHORT : ctypes.sizeof(simple.GLshort) * 8, # simple.GL_UNSIGNED_INT : ctypes.sizeof(simple.GLuint) * 8, # simple.GL_INT : ctypes.sizeof(simple.GLint) * 8, # simple.GL_FLOAT : ctypes.sizeof(simple.GLfloat) * 8, # simple.GL_DOUBLE : ctypes.sizeof(simple.GLdouble) * 8, #} ) images.TYPE_TO_ARRAYTYPE.update( { simple.GL_UNSIGNED_BYTE_3_3_2 : simple.GL_UNSIGNED_BYTE, simple.GL_UNSIGNED_BYTE_2_3_3_REV : simple.GL_UNSIGNED_BYTE, simple.GL_UNSIGNED_SHORT_4_4_4_4 : simple.GL_UNSIGNED_SHORT, simple.GL_UNSIGNED_SHORT_4_4_4_4_REV : simple.GL_UNSIGNED_SHORT, simple.GL_UNSIGNED_SHORT_5_5_5_1 : simple.GL_UNSIGNED_SHORT, simple.GL_UNSIGNED_SHORT_1_5_5_5_REV : simple.GL_UNSIGNED_SHORT, simple.GL_UNSIGNED_SHORT_5_6_5 : simple.GL_UNSIGNED_SHORT, simple.GL_UNSIGNED_SHORT_5_6_5_REV : simple.GL_UNSIGNED_SHORT, simple.GL_UNSIGNED_INT_8_8_8_8 : simple.GL_UNSIGNED_INT, simple.GL_UNSIGNED_INT_8_8_8_8_REV : simple.GL_UNSIGNED_INT, simple.GL_UNSIGNED_INT_10_10_10_2 : simple.GL_UNSIGNED_INT, simple.GL_UNSIGNED_INT_2_10_10_10_REV : simple.GL_UNSIGNED_INT, simple.GL_UNSIGNED_BYTE : simple.GL_UNSIGNED_BYTE, simple.GL_BYTE: simple.GL_BYTE, simple.GL_UNSIGNED_SHORT : simple.GL_UNSIGNED_SHORT, simple.GL_SHORT : simple.GL_SHORT, simple.GL_UNSIGNED_INT : simple.GL_UNSIGNED_INT, simple.GL_INT : simple.GL_INT, simple.GL_FLOAT : simple.GL_FLOAT, simple.GL_DOUBLE : simple.GL_DOUBLE, } ) images.RANK_PACKINGS.update( { 4: [ (simple.glPixelStorei,simple.GL_PACK_SKIP_VOLUMES_SGIS, 0), (simple.glPixelStorei,simple.GL_PACK_IMAGE_DEPTH_SGIS, 0), ], 3: [ (simple.glPixelStorei,simple.GL_PACK_SKIP_IMAGES, 0), (simple.glPixelStorei,simple.GL_PACK_IMAGE_HEIGHT, 0), ], 2: [ (simple.glPixelStorei,simple.GL_PACK_ROW_LENGTH, 0), (simple.glPixelStorei,simple.GL_PACK_SKIP_ROWS, 0), (simple.glPixelStorei,simple.GL_PACK_ALIGNMENT, 1), ], 1: [ (simple.glPixelStorei,simple.GL_PACK_SKIP_PIXELS, 0), ], } ) __all__ = ( 'glReadPixels', 'glReadPixelsb', 'glReadPixelsd', 'glReadPixelsf', 'glReadPixelsi', 'glReadPixelss', 'glReadPixelsub', 'glReadPixelsui', 'glReadPixelsus', 'glGetTexImage', 'glDrawPixels', 'glDrawPixelsb', 'glDrawPixelsf', 'glDrawPixelsi', 'glDrawPixelss', 'glDrawPixelsub', 'glDrawPixelsui', 'glDrawPixelsus', 'glTexSubImage2D', 'glTexSubImage1D', #'glTexSubImage3D', 'glTexImage1D', 'glTexImage2D', #'glTexImage3D', 'glGetTexImageb', 'glGetTexImaged', 'glGetTexImagef', 'glGetTexImagei', 'glGetTexImages', 'glGetTexImageub', 'glGetTexImageui', 'glGetTexImageus', 'glTexImage1Db', 'glTexImage2Db', #'glTexImage3Db', 'glTexSubImage1Db', 'glTexSubImage2Db', #'glTexSubImage3Db', 'glTexImage1Df', 'glTexImage2Df', #'glTexImage3Df', 'glTexSubImage1Df', 'glTexSubImage2Df', #'glTexSubImage3Df', 'glTexImage1Di', 'glTexImage2Di', #'glTexImage3Di', 'glTexSubImage1Di', 'glTexSubImage2Di', #'glTexSubImage3Di', 'glTexImage1Ds', 'glTexImage2Ds', #'glTexImage3Ds', 'glTexSubImage1Ds', 'glTexSubImage2Ds', #'glTexSubImage3Ds', 'glTexImage1Dub', 'glTexImage2Dub', #'glTexImage3Dub', 'glTexSubImage1Dub', 'glTexSubImage2Dub', #'glTexSubImage3Dub', 'glTexImage1Dui', 'glTexImage2Dui', #'glTexImage3Dui', 'glTexSubImage1Dui', 'glTexSubImage2Dui', #'glTexSubImage3Dui', 'glTexImage1Dus', 'glTexImage2Dus', #'glTexImage3Dus', 'glTexSubImage1Dus', 'glTexSubImage2Dus', #'glTexSubImage3Dus', #'glColorTable', #'glGetColorTable', #'glColorSubTable', #'glConvolutionFilter1D', #'glConvolutionFilter2D', #'glGetConvolutionFilter', #'glSeparableFilter2D', #'glGetSeparableFilter', #'glGetMinmax', ) for suffix,type in [ ('b',simple.GL_BYTE), ('d',simple.GL_DOUBLE), ('f',simple.GL_FLOAT), ('i',simple.GL_INT), ('s',simple.GL_SHORT), ('ub',simple.GL_UNSIGNED_BYTE), ('ui',simple.GL_UNSIGNED_INT), ('us',simple.GL_UNSIGNED_SHORT), ]: def glReadPixels( x,y,width,height,format,type=type ): """Read specified pixels from the current display buffer This typed version returns data in your specified default array data-type format """ x,y,width,height = asInt(x),asInt(y),asInt(width),asInt(height) array = images.SetupPixelRead( format, (width,height), type ) arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] imageData = arrayType.dataPointer(array) simple.glReadPixels( x,y, width, height, format,type, ctypes.c_void_p( imageData ) ) return array globals()["glReadPixels%s"%(suffix,)] = glReadPixels def glGetTexImage( target, level,format,type=type ): """Get a texture-level as an image""" from OpenGL.GL import glget dims = [glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_WIDTH )] if target != simple.GL_TEXTURE_1D: dims.append( glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_HEIGHT ) ) if target != simple.GL_TEXTURE_2D: dims.append( glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_DEPTH ) ) array = images.SetupPixelRead( format, tuple(dims), type ) arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] simple.glGetTexImage( target, level, format, type, ctypes.c_void_p( arrayType.dataPointer(array)) ) return array globals()["glGetTexImage%s"%(suffix,)] = glGetTexImage ## def glGetTexSubImage( target, level,format,type ): ## """Get a texture-level as an image""" ## from OpenGL.GL import glget ## dims = [glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_WIDTH )] ## if target != simple.GL_TEXTURE_1D: ## dims.append( glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_HEIGHT ) ) ## if target != simple.GL_TEXTURE_2D: ## dims.append( glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_DEPTH ) ) ## array = images.SetupPixelRead( format, tuple(dims), type ) ## arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] ## simple.glGetTexImage( ## target, level, format, type, ctypes.c_void_p( arrayType.dataPointer(array)) ## ) ## return array ## "%s = glGetTexImage"%(suffix) del suffix,type # Now the real glReadPixels... def glReadPixels( x,y,width,height,format,type, outputType=str ): """Read specified pixels from the current display buffer x,y,width,height -- location and dimensions of the image to read from the buffer format -- pixel format for the resulting data type -- data-format for the resulting data outputType -- default (str) provides string output of the results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True and type == GL_UNSIGNED_BYTE. Any other value will cause output in the default array output format. returns the pixel data array in the format defined by the format, type and outputType """ x,y,width,height = asInt(x),asInt(y),asInt(width),asInt(height) array = images.SetupPixelRead( format, (width,height), type ) arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] imageData = arrayType.dataPointer(array) simple.glReadPixels( x,y,width,height, format,type, ctypes.c_void_p( imageData ) ) if outputType is str: return images.returnFormat( array, type ) else: return array def glGetTexImage( target, level,format,type, outputType=str ): """Get a texture-level as an image target -- enum constant for the texture engine to be read level -- the mip-map level to read format -- image format to read out the data type -- data-type into which to read the data outputType -- default (str) provides string output of the results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True and type == GL_UNSIGNED_BYTE. Any other value will cause output in the default array output format. returns the pixel data array in the format defined by the format, type and outputType """ from OpenGL.GL import glget dims = [glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_WIDTH )] if target != simple.GL_TEXTURE_1D: dims.append( glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_HEIGHT ) ) if target != simple.GL_TEXTURE_2D: dims.append( glget.glGetTexLevelParameteriv( target, level, simple.GL_TEXTURE_DEPTH ) ) array = images.SetupPixelRead( format, tuple(dims), type ) arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] simple.glGetTexImage( target, level, format, type, ctypes.c_void_p( arrayType.dataPointer(array)) ) if outputType is str: return images.returnFormat( array, type ) else: return array INT_DIMENSION_NAMES = [ 'width','height','depth','x','y','z', 'xoffset','yoffset','zoffset', 'start', 'count', ] def asWrapper( value ): if not isinstance( value, wrapper.Wrapper ): return wrapper.wrapper( value ) return value def asIntConverter( value, *args ): if isinstance( value, float ): return int(round(value,0)) return value def setDimensionsAsInts( baseOperation ): """Set arguments with names in INT_DIMENSION_NAMES to asInt processing""" baseOperation = asWrapper( baseOperation ) argNames = getattr( baseOperation, 'pyConverterNames', baseOperation.argNames ) for i,argName in enumerate(argNames): if argName in INT_DIMENSION_NAMES: baseOperation.setPyConverter( argName, asIntConverter ) return baseOperation class ImageInputConverter( object ): def __init__( self, rank, pixelsName=None, typeName='type' ): self.rank = rank self.typeName = typeName self.pixelsName = pixelsName def finalise( self, wrapper ): """Get our pixel index from the wrapper""" self.typeIndex = wrapper.pyArgIndex( self.typeName ) self.pixelsIndex = wrapper.pyArgIndex( self.pixelsName ) def __call__( self, arg, baseOperation, pyArgs ): """pyConverter for the pixels argument""" images.setupDefaultTransferMode() images.rankPacking( self.rank ) type = pyArgs[ self.typeIndex ] try: arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE[ type ] ] except TypeError, err: import pdb pdb.set_trace() return arrayType.asArray( arg ) def cResolver( self, array ): return ctypes.c_void_p( arrays.ArrayDatatype.dataPointer( array ) ) class TypedImageInputConverter( ImageInputConverter ): def __init__( self, rank, pixelsName, arrayType, typeName=None ): self.rank = rank self.arrayType = arrayType self.pixelsName = pixelsName self.typeName = typeName def __call__( self, arg, baseOperation, pyArgs ): """The pyConverter for the pixels""" images.setupDefaultTransferMode() images.rankPacking( self.rank ) return self.arrayType.asArray( arg ) def finalise( self, wrapper ): """Get our pixel index from the wrapper""" self.pixelsIndex = wrapper.pyArgIndex( self.pixelsName ) def width( self, pyArgs, index, wrappedOperation ): """Extract the width from the pixels argument""" return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[0] def height( self, pyArgs, index, wrappedOperation ): """Extract the height from the pixels argument""" return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[1] def depth( self, pyArgs, index, wrappedOperation ): """Extract the depth from the pixels argument""" return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[2] def type( self, pyArgs, index, wrappedOperation ): """Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication... """ return self.typeName class CompressedImageConverter( object ): def finalise( self, wrapper ): """Get our pixel index from the wrapper""" self.dataIndex = wrapper.pyArgIndex( 'data' ) def __call__( self, pyArgs, index, wrappedOperation ): """Create a data-size measurement for our image""" arg = pyArgs[ self.dataIndex ] return arrays.ArrayType.arrayByteCount( arg ) DIMENSION_NAMES = ( 'width','height','depth' ) PIXEL_NAMES = ( 'pixels', 'row', 'column', ) DATA_SIZE_NAMES = ( 'imageSize', ) def setImageInput( baseOperation, arrayType=None, dimNames=DIMENSION_NAMES, pixelName="pixels", typeName=None ): """Determine how to convert "pixels" into an image-compatible argument""" baseOperation = asWrapper( baseOperation ) # rank is the count of width,height,depth arguments... rank = len([ # rank is the number of dims we want, not the number we give... argName for argName in baseOperation.argNames if argName in dimNames ]) + 1 if arrayType: converter = TypedImageInputConverter( rank, pixelName, arrayType, typeName=typeName ) for i,argName in enumerate(baseOperation.argNames): if argName in dimNames: baseOperation.setPyConverter( argName ) baseOperation.setCConverter( argName, getattr(converter,argName) ) elif argName == 'type' and typeName is not None: baseOperation.setPyConverter( argName ) baseOperation.setCConverter( argName, converter.type ) else: converter = ImageInputConverter( rank, pixelsName=pixelName, typeName=typeName or 'type' ) for argName in baseOperation.argNames: if argName in DATA_SIZE_NAMES: baseOperation.setPyConverter( argName ) baseOperation.setCConverter( argName, converter.imageDataSize ) baseOperation.setPyConverter( pixelName, converter, ) baseOperation.setCResolver( pixelName, converter.cResolver ) return baseOperation glDrawPixels = setDimensionsAsInts( setImageInput( simple.glDrawPixels ) ) glTexSubImage2D = setDimensionsAsInts( setImageInput( simple.glTexSubImage2D ) ) glTexSubImage1D = setDimensionsAsInts( setImageInput( simple.glTexSubImage1D ) ) glTexImage2D = setDimensionsAsInts( setImageInput( simple.glTexImage2D ) ) glTexImage1D = setDimensionsAsInts( setImageInput( simple.glTexImage1D ) ) def typedImageFunction( suffix, arrayConstant, baseFunction ): """Produce a typed version of the given image function""" if baseFunction: arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ arrayConstant ] function = setDimensionsAsInts( setImageInput( baseFunction, arrayType, typeName = arrayConstant, ) ) functionName = baseFunction.__name__ functionName = '%(functionName)s%(suffix)s'%locals() return functionName, function else: return baseFunction.__name__, baseFunction def _setDataSize( baseFunction, argument='imageSize' ): """Set the data-size value to come from the data field""" if baseFunction: converter = CompressedImageConverter() return asWrapper( baseFunction ).setPyConverter( argument ).setCConverter( argument, converter ) else: return baseFunction def compressedImageFunction( baseFunction ): """Set the imageSize and dimensions-as-ints converters for baseFunction""" if baseFunction: return setDimensionsAsInts( _setDataSize( baseFunction, argument='imageSize' ) ) else: return baseFunction for suffix,arrayConstant in [ ('b', simple.GL_BYTE), ('f', simple.GL_FLOAT), ('i', simple.GL_INT), ('s', simple.GL_SHORT), ('ub', simple.GL_UNSIGNED_BYTE), ('ui', simple.GL_UNSIGNED_INT), ('us', simple.GL_UNSIGNED_SHORT), ]: for functionName in ( 'glTexImage1D','glTexImage2D', 'glTexSubImage1D','glTexSubImage2D', 'glDrawPixels', #'glTexSubImage3D','glTexImage3D', # extension/1.2 standard ): functionName, function = typedImageFunction( suffix, arrayConstant, getattr(simple,functionName), ) globals()[functionName] = function del function, functionName del suffix,arrayConstant