# /*##########################################################################
#
# Copyright (c) 2015-2019 European Synchrotron Radiation Facility
#
# 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.
#
# ###########################################################################*/
"""This module provides a class to control a viewport on the rendering window.
The :class:`Viewport` describes a Viewport rendering a scene.
The attribute :attr:`scene` is the root group of the scene tree.
:class:`RenderContext` handles the current state during rendering.
"""
__authors__ = ["T. Vincent"]
__license__ = "MIT"
__date__ = "24/04/2018"
import string
import numpy
from silx.gui.colors import rgba
from ..._glutils import gl
from . import camera
from . import event
from . import transform
from .function import DirectionalLight, ClippingPlane, Fog
[docs]
class RenderContext(object):
"""Handle a current rendering context.
An instance of this class is passed to rendering method through
the scene during render.
User should NEVER use an instance of this class beyond the method
it is passed to as an argument (i.e., do not keep a reference to it).
:param Viewport viewport: The viewport doing the rendering.
:param Context glContext: The operating system OpenGL context in use.
"""
_FRAGMENT_SHADER_SRC = string.Template(
"""
void scene_post(vec4 cameraPosition) {
gl_FragColor = $fogCall(gl_FragColor, cameraPosition);
}
"""
)
def __init__(self, viewport, glContext):
self._viewport = viewport
self._glContext = glContext
self._transformStack = [viewport.camera.extrinsic]
self._clipPlane = ClippingPlane(normal=(0.0, 0.0, 0.0))
# cache
self.__cache = {}
[docs]
def cache(self, key, factory, *args, **kwargs):
"""Lazy-loading cache to store values in the context for rendering
:param key: The key to retrieve
:param factory: A callback taking args and kwargs as arguments
and returning the value to store.
:return: The stored or newly allocated value
"""
if key not in self.__cache:
self.__cache[key] = factory(*args, **kwargs)
return self.__cache[key]
@property
def viewport(self):
"""Viewport doing the current rendering"""
return self._viewport
@property
def glCtx(self):
"""The OpenGL context in use"""
return self._glContext
@property
def objectToCamera(self):
"""The current transform from object to camera coords.
Do not modify.
"""
return self._transformStack[-1]
@property
def projection(self):
"""Projection transform.
Do not modify.
"""
return self.viewport.camera.intrinsic
@property
def objectToNDC(self):
"""The transform from object to NDC (this includes projection).
Do not modify.
"""
return transform.StaticTransformList((self.projection, self.objectToCamera))
[docs]
def pushTransform(self, transform_, multiply=True):
"""Push a :class:`Transform` on the transform stack.
:param Transform transform_: The transform to add to the stack.
:param bool multiply:
True (the default) to multiply with the top of the stack,
False to push the transform as is without multiplication.
"""
if multiply:
assert len(self._transformStack) >= 1
transform_ = transform.StaticTransformList(
(self._transformStack[-1], transform_)
)
self._transformStack.append(transform_)
[docs]
def popTransform(self):
"""Pop the transform on top of the stack.
:return: The Transform that is popped from the stack.
"""
assert len(self._transformStack) > 1
return self._transformStack.pop()
@property
def clipper(self):
"""The current clipping plane (ClippingPlane)"""
return self._clipPlane
[docs]
def setClipPlane(self, point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 0.0)):
"""Set the clipping plane to use
For now only handles a single clipping plane.
:param point: A point of the plane
:type point: 3-tuple of float
:param normal: Normal vector of the plane or (0, 0, 0) for no clipping
:type normal: 3-tuple of float
"""
self._clipPlane = ClippingPlane(point, normal)
[docs]
def setupProgram(self, program):
"""Sets-up uniforms of a program using the context shader functions.
:param GLProgram program: The program to set-up.
It MUST be in use and using the context function.
"""
self.clipper.setupProgram(self, program)
self.viewport.fog.setupProgram(self, program)
@property
def fragDecl(self):
"""Fragment shader declaration for scene shader functions"""
return "\n".join(
(
self.clipper.fragDecl,
self.viewport.fog.fragDecl,
self._FRAGMENT_SHADER_SRC.substitute(
fogCall=self.viewport.fog.fragCall
),
)
)
@property
def fragCallPre(self):
"""Fragment shader call for scene shader functions (to do first)
It takes the camera position (vec4) as argument.
"""
return self.clipper.fragCall
@property
def fragCallPost(self):
"""Fragment shader call for scene shader functions (to do last)
It takes the camera position (vec4) as argument.
"""
return "scene_post"
[docs]
class Viewport(event.Notifier):
"""Rendering a single scene through a camera in part of a framebuffer.
:param int framebuffer: The framebuffer ID this viewport is rendering into
"""
def __init__(self, framebuffer=0):
from . import Group # Here to avoid cyclic import
super(Viewport, self).__init__()
self._dirty = True
self._origin = 0, 0
self._size = 1, 1
self._framebuffer = int(framebuffer)
self.scene = Group() # The stuff to render, add overlaid scenes?
self.scene._setParent(self)
self.scene.addListener(self._changed)
self._background = 0.0, 0.0, 0.0, 1.0
self._camera = camera.Camera(
fovy=30.0, near=1.0, far=100.0, position=(0.0, 0.0, 12.0)
)
self._camera.addListener(self._changed)
self._transforms = transform.TransformList([self._camera])
self._light = DirectionalLight(
direction=(0.0, 0.0, -1.0), ambient=(0.3, 0.3, 0.3), diffuse=(0.7, 0.7, 0.7)
)
self._light.addListener(self._changed)
self._fog = Fog()
self._fog.isOn = False
self._fog.addListener(self._changed)
@property
def transforms(self):
"""Proxy of camera transforms.
Do not modify the list.
"""
return self._transforms
def _changed(self, *args, **kwargs):
"""Callback handling scene updates"""
self._dirty = True
self.notify()
@property
def dirty(self):
"""True if scene is dirty and needs redisplay."""
return self._dirty
[docs]
def resetDirty(self):
"""Mark the scene as not being dirty.
To call after rendering.
"""
self._dirty = False
@property
def background(self):
"""Viewport's background color (4-tuple of float in [0, 1] or None)
The background color is used to clear to viewport.
If None, the viewport is not cleared
"""
return self._background
@background.setter
def background(self, color):
if color is not None:
color = rgba(color)
if self._background != color:
self._background = color
self._changed()
@property
def camera(self):
"""The camera used to render the scene."""
return self._camera
@property
def light(self):
"""The light used to render the scene."""
return self._light
@property
def fog(self):
"""The fog function used to render the scene"""
return self._fog
@property
def origin(self):
"""Origin (ox, oy) of the viewport in pixels"""
return self._origin
@origin.setter
def origin(self, origin):
ox, oy = origin
origin = int(ox), int(oy)
if origin != self._origin:
self._origin = origin
self._changed()
@property
def size(self):
"""Size (width, height) of the viewport in pixels"""
return self._size
@size.setter
def size(self, size):
w, h = size
size = int(w), int(h)
if size != self._size:
self._size = size
self.camera.intrinsic.size = size
self._changed()
@property
def shape(self):
"""Shape (height, width) of the viewport in pixels.
This is a convenient wrapper to the inverse of size.
"""
return self._size[1], self._size[0]
@shape.setter
def shape(self, shape):
self.size = shape[1], shape[0]
@property
def framebuffer(self):
"""The framebuffer ID this viewport is rendering into (int)"""
return self._framebuffer
@framebuffer.setter
def framebuffer(self, framebuffer):
self._framebuffer = int(framebuffer)
[docs]
def render(self, glContext):
"""Perform the rendering of the viewport
:param Context glContext: The context used for rendering"""
# Get a chance to run deferred delete
glContext.cleanGLGarbage()
# OpenGL set-up: really need to be done once
ox, oy = self.origin
w, h = self.size
gl.glViewport(ox, oy, w, h)
gl.glEnable(gl.GL_SCISSOR_TEST)
gl.glScissor(ox, oy, w, h)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LEQUAL)
gl.glDepthRange(0.0, 1.0)
# gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
# gl.glPolygonOffset(1., 1.)
gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gl.glEnable(gl.GL_LINE_SMOOTH)
if self.background is None:
gl.glClear(gl.GL_STENCIL_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
else:
gl.glClearColor(*self.background)
# Prepare OpenGL
gl.glClear(
gl.GL_COLOR_BUFFER_BIT
| gl.GL_STENCIL_BUFFER_BIT
| gl.GL_DEPTH_BUFFER_BIT
)
ctx = RenderContext(self, glContext)
self.scene.render(ctx)
self.scene.postRender(ctx)
[docs]
def adjustCameraDepthExtent(self):
"""Update camera depth extent to fit the scene bounds.
Only near and far planes are updated.
The scene might still not be fully visible
(e.g., if spanning behind the viewpoint with perspective projection).
"""
bounds = self.scene.bounds(transformed=True)
if bounds is None:
bounds = numpy.array(
((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), dtype=numpy.float32
)
bounds = self.camera.extrinsic.transformBounds(bounds)
if isinstance(self.camera.intrinsic, transform.Perspective):
# This needs to be reworked
zbounds = -bounds[:, 2]
zextent = max(numpy.fabs(zbounds[0] - zbounds[1]), 0.0001)
near = max(zextent / 1000.0, 0.95 * zbounds[1])
far = max(near + 0.1, 1.05 * zbounds[0])
self.camera.intrinsic.setDepthExtent(near, far)
elif isinstance(self.camera.intrinsic, transform.Orthographic):
# Makes sure z bounds are included
border = max(abs(bounds[:, 2]))
self.camera.intrinsic.setDepthExtent(-border, border)
else:
raise RuntimeError("Unsupported camera", self.camera.intrinsic)
[docs]
def resetCamera(self):
"""Change camera to have the whole scene in the viewing frustum.
It updates the camera position and depth extent.
Camera sight direction and up are not affected.
"""
bounds = self.scene.bounds(transformed=True)
if bounds is None:
bounds = numpy.array(
((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), dtype=numpy.float32
)
self.camera.resetCamera(bounds)
[docs]
def orbitCamera(self, direction, angle=1.0):
"""Rotate the camera around center of the scene.
:param str direction: Direction of movement relative to image plane.
In: 'up', 'down', 'left', 'right'.
:param float angle: he angle in degrees of the rotation.
"""
bounds = self.scene.bounds(transformed=True)
if bounds is None:
bounds = numpy.array(
((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), dtype=numpy.float32
)
center = 0.5 * (bounds[0] + bounds[1])
self.camera.orbit(direction, center, angle)
[docs]
def moveCamera(self, direction, step=0.1):
"""Move the camera relative to the image plane.
:param str direction: Direction relative to image plane.
One of: 'up', 'down', 'left', 'right',
'forward', 'backward'.
:param float step: The ratio of data to step for each pan.
"""
bounds = self.scene.bounds(transformed=True)
if bounds is None:
bounds = numpy.array(
((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)), dtype=numpy.float32
)
bounds = self.camera.extrinsic.transformBounds(bounds)
center = 0.5 * (bounds[0] + bounds[1])
ndcCenter = self.camera.intrinsic.transformPoint(center, perspectiveDivide=True)
step *= 2.0 # NDC has size 2
if direction == "up":
ndcCenter[1] -= step
elif direction == "down":
ndcCenter[1] += step
elif direction == "right":
ndcCenter[0] -= step
elif direction == "left":
ndcCenter[0] += step
elif direction == "forward":
ndcCenter[2] += step
elif direction == "backward":
ndcCenter[2] -= step
else:
raise ValueError("Unsupported direction: %s" % direction)
newCenter = self.camera.intrinsic.transformPoint(
ndcCenter, direct=False, perspectiveDivide=True
)
self.camera.move(direction, numpy.linalg.norm(newCenter - center))
[docs]
def windowToNdc(self, winX, winY, checkInside=True):
"""Convert position from window to normalized device coordinates.
If window coordinates are int, they are moved half a pixel
to be positioned at the center of pixel.
:param winX: X window coord, origin left.
:param winY: Y window coord, origin top.
:param bool checkInside: If True, returns None if position is
outside viewport.
:return: (x, y) Normalize device coordinates in [-1, 1] or None.
Origin center, x to the right, y goes upward.
"""
ox, oy = self._origin
width, height = self.size
# If int, move it to the center of pixel
if isinstance(winX, int):
winX += 0.5
if isinstance(winY, int):
winY += 0.5
x, y = winX - ox, winY - oy
if checkInside and (x < 0.0 or x > width or y < 0.0 or y > height):
return None # Out of viewport
ndcx = 2.0 * x / float(width) - 1.0
ndcy = 1.0 - 2.0 * y / float(height)
return ndcx, ndcy
[docs]
def ndcToWindow(self, ndcX, ndcY, checkInside=True):
"""Convert position from normalized device coordinates (NDC) to window.
:param float ndcX: X NDC coord.
:param float ndcY: Y NDC coord.
:param bool checkInside: If True, returns None if position is
outside viewport.
:return: (x, y) window coordinates or None.
Origin top-left, x to the right, y goes downward.
"""
if checkInside and (ndcX < -1.0 or ndcX > 1.0 or ndcY < -1.0 or ndcY > 1.0):
return None # Outside viewport
ox, oy = self._origin
width, height = self.size
winx = ox + width * 0.5 * (ndcX + 1.0)
winy = oy + height * 0.5 * (1.0 - ndcY)
return winx, winy
def _pickNdcZGL(self, x, y, offset=0):
"""Retrieve depth from depth buffer and return corresponding NDC Z.
:param int x: In pixels in window coordinates, origin left.
:param int y: In pixels in window coordinates, origin top.
:param int offset: Number of pixels to look at around the given pixel
:return: Normalize device Z coordinate of depth in [-1, 1]
or None if outside viewport.
:rtype: float or None
"""
ox, oy = self._origin
width, height = self.size
x = int(x)
y = height - int(y) # Invert y coord
if x < ox or x > ox + width or y < oy or y > oy + height:
# Outside viewport
return None
# Get depth from depth buffer in [0., 1.]
# Bind used framebuffer to get depth
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.framebuffer)
if offset == 0: # Fast path
# glReadPixels is not GL|ES friendly
depthPatch = gl.glReadPixels(x, y, 1, 1, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT)
depth = numpy.ravel(depthPatch)[0]
else:
offset = abs(int(offset))
size = 2 * offset + 1
depthPatch = gl.glReadPixels(
x - offset, y - offset, size, size, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT
)
depthPatch = depthPatch.ravel() # Work in 1D
# TODO cache sortedIndices to avoid computing it each time
# Compute distance of each pixels to the center of the patch
offsetToCenter = numpy.arange(-offset, offset + 1, dtype=numpy.float32) ** 2
sqDistToCenter = numpy.add.outer(offsetToCenter, offsetToCenter)
# Use distance to center to sort values from the patch
sortedIndices = numpy.argsort(sqDistToCenter.ravel())
sortedValues = depthPatch[sortedIndices]
# Take first depth that is not 1 in the sorted values
hits = sortedValues[sortedValues != 1.0]
depth = 1.0 if len(hits) == 0 else hits[0]
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
# Z in NDC in [-1., 1.]
return float(depth) * 2.0 - 1.0
def _getXZYGL(self, x, y):
ndc = self.windowToNdc(x, y)
if ndc is None:
return None # Outside viewport
ndcz = self._pickNdcZGL(x, y)
ndcpos = numpy.array((ndc[0], ndc[1], ndcz, 1.0), dtype=numpy.float32)
camerapos = self.camera.intrinsic.transformPoint(
ndcpos, direct=False, perspectiveDivide=True
)
scenepos = self.camera.extrinsic.transformPoint(camerapos, direct=False)
return scenepos[:3]
def pick(self, x, y):
pass
# ndcX, ndcY = self.windowToNdc(x, y)
# ndcNearPt = ndcX, ndcY, -1.
# ndcFarPT = ndcX, ndcY, 1.
