# /*######################################################################### # # The PyMca X-Ray Fluorescence Toolkit # # Copyright (c) 2004-2014 European Synchrotron Radiation Facility # # This file is part of the PyMca X-ray Fluorescence Toolkit developed at # the ESRF by the Software group. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # # ###########################################################################*/ __author__ = "T. Vincent - ESRF Data Analysis" __contact__ = "thomas.vincent@esrf.fr" __license__ = "MIT" __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France" __doc__ = """ This module provides classes wrapping OpenGL texture. """ # import ###################################################################### from .gl import * # noqa from ctypes import c_void_p import numpy as np # texture ##################################################################### class Texture2D(object): """Wraps OpenGL texture2D""" def __init__(self, internalFormat, width, height, format_=None, type_=GL_FLOAT, data=None, texUnit=0, minFilter=None, magFilter=None, wrapS=None, wrapT=None, unpackAlign=1, unpackRowLength=0, unpackSkipPixels=0, unpackSkipRows=0): self._internalFormat = internalFormat self._width, self._height = width, height self.texUnit = texUnit self._tid = glGenTextures(1) self.bind(self.texUnit) if minFilter is not None: glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter) if magFilter is not None: glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter) if wrapS is not None: glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS) if wrapT is not None: glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT) glPixelStorei(GL_UNPACK_ALIGNMENT, unpackAlign) if unpackRowLength: glPixelStorei(GL_UNPACK_ROW_LENGTH, unpackRowLength) if unpackSkipPixels: glPixelStorei(GL_UNPACK_SKIP_PIXELS, unpackSkipPixels) if unpackSkipRows: glPixelStorei(GL_UNPACK_SKIP_ROWS, unpackSkipRows) glTexImage2D(GL_TEXTURE_2D, 0, self.internalFormat, self.width, self.height, 0, format_ if format_ is not None else self.internalFormat, type_, data if data is not None else c_void_p(0)) if unpackRowLength: glPixelStorei(GL_UNPACK_ROW_LENGTH, 0) if unpackSkipPixels: glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0) if unpackSkipRows: glPixelStorei(GL_UNPACK_SKIP_ROWS, 0) glBindTexture(GL_TEXTURE_2D, 0) @property def internalFormat(self): return self._internalFormat @property def width(self): return self._width @property def height(self): return self._height @property def tid(self): """OpenGL texture ID""" try: return self._tid except AttributeError: raise RuntimeError("No OpenGL texture resource, \ discard has already been called") def discard(self): if hasattr(self, '_tid'): if bool(glDeleteTextures): # Test for __del__ glDeleteTextures(np.array((self._tid,))) del self._tid def __del__(self): self.discard() def bind(self, texUnit=None): texUnit = texUnit if texUnit is not None else self.texUnit glActiveTexture(GL_TEXTURE0 + texUnit) glBindTexture(GL_TEXTURE_2D, self.tid) def update(self, format_, type_, data, xOffset=0, yOffset=0, width=None, height=None, texUnit=None, unpackAlign=1, unpackRowLength=0, unpackSkipPixels=0, unpackSkipRows=0): if unpackRowLength: glPixelStorei(GL_UNPACK_ROW_LENGTH, unpackRowLength) if unpackSkipPixels: glPixelStorei(GL_UNPACK_SKIP_PIXELS, unpackSkipPixels) if unpackSkipRows: glPixelStorei(GL_UNPACK_SKIP_ROWS, unpackSkipRows) glPixelStorei(GL_UNPACK_ALIGNMENT, unpackAlign) self.bind(texUnit) glTexSubImage2D(GL_TEXTURE_2D, 0, xOffset, yOffset, width or self.width, height or self.height, format_, type_, data) glBindTexture(GL_TEXTURE_2D, 0) if unpackRowLength: glPixelStorei(GL_UNPACK_ROW_LENGTH, 0) if unpackSkipPixels: glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0) if unpackSkipRows: glPixelStorei(GL_UNPACK_SKIP_ROWS, 0) def _checkTexture2D(internalFormat, width, height, format_=None, type_=GL_FLOAT, border=0): """Check if texture size with provided parameters is supported :rtype: bool """ glTexImage2D(GL_PROXY_TEXTURE_2D, 0, internalFormat, width, height, border, format_ or internalFormat, type_, c_void_p(0)) width = glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH) return bool(width) MIN_TEXTURE_SIZE = 64 def _getMaxSquareTexture2DSize(internalFormat=GL_RGBA, format_=None, type_=GL_FLOAT, border=0): """Returns a supported size for a corresponding square texture :returns: GL_MAX_TEXTURE_SIZE or a smaller supported size (not optimal) :rtype: tuple """ # Is this useful? maxTexSize = glGetIntegerv(GL_MAX_TEXTURE_SIZE) while maxTexSize > MIN_TEXTURE_SIZE and \ not _checkTexture2D(internalFormat, maxTexSize, maxTexSize, format_, type_, border): maxTexSize = maxTexSize // 2 return max(MIN_TEXTURE_SIZE, maxTexSize) class Image(object): """Image of any size eventually using multiple textures or larger texture """ _WRAP_S = GL_CLAMP_TO_EDGE _WRAP_T = GL_CLAMP_TO_EDGE _MIN_FILTER = GL_NEAREST _MAG_FILTER = GL_NEAREST def __init__(self, internalFormat, width, height, format_=None, type_=GL_FLOAT, data=None, texUnit=0, unpackAlign=1): self.internalFormat = internalFormat self.width, self.height = width, height if _checkTexture2D(internalFormat, width, height, format_, type_): texture = Texture2D(internalFormat, width, height, format_, type_, data, texUnit=texUnit, minFilter=self._MIN_FILTER, magFilter=self._MAG_FILTER, wrapS=self._WRAP_S, wrapT=self._WRAP_T, unpackAlign=unpackAlign) vertices = np.array(( (0., 0., 0., 0.), (width, 0., 1., 0.), (0., height, 0., 1.), (width, height, 1., 1.)), dtype=np.float32) self.tiles = ((texture, vertices, {'xOrigData': 0, 'yOrigData': 0, 'wData': width, 'hData': height}),) else: # Handle dimension too large: make tiles maxTexSize = _getMaxSquareTexture2DSize(internalFormat, format_, type_) nCols = (width+maxTexSize-1) // maxTexSize colWidths = [width // nCols] * nCols colWidths[-1] += width % nCols nRows = (height+maxTexSize-1) // maxTexSize rowHeights = [height//nRows] * nRows rowHeights[-1] += height % nRows tiles = [] yOrig = 0 for hData in rowHeights: xOrig = 0 for wData in colWidths: if (hData < MIN_TEXTURE_SIZE or wData < MIN_TEXTURE_SIZE) \ and not _checkTexture2D(internalFormat, wData, hData, format_, type_): # Ensure texture size is at least MIN_TEXTURE_SIZE tH = max(hData, MIN_TEXTURE_SIZE) tW = max(wData, MIN_TEXTURE_SIZE) uMax, vMax = float(wData)/tW, float(hData)/tH texture = Texture2D(internalFormat, tW, tH, format_, type_, None, texUnit=texUnit, minFilter=self._MIN_FILTER, magFilter=self._MAG_FILTER, wrapS=self._WRAP_S, wrapT=self._WRAP_T, unpackAlign=unpackAlign) texture.update(format_, type_, data, width=wData, height=hData, unpackRowLength=width, unpackSkipPixels=xOrig, unpackSkipRows=yOrig) else: uMax, vMax = 1, 1 texture = Texture2D(internalFormat, wData, hData, format_, type_, data, texUnit=texUnit, minFilter=self._MIN_FILTER, magFilter=self._MAG_FILTER, wrapS=self._WRAP_S, wrapT=self._WRAP_T, unpackAlign=unpackAlign, unpackRowLength=width, unpackSkipPixels=xOrig, unpackSkipRows=yOrig) vertices = np.array(( (xOrig, yOrig, 0., 0.), (xOrig + wData, yOrig, uMax, 0.), (xOrig, yOrig + hData, 0., vMax), (xOrig + wData, yOrig + hData, uMax, vMax)), dtype=np.float32) tiles.append((texture, vertices, {'xOrigData': xOrig, 'yOrigData': yOrig, 'wData': wData, 'hData': hData})) xOrig += wData yOrig += hData self.tiles = tuple(tiles) def discard(self): for texture, vertices, _ in self.tiles: texture.discard() del self.tiles def updateAll(self, format_, type_, data, texUnit=0, unpackAlign=1): if not hasattr(self, 'tiles'): raise RuntimeError("No texture, discard has already been called") assert data.shape[:2] == (self.height, self.width) if len(self.tiles) == 1: self.tiles[0][0].update(format_, type_, data, width=self.width, height=self.height, texUnit=texUnit, unpackAlign=unpackAlign) else: for texture, _, info in self.tiles: texture.update(format_, type_, data, width=info['wData'], height=info['hData'], texUnit=texUnit, unpackAlign=unpackAlign, unpackRowLength=self.width, unpackSkipPixels=info['xOrigData'], unpackSkipRows=info['yOrigData']) def render(self, posAttrib, texAttrib, texUnit=0): try: tiles = self.tiles except AttributeError: raise RuntimeError("No texture, discard has already been called") for texture, vertices, _ in tiles: texture.bind(texUnit) stride = vertices.shape[-1] * vertices.itemsize glEnableVertexAttribArray(posAttrib) glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, stride, vertices) texCoordsPtr = c_void_p(vertices.ctypes.data + 2 * vertices.itemsize) glEnableVertexAttribArray(texAttrib) glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, stride, texCoordsPtr) glDrawArrays(GL_TRIANGLE_STRIP, 0, len(vertices))