Source code for silx.gui.plot3d.scene.viewport

# coding: utf-8
# /*##########################################################################
#
# Copyright (c) 2015-2017 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.
"""

from __future__ import absolute_import, division, unicode_literals

__authors__ = ["T. Vincent"]
__license__ = "MIT"
__date__ = "25/07/2016"


import numpy

from silx.gui.plot.Colors import rgba

from ..glutils import gl

from . import camera
from . import event
from . import transform
from .function import DirectionalLight, ClippingPlane


[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. """ def __init__(self, viewport, glContext): self._viewport = viewport self._glContext = glContext self._transformStack = [viewport.camera.extrinsic] self._clipPlane = ClippingPlane(normal=(0., 0., 0.)) @property
[docs] def viewport(self): """Viewport doing the current rendering""" return self._viewport
@property
[docs] def glCtx(self): """The OpenGL context in use""" return self._glContext
@property
[docs] def objectToCamera(self): """The current transform from object to camera coords. Do not modify. """ return self._transformStack[-1]
@property
[docs] def projection(self): """Projection transform. Do not modify. """ return self.viewport.camera.intrinsic
@property
[docs] 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
[docs] def clipper(self): """The current clipping plane """ return self._clipPlane
[docs] def setClipPlane(self, point=(0., 0., 0.), normal=(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]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., 1. self._camera = camera.Camera(fovy=30., near=1., far=100., position=(0., 0., 12.)) self._camera.addListener(self._changed) self._transforms = transform.TransformList([self._camera]) self._light = DirectionalLight(direction=(0., 0., -1.), ambient=(0.3, 0.3, 0.3), diffuse=(0.7, 0.7, 0.7)) self._light.addListener(self._changed) @property
[docs] 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
[docs] 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): """Background color of the viewport (4-tuple of float in [0, 1]""" return self._background @background.setter
[docs] def background(self, color): color = rgba(color) if self._background != color: self._background = color self._changed()
@property
[docs] def camera(self): """The camera used to render the scene.""" return self._camera
@property
[docs] def light(self): """The light used to render the scene.""" return self._light
@property def origin(self): """Origin (ox, oy) of the viewport in pixels""" return self._origin @origin.setter
[docs] 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
[docs] 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
[docs] 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
[docs] 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., 1.) # 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) 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) 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.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. """ self.camera.resetCamera(self.scene.bounds(transformed=True))
[docs] def orbitCamera(self, direction, angle=1.): """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) 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) bounds = self.camera.extrinsic.transformBounds(bounds) center = 0.5 * (bounds[0] + bounds[1]) ndcCenter = self.camera.intrinsic.transformPoint( center, perspectiveDivide=True) step *= 2. # 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. or x > width or y < 0. or y > height): return None # Out of viewport ndcx = 2. * x / float(width) - 1. ndcy = 1. - 2. * 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. or ndcX > 1. or ndcY < -1. or ndcY > 1.)): return None # Outside viewport ox, oy = self._origin width, height = self.size winx = ox + width * 0.5 * (ndcX + 1.) winy = oy + height * 0.5 * (1. - ndcY) return winx, winy
def _pickNdcZGL(self, x, y): """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. :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) depth = gl.glReadPixels( x, y, 1, 1, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT)[0] gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) # This is not GL|ES friendly # Z in NDC in [-1., 1.] return float(depth) * 2. - 1. 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.), 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.