From f1fe73d1909a2448a004a88362a1a532d0d4f7c3 Mon Sep 17 00:00:00 2001 From: sanine Date: Sun, 12 Feb 2023 23:53:22 -0600 Subject: switch to tinyobj and nanovg from assimp and cairo --- libs/assimp/port/PyAssimp/scripts/3d_viewer.py | 1318 --------------- libs/assimp/port/PyAssimp/scripts/3d_viewer_py3.py | 1316 --------------- libs/assimp/port/PyAssimp/scripts/README.md | 13 - .../PyAssimp/scripts/fixed_pipeline_3d_viewer.py | 372 ----- libs/assimp/port/PyAssimp/scripts/quicktest.py | 53 - libs/assimp/port/PyAssimp/scripts/sample.py | 89 - .../port/PyAssimp/scripts/transformations.py | 1705 -------------------- 7 files changed, 4866 deletions(-) delete mode 100755 libs/assimp/port/PyAssimp/scripts/3d_viewer.py delete mode 100755 libs/assimp/port/PyAssimp/scripts/3d_viewer_py3.py delete mode 100644 libs/assimp/port/PyAssimp/scripts/README.md delete mode 100755 libs/assimp/port/PyAssimp/scripts/fixed_pipeline_3d_viewer.py delete mode 100755 libs/assimp/port/PyAssimp/scripts/quicktest.py delete mode 100755 libs/assimp/port/PyAssimp/scripts/sample.py delete mode 100644 libs/assimp/port/PyAssimp/scripts/transformations.py (limited to 'libs/assimp/port/PyAssimp/scripts') diff --git a/libs/assimp/port/PyAssimp/scripts/3d_viewer.py b/libs/assimp/port/PyAssimp/scripts/3d_viewer.py deleted file mode 100755 index 08a6266..0000000 --- a/libs/assimp/port/PyAssimp/scripts/3d_viewer.py +++ /dev/null @@ -1,1318 +0,0 @@ -#!/usr/bin/env python -# -*- coding: UTF-8 -*- - -""" This program loads a model with PyASSIMP, and display it. - -Based on: -- pygame code from http://3dengine.org/Spectator_%28PyOpenGL%29 -- http://www.lighthouse3d.com/tutorials -- http://www.songho.ca/opengl/gl_transform.html -- http://code.activestate.com/recipes/325391/ -- ASSIMP's C++ SimpleOpenGL viewer - -Authors: Séverin Lemaignan, 2012-2016 -""" -import sys -import logging - -logger = logging.getLogger("pyassimp") -gllogger = logging.getLogger("OpenGL") -gllogger.setLevel(logging.WARNING) -logging.basicConfig(level=logging.INFO) - -import OpenGL - -OpenGL.ERROR_CHECKING = False -OpenGL.ERROR_LOGGING = False -# OpenGL.ERROR_ON_COPY = True -# OpenGL.FULL_LOGGING = True -from OpenGL.GL import * -from OpenGL.arrays import vbo -from OpenGL.GL import shaders - -import pygame -import pygame.font -import pygame.image - -import math, random -from numpy import linalg - -import pyassimp -from pyassimp.postprocess import * -from pyassimp.helper import * -import transformations - -ROTATION_180_X = numpy.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]], dtype=numpy.float32) - -# rendering mode -BASE = "BASE" -COLORS = "COLORS" -SILHOUETTE = "SILHOUETTE" -HELPERS = "HELPERS" - -# Entities type -ENTITY = "entity" -CAMERA = "camera" -MESH = "mesh" - -FLAT_VERTEX_SHADER_120 = """ -#version 120 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; - -uniform vec4 u_materialDiffuse; - -attribute vec3 a_vertex; - -varying vec4 v_color; - -void main(void) -{ - v_color = u_materialDiffuse; - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -FLAT_VERTEX_SHADER_130 = """ -#version 130 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; - -uniform vec4 u_materialDiffuse; - -in vec3 a_vertex; - -out vec4 v_color; - -void main(void) -{ - v_color = u_materialDiffuse; - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -BASIC_VERTEX_SHADER_120 = """ -#version 120 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; - -uniform vec4 u_materialDiffuse; - -attribute vec3 a_vertex; -attribute vec3 a_normal; - -varying vec4 v_color; - -void main(void) -{ - // Now the normal is in world space, as we pass the light in world space. - vec3 normal = u_normalMatrix * a_normal; - - float dist = distance(a_vertex, u_lightPos); - - // go to https://www.desmos.com/calculator/nmnaud1hrw to play with the parameters - // att is not used for now - float att=1.0/(1.0+0.8*dist*dist); - - vec3 surf2light = normalize(u_lightPos - a_vertex); - vec3 norm = normalize(normal); - float dcont=max(0.0,dot(norm,surf2light)); - - float ambient = 0.3; - float intensity = dcont + 0.3 + ambient; - - v_color = u_materialDiffuse * intensity; - - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -BASIC_VERTEX_SHADER_130 = """ -#version 130 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; - -uniform vec4 u_materialDiffuse; - -in vec3 a_vertex; -in vec3 a_normal; - -out vec4 v_color; - -void main(void) -{ - // Now the normal is in world space, as we pass the light in world space. - vec3 normal = u_normalMatrix * a_normal; - - float dist = distance(a_vertex, u_lightPos); - - // go to https://www.desmos.com/calculator/nmnaud1hrw to play with the parameters - // att is not used for now - float att=1.0/(1.0+0.8*dist*dist); - - vec3 surf2light = normalize(u_lightPos - a_vertex); - vec3 norm = normalize(normal); - float dcont=max(0.0,dot(norm,surf2light)); - - float ambient = 0.3; - float intensity = dcont + 0.3 + ambient; - - v_color = u_materialDiffuse * intensity; - - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -BASIC_FRAGMENT_SHADER_120 = """ -#version 120 - -varying vec4 v_color; - -void main() { - gl_FragColor = v_color; -} -""" - -BASIC_FRAGMENT_SHADER_130 = """ -#version 130 - -in vec4 v_color; - -void main() { - gl_FragColor = v_color; -} -""" - -GOOCH_VERTEX_SHADER_120 = """ -#version 120 - -// attributes -attribute vec3 a_vertex; // xyz - position -attribute vec3 a_normal; // xyz - normal - -// uniforms -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; -uniform vec3 u_camPos; - -// output data from vertex to fragment shader -varying vec3 o_normal; -varying vec3 o_lightVector; - -/////////////////////////////////////////////////////////////////// - -void main(void) -{ - // transform position and normal to world space - vec4 positionWorld = u_modelMatrix * vec4(a_vertex, 1.0); - vec3 normalWorld = u_normalMatrix * a_normal; - - // calculate and pass vectors required for lighting - o_lightVector = u_lightPos - positionWorld.xyz; - o_normal = normalWorld; - - // project world space position to the screen and output it - gl_Position = u_viewProjectionMatrix * positionWorld; -} -""" - -GOOCH_VERTEX_SHADER_130 = """ -#version 130 - -// attributes -in vec3 a_vertex; // xyz - position -in vec3 a_normal; // xyz - normal - -// uniforms -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; -uniform vec3 u_camPos; - -// output data from vertex to fragment shader -out vec3 o_normal; -out vec3 o_lightVector; - -/////////////////////////////////////////////////////////////////// - -void main(void) -{ - // transform position and normal to world space - vec4 positionWorld = u_modelMatrix * vec4(a_vertex, 1.0); - vec3 normalWorld = u_normalMatrix * a_normal; - - // calculate and pass vectors required for lighting - o_lightVector = u_lightPos - positionWorld.xyz; - o_normal = normalWorld; - - // project world space position to the screen and output it - gl_Position = u_viewProjectionMatrix * positionWorld; -} -""" - -GOOCH_FRAGMENT_SHADER_120 = """ -#version 120 - -// data from vertex shader -varying vec3 o_normal; -varying vec3 o_lightVector; - -// diffuse color of the object -uniform vec4 u_materialDiffuse; -// cool color of gooch shading -uniform vec3 u_coolColor; -// warm color of gooch shading -uniform vec3 u_warmColor; -// how much to take from object color in final cool color -uniform float u_alpha; -// how much to take from object color in final warm color -uniform float u_beta; - -/////////////////////////////////////////////////////////// - -void main(void) -{ - // normlize vectors for lighting - vec3 normalVector = normalize(o_normal); - vec3 lightVector = normalize(o_lightVector); - // intensity of diffuse lighting [-1, 1] - float diffuseLighting = dot(lightVector, normalVector); - // map intensity of lighting from range [-1; 1] to [0, 1] - float interpolationValue = (1.0 + diffuseLighting)/2; - - ////////////////////////////////////////////////////////////////// - - // cool color mixed with color of the object - vec3 coolColorMod = u_coolColor + vec3(u_materialDiffuse) * u_alpha; - // warm color mixed with color of the object - vec3 warmColorMod = u_warmColor + vec3(u_materialDiffuse) * u_beta; - // interpolation of cool and warm colors according - // to lighting intensity. The lower the light intensity, - // the larger part of the cool color is used - vec3 colorOut = mix(coolColorMod, warmColorMod, interpolationValue); - - ////////////////////////////////////////////////////////////////// - - // save color - gl_FragColor.rgb = colorOut; - gl_FragColor.a = 1; -} -""" - -GOOCH_FRAGMENT_SHADER_130 = """ -#version 130 - -// data from vertex shader -in vec3 o_normal; -in vec3 o_lightVector; - -// diffuse color of the object -uniform vec4 u_materialDiffuse; -// cool color of gooch shading -uniform vec3 u_coolColor; -// warm color of gooch shading -uniform vec3 u_warmColor; -// how much to take from object color in final cool color -uniform float u_alpha; -// how much to take from object color in final warm color -uniform float u_beta; - -// output to framebuffer -out vec4 resultingColor; - -/////////////////////////////////////////////////////////// - -void main(void) -{ - // normlize vectors for lighting - vec3 normalVector = normalize(o_normal); - vec3 lightVector = normalize(o_lightVector); - // intensity of diffuse lighting [-1, 1] - float diffuseLighting = dot(lightVector, normalVector); - // map intensity of lighting from range [-1; 1] to [0, 1] - float interpolationValue = (1.0 + diffuseLighting)/2; - - ////////////////////////////////////////////////////////////////// - - // cool color mixed with color of the object - vec3 coolColorMod = u_coolColor + vec3(u_materialDiffuse) * u_alpha; - // warm color mixed with color of the object - vec3 warmColorMod = u_warmColor + vec3(u_materialDiffuse) * u_beta; - // interpolation of cool and warm colors according - // to lighting intensity. The lower the light intensity, - // the larger part of the cool color is used - vec3 colorOut = mix(coolColorMod, warmColorMod, interpolationValue); - - ////////////////////////////////////////////////////////////////// - - // save color - resultingColor.rgb = colorOut; - resultingColor.a = 1; -} -""" - -SILHOUETTE_VERTEX_SHADER_120 = """ -#version 120 - -attribute vec3 a_vertex; // xyz - position -attribute vec3 a_normal; // xyz - normal - -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelViewMatrix; -uniform vec4 u_materialDiffuse; -uniform float u_bordersize; // width of the border - -varying vec4 v_color; - -void main(void){ - v_color = u_materialDiffuse; - float distToCamera = -(u_modelViewMatrix * vec4(a_vertex, 1.0)).z; - vec4 tPos = vec4(a_vertex + a_normal * u_bordersize * distToCamera, 1.0); - gl_Position = u_viewProjectionMatrix * u_modelMatrix * tPos; -} -""" - -SILHOUETTE_VERTEX_SHADER_130 = """ -#version 130 - -in vec3 a_vertex; // xyz - position -in vec3 a_normal; // xyz - normal - -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelViewMatrix; -uniform vec4 u_materialDiffuse; -uniform float u_bordersize; // width of the border - -out vec4 v_color; - -void main(void){ - v_color = u_materialDiffuse; - float distToCamera = -(u_modelViewMatrix * vec4(a_vertex, 1.0)).z; - vec4 tPos = vec4(a_vertex + a_normal * u_bordersize * distToCamera, 1.0); - gl_Position = u_viewProjectionMatrix * u_modelMatrix * tPos; -} -""" -DEFAULT_CLIP_PLANE_NEAR = 0.001 -DEFAULT_CLIP_PLANE_FAR = 1000.0 - - -def get_world_transform(scene, node): - if node == scene.rootnode: - return numpy.identity(4, dtype=numpy.float32) - - parents = reversed(_get_parent_chain(scene, node, [])) - parent_transform = reduce(numpy.dot, [p.transformation for p in parents]) - return numpy.dot(parent_transform, node.transformation) - - -def _get_parent_chain(scene, node, parents): - parent = node.parent - - parents.append(parent) - - if parent == scene.rootnode: - return parents - - return _get_parent_chain(scene, parent, parents) - - -class DefaultCamera: - def __init__(self, w, h, fov): - self.name = "default camera" - self.type = CAMERA - self.clipplanenear = DEFAULT_CLIP_PLANE_NEAR - self.clipplanefar = DEFAULT_CLIP_PLANE_FAR - self.aspect = w / h - self.horizontalfov = fov * math.pi / 180 - self.transformation = numpy.array([[0.68, -0.32, 0.65, 7.48], - [0.73, 0.31, -0.61, -6.51], - [-0.01, 0.89, 0.44, 5.34], - [0., 0., 0., 1.]], dtype=numpy.float32) - - self.transformation = numpy.dot(self.transformation, ROTATION_180_X) - - def __str__(self): - return self.name - - -class PyAssimp3DViewer: - base_name = "PyASSIMP 3D viewer" - - def __init__(self, model, w=1024, h=768): - - self.w = w - self.h = h - - pygame.init() - pygame.display.set_caption(self.base_name) - pygame.display.set_mode((w, h), pygame.OPENGL | pygame.DOUBLEBUF) - - glClearColor(0.18, 0.18, 0.18, 1.0) - - shader_compilation_succeeded = False - try: - self.set_shaders_v130() - self.prepare_shaders() - except RuntimeError, message: - sys.stderr.write("%s\n" % message) - sys.stdout.write("Could not compile shaders in version 1.30, trying version 1.20\n") - - if not shader_compilation_succeeded: - self.set_shaders_v120() - self.prepare_shaders() - - self.scene = None - self.meshes = {} # stores the OpenGL vertex/faces/normals buffers pointers - - self.node2colorid = {} # stores a color ID for each node. Useful for mouse picking and visibility checking - self.colorid2node = {} # reverse dict of node2colorid - - self.currently_selected = None - self.moving = False - self.moving_situation = None - - self.default_camera = DefaultCamera(self.w, self.h, fov=70) - self.cameras = [self.default_camera] - - self.current_cam_index = 0 - self.current_cam = self.default_camera - self.set_camera_projection() - - self.load_model(model) - - # user interactions - self.focal_point = [0, 0, 0] - self.is_rotating = False - self.is_panning = False - self.is_zooming = False - - def set_shaders_v120(self): - self.BASIC_VERTEX_SHADER = BASIC_VERTEX_SHADER_120 - self.FLAT_VERTEX_SHADER = FLAT_VERTEX_SHADER_120 - self.SILHOUETTE_VERTEX_SHADER = SILHOUETTE_VERTEX_SHADER_120 - self.GOOCH_VERTEX_SHADER = GOOCH_VERTEX_SHADER_120 - - self.BASIC_FRAGMENT_SHADER = BASIC_FRAGMENT_SHADER_120 - self.GOOCH_FRAGMENT_SHADER = GOOCH_FRAGMENT_SHADER_120 - - def set_shaders_v130(self): - self.BASIC_VERTEX_SHADER = BASIC_VERTEX_SHADER_130 - self.FLAT_VERTEX_SHADER = FLAT_VERTEX_SHADER_130 - self.SILHOUETTE_VERTEX_SHADER = SILHOUETTE_VERTEX_SHADER_130 - self.GOOCH_VERTEX_SHADER = GOOCH_VERTEX_SHADER_130 - - self.BASIC_FRAGMENT_SHADER = BASIC_FRAGMENT_SHADER_130 - self.GOOCH_FRAGMENT_SHADER = GOOCH_FRAGMENT_SHADER_130 - - def prepare_shaders(self): - - ### Base shader - vertex = shaders.compileShader(self.BASIC_VERTEX_SHADER, GL_VERTEX_SHADER) - fragment = shaders.compileShader(self.BASIC_FRAGMENT_SHADER, GL_FRAGMENT_SHADER) - - self.shader = shaders.compileProgram(vertex, fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_normalMatrix', - 'u_lightPos', - 'u_materialDiffuse'), - ('a_vertex', - 'a_normal'), self.shader) - - ### Flat shader - flatvertex = shaders.compileShader(self.FLAT_VERTEX_SHADER, GL_VERTEX_SHADER) - self.flatshader = shaders.compileProgram(flatvertex, fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_materialDiffuse',), - ('a_vertex',), self.flatshader) - - ### Silhouette shader - silh_vertex = shaders.compileShader(self.SILHOUETTE_VERTEX_SHADER, GL_VERTEX_SHADER) - self.silhouette_shader = shaders.compileProgram(silh_vertex, fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_modelViewMatrix', - 'u_materialDiffuse', - 'u_bordersize' # width of the silhouette - ), - ('a_vertex', - 'a_normal'), self.silhouette_shader) - - ### Gooch shader - gooch_vertex = shaders.compileShader(self.GOOCH_VERTEX_SHADER, GL_VERTEX_SHADER) - gooch_fragment = shaders.compileShader(self.GOOCH_FRAGMENT_SHADER, GL_FRAGMENT_SHADER) - self.gooch_shader = shaders.compileProgram(gooch_vertex, gooch_fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_normalMatrix', - 'u_lightPos', - 'u_materialDiffuse', - 'u_coolColor', - 'u_warmColor', - 'u_alpha', - 'u_beta' - ), - ('a_vertex', - 'a_normal'), self.gooch_shader) - - @staticmethod - def set_shader_accessors(uniforms, attributes, shader): - # add accessors to the shaders uniforms and attributes - for uniform in uniforms: - location = glGetUniformLocation(shader, uniform) - if location in (None, -1): - raise RuntimeError('No uniform: %s (maybe it is not used ' - 'anymore and has been optimized out by' - ' the shader compiler)' % uniform) - setattr(shader, uniform, location) - - for attribute in attributes: - location = glGetAttribLocation(shader, attribute) - if location in (None, -1): - raise RuntimeError('No attribute: %s' % attribute) - setattr(shader, attribute, location) - - @staticmethod - def prepare_gl_buffers(mesh): - - mesh.gl = {} - - # Fill the buffer for vertex and normals positions - v = numpy.array(mesh.vertices, 'f') - n = numpy.array(mesh.normals, 'f') - - mesh.gl["vbo"] = vbo.VBO(numpy.hstack((v, n))) - - # Fill the buffer for vertex positions - mesh.gl["faces"] = glGenBuffers(1) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) - glBufferData(GL_ELEMENT_ARRAY_BUFFER, - numpy.array(mesh.faces, dtype=numpy.int32), - GL_STATIC_DRAW) - - mesh.gl["nbfaces"] = len(mesh.faces) - - # Unbind buffers - glBindBuffer(GL_ARRAY_BUFFER, 0) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) - - @staticmethod - def get_rgb_from_colorid(colorid): - r = (colorid >> 0) & 0xff - g = (colorid >> 8) & 0xff - b = (colorid >> 16) & 0xff - - return r, g, b - - def get_color_id(self): - id = random.randint(0, 256 * 256 * 256) - if id not in self.colorid2node: - return id - else: - return self.get_color_id() - - def glize(self, scene, node): - - logger.info("Loading node <%s>" % node) - node.selected = True if self.currently_selected and self.currently_selected == node else False - - node.transformation = node.transformation.astype(numpy.float32) - - if node.meshes: - node.type = MESH - colorid = self.get_color_id() - self.colorid2node[colorid] = node - self.node2colorid[node.name] = colorid - - elif node.name in [c.name for c in scene.cameras]: - - # retrieve the ASSIMP camera object - [cam] = [c for c in scene.cameras if c.name == node.name] - node.type = CAMERA - logger.info("Added camera <%s>" % node.name) - logger.info("Camera position: %.3f, %.3f, %.3f" % tuple(node.transformation[:, 3][:3].tolist())) - self.cameras.append(node) - node.clipplanenear = cam.clipplanenear - node.clipplanefar = cam.clipplanefar - - if numpy.allclose(cam.lookat, [0, 0, -1]) and numpy.allclose(cam.up, [0, 1, 0]): # Cameras in .blend files - - # Rotate by 180deg around X to have Z pointing forward - node.transformation = numpy.dot(node.transformation, ROTATION_180_X) - else: - raise RuntimeError( - "I do not know how to normalize this camera orientation: lookat=%s, up=%s" % (cam.lookat, cam.up)) - - if cam.aspect == 0.0: - logger.warning("Camera aspect not set. Setting to default 4:3") - node.aspect = 1.333 - else: - node.aspect = cam.aspect - - node.horizontalfov = cam.horizontalfov - - else: - node.type = ENTITY - - for child in node.children: - self.glize(scene, child) - - def load_model(self, path, postprocess=aiProcessPreset_TargetRealtime_MaxQuality): - logger.info("Loading model:" + path + "...") - - if postprocess: - self.scene = pyassimp.load(path, processing=postprocess) - else: - self.scene = pyassimp.load(path) - logger.info("Done.") - - scene = self.scene - # log some statistics - logger.info(" meshes: %d" % len(scene.meshes)) - logger.info(" total faces: %d" % sum([len(mesh.faces) for mesh in scene.meshes])) - logger.info(" materials: %d" % len(scene.materials)) - self.bb_min, self.bb_max = get_bounding_box(self.scene) - logger.info(" bounding box:" + str(self.bb_min) + " - " + str(self.bb_max)) - - self.scene_center = [(a + b) / 2. for a, b in zip(self.bb_min, self.bb_max)] - - for index, mesh in enumerate(scene.meshes): - self.prepare_gl_buffers(mesh) - - self.glize(scene, scene.rootnode) - - # Finally release the model - pyassimp.release(scene) - logger.info("Ready for 3D rendering!") - - def cycle_cameras(self): - - self.current_cam_index = (self.current_cam_index + 1) % len(self.cameras) - self.current_cam = self.cameras[self.current_cam_index] - self.set_camera_projection(self.current_cam) - logger.info("Switched to camera <%s>" % self.current_cam) - - def set_overlay_projection(self): - glViewport(0, 0, self.w, self.h) - glMatrixMode(GL_PROJECTION) - glLoadIdentity() - glOrtho(0.0, self.w - 1.0, 0.0, self.h - 1.0, -1.0, 1.0) - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - - def set_camera_projection(self, camera=None): - - if not camera: - camera = self.current_cam - - znear = camera.clipplanenear or DEFAULT_CLIP_PLANE_NEAR - zfar = camera.clipplanefar or DEFAULT_CLIP_PLANE_FAR - aspect = camera.aspect - fov = camera.horizontalfov - - glMatrixMode(GL_PROJECTION) - glLoadIdentity() - - # Compute gl frustrum - tangent = math.tan(fov / 2.) - h = znear * tangent - w = h * aspect - - # params: left, right, bottom, top, near, far - glFrustum(-w, w, -h, h, znear, zfar) - # equivalent to: - # gluPerspective(fov * 180/math.pi, aspect, znear, zfar) - - self.projection_matrix = glGetFloatv(GL_PROJECTION_MATRIX).transpose() - - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - - def render_colors(self): - - glEnable(GL_DEPTH_TEST) - glDepthFunc(GL_LEQUAL) - - glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) - glEnable(GL_CULL_FACE) - - glUseProgram(self.flatshader) - - glUniformMatrix4fv(self.flatshader.u_viewProjectionMatrix, 1, GL_TRUE, - numpy.dot(self.projection_matrix, self.view_matrix)) - - self.recursive_render(self.scene.rootnode, self.flatshader, mode=COLORS) - - glUseProgram(0) - - def get_hovered_node(self, mousex, mousey): - """ - Attention: The performances of this method relies heavily on the size of the display! - """ - - # mouse out of the window? - if mousex < 0 or mousex >= self.w or mousey < 0 or mousey >= self.h: - return None - - self.render_colors() - # Capture image from the OpenGL buffer - buf = (GLubyte * (3 * self.w * self.h))(0) - glReadPixels(0, 0, self.w, self.h, GL_RGB, GL_UNSIGNED_BYTE, buf) - - # Reinterpret the RGB pixel buffer as a 1-D array of 24bits colors - a = numpy.ndarray(len(buf), numpy.dtype('>u1'), buf) - colors = numpy.zeros(len(buf) / 3, numpy.dtype('u1')[i::3] - - colorid = colors[mousex + mousey * self.w] - - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) - - if colorid in self.colorid2node: - return self.colorid2node[colorid] - - def render(self, wireframe=False, twosided=False): - - glEnable(GL_DEPTH_TEST) - glDepthFunc(GL_LEQUAL) - - glPolygonMode(GL_FRONT_AND_BACK, GL_LINE if wireframe else GL_FILL) - glDisable(GL_CULL_FACE) if twosided else glEnable(GL_CULL_FACE) - - self.render_grid() - - self.recursive_render(self.scene.rootnode, None, mode=HELPERS) - - ### First, the silhouette - - if False: - shader = self.silhouette_shader - - # glDepthMask(GL_FALSE) - glCullFace(GL_FRONT) # cull front faces - - glUseProgram(shader) - glUniform1f(shader.u_bordersize, 0.01) - - glUniformMatrix4fv(shader.u_viewProjectionMatrix, 1, GL_TRUE, - numpy.dot(self.projection_matrix, self.view_matrix)) - - self.recursive_render(self.scene.rootnode, shader, mode=SILHOUETTE) - - glUseProgram(0) - - ### Then, inner shading - # glDepthMask(GL_TRUE) - glCullFace(GL_BACK) - - use_gooch = False - if use_gooch: - shader = self.gooch_shader - - glUseProgram(shader) - glUniform3f(shader.u_lightPos, -.5, -.5, .5) - - ##### GOOCH specific - glUniform3f(shader.u_coolColor, 159.0 / 255, 148.0 / 255, 255.0 / 255) - glUniform3f(shader.u_warmColor, 255.0 / 255, 75.0 / 255, 75.0 / 255) - glUniform1f(shader.u_alpha, .25) - glUniform1f(shader.u_beta, .25) - ######### - else: - shader = self.shader - glUseProgram(shader) - glUniform3f(shader.u_lightPos, -.5, -.5, .5) - - glUniformMatrix4fv(shader.u_viewProjectionMatrix, 1, GL_TRUE, - numpy.dot(self.projection_matrix, self.view_matrix)) - - self.recursive_render(self.scene.rootnode, shader) - - glUseProgram(0) - - def render_axis(self, - transformation=numpy.identity(4, dtype=numpy.float32), - label=None, - size=0.2, - selected=False): - m = transformation.transpose() # OpenGL row major - - glPushMatrix() - glMultMatrixf(m) - - glLineWidth(3 if selected else 1) - - size = 2 * size if selected else size - - glBegin(GL_LINES) - - # draw line for x axis - glColor3f(1.0, 0.0, 0.0) - glVertex3f(0.0, 0.0, 0.0) - glVertex3f(size, 0.0, 0.0) - - # draw line for y axis - glColor3f(0.0, 1.0, 0.0) - glVertex3f(0.0, 0.0, 0.0) - glVertex3f(0.0, size, 0.0) - - # draw line for Z axis - glColor3f(0.0, 0.0, 1.0) - glVertex3f(0.0, 0.0, 0.0) - glVertex3f(0.0, 0.0, size) - - glEnd() - - if label: - self.showtext(label) - - glPopMatrix() - - @staticmethod - def render_camera(camera, transformation): - - m = transformation.transpose() # OpenGL row major - - aspect = camera.aspect - - u = 0.1 # unit size (in m) - l = 3 * u # length of the camera cone - f = 3 * u # aperture of the camera cone - - glPushMatrix() - glMultMatrixf(m) - - glLineWidth(2) - glBegin(GL_LINE_STRIP) - - glColor3f(.2, .2, .2) - - glVertex3f(u, u, -u) - glVertex3f(u, -u, -u) - glVertex3f(-u, -u, -u) - glVertex3f(-u, u, -u) - glVertex3f(u, u, -u) - - glVertex3f(u, u, 0.0) - glVertex3f(u, -u, 0.0) - glVertex3f(-u, -u, 0.0) - glVertex3f(-u, u, 0.0) - glVertex3f(u, u, 0.0) - - glVertex3f(f * aspect, f, l) - glVertex3f(f * aspect, -f, l) - glVertex3f(-f * aspect, -f, l) - glVertex3f(-f * aspect, f, l) - glVertex3f(f * aspect, f, l) - - glEnd() - - glBegin(GL_LINE_STRIP) - glVertex3f(u, -u, -u) - glVertex3f(u, -u, 0.0) - glVertex3f(f * aspect, -f, l) - glEnd() - - glBegin(GL_LINE_STRIP) - glVertex3f(-u, -u, -u) - glVertex3f(-u, -u, 0.0) - glVertex3f(-f * aspect, -f, l) - glEnd() - - glBegin(GL_LINE_STRIP) - glVertex3f(-u, u, -u) - glVertex3f(-u, u, 0.0) - glVertex3f(-f * aspect, f, l) - glEnd() - - glPopMatrix() - - @staticmethod - def render_grid(): - - glLineWidth(1) - glColor3f(0.5, 0.5, 0.5) - glBegin(GL_LINES) - for i in range(-10, 11): - glVertex3f(i, -10.0, 0.0) - glVertex3f(i, 10.0, 0.0) - - for i in range(-10, 11): - glVertex3f(-10.0, i, 0.0) - glVertex3f(10.0, i, 0.0) - glEnd() - - def recursive_render(self, node, shader, mode=BASE, with_normals=True): - """ Main recursive rendering method. - """ - - normals = with_normals - - if mode == COLORS: - normals = False - - - if not hasattr(node, "selected"): - node.selected = False - - m = get_world_transform(self.scene, node) - - # HELPERS mode - ### - if mode == HELPERS: - # if node.type == ENTITY: - self.render_axis(m, - label=node.name if node != self.scene.rootnode else None, - selected=node.selected if hasattr(node, "selected") else False) - - if node.type == CAMERA: - self.render_camera(node, m) - - for child in node.children: - self.recursive_render(child, shader, mode) - - return - - # Mesh rendering modes - ### - if node.type == MESH: - - for mesh in node.meshes: - - stride = 24 # 6 * 4 bytes - - if node.selected and mode == SILHOUETTE: - glUniform4f(shader.u_materialDiffuse, 1.0, 0.0, 0.0, 1.0) - glUniformMatrix4fv(shader.u_modelViewMatrix, 1, GL_TRUE, - numpy.dot(self.view_matrix, m)) - - else: - if mode == COLORS: - colorid = self.node2colorid[node.name] - r, g, b = self.get_rgb_from_colorid(colorid) - glUniform4f(shader.u_materialDiffuse, r / 255.0, g / 255.0, b / 255.0, 1.0) - elif mode == SILHOUETTE: - glUniform4f(shader.u_materialDiffuse, .0, .0, .0, 1.0) - else: - if node.selected: - diffuse = (1.0, 0.0, 0.0, 1.0) # selected nodes in red - else: - diffuse = mesh.material.properties["diffuse"] - if len(diffuse) == 3: # RGB instead of expected RGBA - diffuse.append(1.0) - glUniform4f(shader.u_materialDiffuse, *diffuse) - # if ambient: - # glUniform4f( shader.Material_ambient, *mat["ambient"] ) - - if mode == BASE: # not in COLORS or SILHOUETTE - normal_matrix = linalg.inv(numpy.dot(self.view_matrix, m)[0:3, 0:3]).transpose() - glUniformMatrix3fv(shader.u_normalMatrix, 1, GL_TRUE, normal_matrix) - - glUniformMatrix4fv(shader.u_modelMatrix, 1, GL_TRUE, m) - - vbo = mesh.gl["vbo"] - vbo.bind() - - glEnableVertexAttribArray(shader.a_vertex) - if normals: - glEnableVertexAttribArray(shader.a_normal) - - glVertexAttribPointer( - shader.a_vertex, - 3, GL_FLOAT, False, stride, vbo - ) - - if normals: - glVertexAttribPointer( - shader.a_normal, - 3, GL_FLOAT, False, stride, vbo + 12 - ) - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) - glDrawElements(GL_TRIANGLES, mesh.gl["nbfaces"] * 3, GL_UNSIGNED_INT, None) - - vbo.unbind() - glDisableVertexAttribArray(shader.a_vertex) - - if normals: - glDisableVertexAttribArray(shader.a_normal) - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) - - for child in node.children: - self.recursive_render(child, shader, mode) - - - def switch_to_overlay(self): - glPushMatrix() - self.set_overlay_projection() - - def switch_from_overlay(self): - self.set_camera_projection() - glPopMatrix() - - def select_node(self, node): - self.currently_selected = node - self.update_node_select(self.scene.rootnode) - - def update_node_select(self, node): - if node is self.currently_selected: - node.selected = True - else: - node.selected = False - - for child in node.children: - self.update_node_select(child) - - def loop(self): - - pygame.display.flip() - - if not self.process_events(): - return False # ESC has been pressed - - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) - - return True - - def process_events(self): - - LEFT_BUTTON = 1 - MIDDLE_BUTTON = 2 - RIGHT_BUTTON = 3 - WHEEL_UP = 4 - WHEEL_DOWN = 5 - - dx, dy = pygame.mouse.get_rel() - mousex, mousey = pygame.mouse.get_pos() - - zooming_one_shot = False - - ok = True - - for evt in pygame.event.get(): - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button == LEFT_BUTTON: - hovered = self.get_hovered_node(mousex, self.h - mousey) - if hovered: - if self.currently_selected and self.currently_selected == hovered: - self.select_node(None) - else: - logger.info("Node %s selected" % hovered) - self.select_node(hovered) - else: - self.is_rotating = True - if evt.type == pygame.MOUSEBUTTONUP and evt.button == LEFT_BUTTON: - self.is_rotating = False - - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button == MIDDLE_BUTTON: - self.is_panning = True - if evt.type == pygame.MOUSEBUTTONUP and evt.button == MIDDLE_BUTTON: - self.is_panning = False - - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button == RIGHT_BUTTON: - self.is_zooming = True - if evt.type == pygame.MOUSEBUTTONUP and evt.button == RIGHT_BUTTON: - self.is_zooming = False - - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button in [WHEEL_UP, WHEEL_DOWN]: - zooming_one_shot = True - self.is_zooming = True - dy = -10 if evt.button == WHEEL_UP else 10 - - if evt.type == pygame.KEYDOWN: - ok = (ok and self.process_keystroke(evt.key, evt.mod)) - - self.controls_3d(dx, dy, zooming_one_shot) - - return ok - - def process_keystroke(self, key, mod): - - # process arrow keys if an object is selected - if self.currently_selected: - up = 0 - strafe = 0 - - if key == pygame.K_UP: - up = 1 - if key == pygame.K_DOWN: - up = -1 - if key == pygame.K_LEFT: - strafe = -1 - if key == pygame.K_RIGHT: - strafe = 1 - - self.move_selected_node(up, strafe) - - if key == pygame.K_f: - pygame.display.toggle_fullscreen() - - if key == pygame.K_TAB: - self.cycle_cameras() - - if key in [pygame.K_ESCAPE, pygame.K_q]: - return False - - return True - - def controls_3d(self, dx, dy, zooming_one_shot=False): - - CAMERA_TRANSLATION_FACTOR = 0.01 - CAMERA_ROTATION_FACTOR = 0.01 - - if not (self.is_rotating or self.is_panning or self.is_zooming): - return - - current_pos = self.current_cam.transformation[:3, 3].copy() - distance = numpy.linalg.norm(self.focal_point - current_pos) - - if self.is_rotating: - """ Orbiting the camera is implemented the following way: - - - the rotation is split into a rotation around the *world* Z axis - (controlled by the horizontal mouse motion along X) and a - rotation around the *X* axis of the camera (pitch) *shifted to - the focal origin* (the world origin for now). This is controlled - by the vertical motion of the mouse (Y axis). - - - as a result, the resulting transformation of the camera in the - world frame C' is: - C' = (T · Rx · T⁻¹ · (Rz · C)⁻¹)⁻¹ - - where: - - C is the original camera transformation in the world frame, - - Rz is the rotation along the Z axis (in the world frame) - - T is the translation camera -> world (ie, the inverse of the - translation part of C - - Rx is the rotation around X in the (translated) camera frame - """ - - rotation_camera_x = dy * CAMERA_ROTATION_FACTOR - rotation_world_z = dx * CAMERA_ROTATION_FACTOR - world_z_rotation = transformations.euler_matrix(0, 0, rotation_world_z) - cam_x_rotation = transformations.euler_matrix(rotation_camera_x, 0, 0) - - after_world_z_rotation = numpy.dot(world_z_rotation, self.current_cam.transformation) - - inverse_transformation = transformations.inverse_matrix(after_world_z_rotation) - - translation = transformations.translation_matrix( - transformations.decompose_matrix(inverse_transformation)[3]) - inverse_translation = transformations.inverse_matrix(translation) - - new_inverse = numpy.dot(inverse_translation, inverse_transformation) - new_inverse = numpy.dot(cam_x_rotation, new_inverse) - new_inverse = numpy.dot(translation, new_inverse) - - self.current_cam.transformation = transformations.inverse_matrix(new_inverse).astype(numpy.float32) - - if self.is_panning: - tx = -dx * CAMERA_TRANSLATION_FACTOR * distance - ty = dy * CAMERA_TRANSLATION_FACTOR * distance - cam_transform = transformations.translation_matrix((tx, ty, 0)).astype(numpy.float32) - self.current_cam.transformation = numpy.dot(self.current_cam.transformation, cam_transform) - - if self.is_zooming: - tz = dy * CAMERA_TRANSLATION_FACTOR * distance - cam_transform = transformations.translation_matrix((0, 0, tz)).astype(numpy.float32) - self.current_cam.transformation = numpy.dot(self.current_cam.transformation, cam_transform) - - if zooming_one_shot: - self.is_zooming = False - - self.update_view_camera() - - def update_view_camera(self): - - self.view_matrix = linalg.inv(self.current_cam.transformation) - - # Rotate by 180deg around X to have Z pointing backward (OpenGL convention) - self.view_matrix = numpy.dot(ROTATION_180_X, self.view_matrix) - - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - glMultMatrixf(self.view_matrix.transpose()) - - def move_selected_node(self, up, strafe): - self.currently_selected.transformation[0][3] += strafe - self.currently_selected.transformation[2][3] += up - - @staticmethod - def showtext(text, x=0, y=0, z=0, size=20): - - # TODO: alpha blending does not work... - # glEnable(GL_BLEND) - # glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) - - font = pygame.font.Font(None, size) - text_surface = font.render(text, True, (10, 10, 10, 255), - (255 * 0.18, 255 * 0.18, 255 * 0.18, 0)) - text_data = pygame.image.tostring(text_surface, "RGBA", True) - glRasterPos3d(x, y, z) - glDrawPixels(text_surface.get_width(), - text_surface.get_height(), - GL_RGBA, GL_UNSIGNED_BYTE, - text_data) - - # glDisable(GL_BLEND) - - -def main(model, width, height): - app = PyAssimp3DViewer(model, w=width, h=height) - - clock = pygame.time.Clock() - - while app.loop(): - - app.update_view_camera() - - ## Main rendering - app.render() - - ## GUI text display - app.switch_to_overlay() - app.showtext("Active camera: %s" % str(app.current_cam), 10, app.h - 30) - if app.currently_selected: - app.showtext("Selected node: %s" % app.currently_selected, 10, app.h - 50) - pos = app.h - 70 - - app.showtext("(%sm, %sm, %sm)" % (app.currently_selected.transformation[0, 3], - app.currently_selected.transformation[1, 3], - app.currently_selected.transformation[2, 3]), 30, pos) - - app.switch_from_overlay() - - # Make sure we do not go over 30fps - clock.tick(30) - - logger.info("Quitting! Bye bye!") - - -######################################################################### -######################################################################### - -if __name__ == '__main__': - if not len(sys.argv) > 1: - print("Usage: " + __file__ + " ") - sys.exit(2) - - main(model=sys.argv[1], width=1024, height=768) diff --git a/libs/assimp/port/PyAssimp/scripts/3d_viewer_py3.py b/libs/assimp/port/PyAssimp/scripts/3d_viewer_py3.py deleted file mode 100755 index fcee637..0000000 --- a/libs/assimp/port/PyAssimp/scripts/3d_viewer_py3.py +++ /dev/null @@ -1,1316 +0,0 @@ -#!/usr/bin/env python -# -*- coding: UTF-8 -*- - -""" This program loads a model with PyASSIMP, and display it. - -Based on: -- pygame code from http://3dengine.org/Spectator_%28PyOpenGL%29 -- http://www.lighthouse3d.com/tutorials -- http://www.songho.ca/opengl/gl_transform.html -- http://code.activestate.com/recipes/325391/ -- ASSIMP's C++ SimpleOpenGL viewer - -Authors: Séverin Lemaignan, 2012-2016 -""" -import sys -import logging - -from functools import reduce - -logger = logging.getLogger("pyassimp") -gllogger = logging.getLogger("OpenGL") -gllogger.setLevel(logging.WARNING) -logging.basicConfig(level=logging.INFO) - -import OpenGL - -OpenGL.ERROR_CHECKING = False -OpenGL.ERROR_LOGGING = False -# OpenGL.ERROR_ON_COPY = True -# OpenGL.FULL_LOGGING = True -from OpenGL.GL import * -from OpenGL.arrays import vbo -from OpenGL.GL import shaders - -import pygame -import pygame.font -import pygame.image - -import math, random -from numpy import linalg - -import pyassimp -from pyassimp.postprocess import * -from pyassimp.helper import * -import transformations - -ROTATION_180_X = numpy.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]], dtype=numpy.float32) - -# rendering mode -BASE = "BASE" -COLORS = "COLORS" -SILHOUETTE = "SILHOUETTE" -HELPERS = "HELPERS" - -# Entities type -ENTITY = "entity" -CAMERA = "camera" -MESH = "mesh" - -FLAT_VERTEX_SHADER_120 = """ -#version 120 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; - -uniform vec4 u_materialDiffuse; - -attribute vec3 a_vertex; - -varying vec4 v_color; - -void main(void) -{ - v_color = u_materialDiffuse; - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -FLAT_VERTEX_SHADER_130 = """ -#version 130 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; - -uniform vec4 u_materialDiffuse; - -in vec3 a_vertex; - -out vec4 v_color; - -void main(void) -{ - v_color = u_materialDiffuse; - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -BASIC_VERTEX_SHADER_120 = """ -#version 120 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; - -uniform vec4 u_materialDiffuse; - -attribute vec3 a_vertex; -attribute vec3 a_normal; - -varying vec4 v_color; - -void main(void) -{ - // Now the normal is in world space, as we pass the light in world space. - vec3 normal = u_normalMatrix * a_normal; - - float dist = distance(a_vertex, u_lightPos); - - // go to https://www.desmos.com/calculator/nmnaud1hrw to play with the parameters - // att is not used for now - float att=1.0/(1.0+0.8*dist*dist); - - vec3 surf2light = normalize(u_lightPos - a_vertex); - vec3 norm = normalize(normal); - float dcont=max(0.0,dot(norm,surf2light)); - - float ambient = 0.3; - float intensity = dcont + 0.3 + ambient; - - v_color = u_materialDiffuse * intensity; - - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -BASIC_VERTEX_SHADER_130 = """ -#version 130 - -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; - -uniform vec4 u_materialDiffuse; - -in vec3 a_vertex; -in vec3 a_normal; - -out vec4 v_color; - -void main(void) -{ - // Now the normal is in world space, as we pass the light in world space. - vec3 normal = u_normalMatrix * a_normal; - - float dist = distance(a_vertex, u_lightPos); - - // go to https://www.desmos.com/calculator/nmnaud1hrw to play with the parameters - // att is not used for now - float att=1.0/(1.0+0.8*dist*dist); - - vec3 surf2light = normalize(u_lightPos - a_vertex); - vec3 norm = normalize(normal); - float dcont=max(0.0,dot(norm,surf2light)); - - float ambient = 0.3; - float intensity = dcont + 0.3 + ambient; - - v_color = u_materialDiffuse * intensity; - - gl_Position = u_viewProjectionMatrix * u_modelMatrix * vec4(a_vertex, 1.0); -} -""" - -BASIC_FRAGMENT_SHADER_120 = """ -#version 120 - -varying vec4 v_color; - -void main() { - gl_FragColor = v_color; -} -""" - -BASIC_FRAGMENT_SHADER_130 = """ -#version 130 - -in vec4 v_color; - -void main() { - gl_FragColor = v_color; -} -""" - -GOOCH_VERTEX_SHADER_120 = """ -#version 120 - -// attributes -attribute vec3 a_vertex; // xyz - position -attribute vec3 a_normal; // xyz - normal - -// uniforms -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; -uniform vec3 u_camPos; - -// output data from vertex to fragment shader -varying vec3 o_normal; -varying vec3 o_lightVector; - -/////////////////////////////////////////////////////////////////// - -void main(void) -{ - // transform position and normal to world space - vec4 positionWorld = u_modelMatrix * vec4(a_vertex, 1.0); - vec3 normalWorld = u_normalMatrix * a_normal; - - // calculate and pass vectors required for lighting - o_lightVector = u_lightPos - positionWorld.xyz; - o_normal = normalWorld; - - // project world space position to the screen and output it - gl_Position = u_viewProjectionMatrix * positionWorld; -} -""" - -GOOCH_VERTEX_SHADER_130 = """ -#version 130 - -// attributes -in vec3 a_vertex; // xyz - position -in vec3 a_normal; // xyz - normal - -// uniforms -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat3 u_normalMatrix; -uniform vec3 u_lightPos; -uniform vec3 u_camPos; - -// output data from vertex to fragment shader -out vec3 o_normal; -out vec3 o_lightVector; - -/////////////////////////////////////////////////////////////////// - -void main(void) -{ - // transform position and normal to world space - vec4 positionWorld = u_modelMatrix * vec4(a_vertex, 1.0); - vec3 normalWorld = u_normalMatrix * a_normal; - - // calculate and pass vectors required for lighting - o_lightVector = u_lightPos - positionWorld.xyz; - o_normal = normalWorld; - - // project world space position to the screen and output it - gl_Position = u_viewProjectionMatrix * positionWorld; -} -""" - -GOOCH_FRAGMENT_SHADER_120 = """ -#version 120 - -// data from vertex shader -varying vec3 o_normal; -varying vec3 o_lightVector; - -// diffuse color of the object -uniform vec4 u_materialDiffuse; -// cool color of gooch shading -uniform vec3 u_coolColor; -// warm color of gooch shading -uniform vec3 u_warmColor; -// how much to take from object color in final cool color -uniform float u_alpha; -// how much to take from object color in final warm color -uniform float u_beta; - -/////////////////////////////////////////////////////////// - -void main(void) -{ - // normlize vectors for lighting - vec3 normalVector = normalize(o_normal); - vec3 lightVector = normalize(o_lightVector); - // intensity of diffuse lighting [-1, 1] - float diffuseLighting = dot(lightVector, normalVector); - // map intensity of lighting from range [-1; 1] to [0, 1] - float interpolationValue = (1.0 + diffuseLighting)/2; - - ////////////////////////////////////////////////////////////////// - - // cool color mixed with color of the object - vec3 coolColorMod = u_coolColor + vec3(u_materialDiffuse) * u_alpha; - // warm color mixed with color of the object - vec3 warmColorMod = u_warmColor + vec3(u_materialDiffuse) * u_beta; - // interpolation of cool and warm colors according - // to lighting intensity. The lower the light intensity, - // the larger part of the cool color is used - vec3 colorOut = mix(coolColorMod, warmColorMod, interpolationValue); - - ////////////////////////////////////////////////////////////////// - - // save color - gl_FragColor.rgb = colorOut; - gl_FragColor.a = 1; -} -""" - -GOOCH_FRAGMENT_SHADER_130 = """ -#version 130 - -// data from vertex shader -in vec3 o_normal; -in vec3 o_lightVector; - -// diffuse color of the object -uniform vec4 u_materialDiffuse; -// cool color of gooch shading -uniform vec3 u_coolColor; -// warm color of gooch shading -uniform vec3 u_warmColor; -// how much to take from object color in final cool color -uniform float u_alpha; -// how much to take from object color in final warm color -uniform float u_beta; - -// output to framebuffer -out vec4 resultingColor; - -/////////////////////////////////////////////////////////// - -void main(void) -{ - // normlize vectors for lighting - vec3 normalVector = normalize(o_normal); - vec3 lightVector = normalize(o_lightVector); - // intensity of diffuse lighting [-1, 1] - float diffuseLighting = dot(lightVector, normalVector); - // map intensity of lighting from range [-1; 1] to [0, 1] - float interpolationValue = (1.0 + diffuseLighting)/2; - - ////////////////////////////////////////////////////////////////// - - // cool color mixed with color of the object - vec3 coolColorMod = u_coolColor + vec3(u_materialDiffuse) * u_alpha; - // warm color mixed with color of the object - vec3 warmColorMod = u_warmColor + vec3(u_materialDiffuse) * u_beta; - // interpolation of cool and warm colors according - // to lighting intensity. The lower the light intensity, - // the larger part of the cool color is used - vec3 colorOut = mix(coolColorMod, warmColorMod, interpolationValue); - - ////////////////////////////////////////////////////////////////// - - // save color - resultingColor.rgb = colorOut; - resultingColor.a = 1; -} -""" - -SILHOUETTE_VERTEX_SHADER_120 = """ -#version 120 - -attribute vec3 a_vertex; // xyz - position -attribute vec3 a_normal; // xyz - normal - -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelViewMatrix; -uniform vec4 u_materialDiffuse; -uniform float u_bordersize; // width of the border - -varying vec4 v_color; - -void main(void){ - v_color = u_materialDiffuse; - float distToCamera = -(u_modelViewMatrix * vec4(a_vertex, 1.0)).z; - vec4 tPos = vec4(a_vertex + a_normal * u_bordersize * distToCamera, 1.0); - gl_Position = u_viewProjectionMatrix * u_modelMatrix * tPos; -} -""" - -SILHOUETTE_VERTEX_SHADER_130 = """ -#version 130 - -in vec3 a_vertex; // xyz - position -in vec3 a_normal; // xyz - normal - -uniform mat4 u_modelMatrix; -uniform mat4 u_viewProjectionMatrix; -uniform mat4 u_modelViewMatrix; -uniform vec4 u_materialDiffuse; -uniform float u_bordersize; // width of the border - -out vec4 v_color; - -void main(void){ - v_color = u_materialDiffuse; - float distToCamera = -(u_modelViewMatrix * vec4(a_vertex, 1.0)).z; - vec4 tPos = vec4(a_vertex + a_normal * u_bordersize * distToCamera, 1.0); - gl_Position = u_viewProjectionMatrix * u_modelMatrix * tPos; -} -""" -DEFAULT_CLIP_PLANE_NEAR = 0.001 -DEFAULT_CLIP_PLANE_FAR = 1000.0 - - -def get_world_transform(scene, node): - if node == scene.rootnode: - return numpy.identity(4, dtype=numpy.float32) - - parents = reversed(_get_parent_chain(scene, node, [])) - parent_transform = reduce(numpy.dot, [p.transformation for p in parents]) - return numpy.dot(parent_transform, node.transformation) - - -def _get_parent_chain(scene, node, parents): - parent = node.parent - - parents.append(parent) - - if parent == scene.rootnode: - return parents - - return _get_parent_chain(scene, parent, parents) - - -class DefaultCamera: - def __init__(self, w, h, fov): - self.name = "default camera" - self.type = CAMERA - self.clipplanenear = DEFAULT_CLIP_PLANE_NEAR - self.clipplanefar = DEFAULT_CLIP_PLANE_FAR - self.aspect = w / h - self.horizontalfov = fov * math.pi / 180 - self.transformation = numpy.array([[0.68, -0.32, 0.65, 7.48], - [0.73, 0.31, -0.61, -6.51], - [-0.01, 0.89, 0.44, 5.34], - [0., 0., 0., 1.]], dtype=numpy.float32) - - self.transformation = numpy.dot(self.transformation, ROTATION_180_X) - - def __str__(self): - return self.name - - -class PyAssimp3DViewer: - base_name = "PyASSIMP 3D viewer" - - def __init__(self, model, w=1024, h=768): - - self.w = w - self.h = h - - pygame.init() - pygame.display.set_caption(self.base_name) - pygame.display.set_mode((w, h), pygame.OPENGL | pygame.DOUBLEBUF) - - glClearColor(0.18, 0.18, 0.18, 1.0) - - shader_compilation_succeeded = False - try: - self.set_shaders_v130() - self.prepare_shaders() - except RuntimeError as message: - sys.stderr.write("%s\n" % message) - sys.stdout.write("Could not compile shaders in version 1.30, trying version 1.20\n") - - if not shader_compilation_succeeded: - self.set_shaders_v120() - self.prepare_shaders() - - self.scene = None - self.meshes = {} # stores the OpenGL vertex/faces/normals buffers pointers - - self.node2colorid = {} # stores a color ID for each node. Useful for mouse picking and visibility checking - self.colorid2node = {} # reverse dict of node2colorid - - self.currently_selected = None - self.moving = False - self.moving_situation = None - - self.default_camera = DefaultCamera(self.w, self.h, fov=70) - self.cameras = [self.default_camera] - - self.current_cam_index = 0 - self.current_cam = self.default_camera - self.set_camera_projection() - - self.load_model(model) - - # user interactions - self.focal_point = [0, 0, 0] - self.is_rotating = False - self.is_panning = False - self.is_zooming = False - - def set_shaders_v120(self): - self.BASIC_VERTEX_SHADER = BASIC_VERTEX_SHADER_120 - self.FLAT_VERTEX_SHADER = FLAT_VERTEX_SHADER_120 - self.SILHOUETTE_VERTEX_SHADER = SILHOUETTE_VERTEX_SHADER_120 - self.GOOCH_VERTEX_SHADER = GOOCH_VERTEX_SHADER_120 - - self.BASIC_FRAGMENT_SHADER = BASIC_FRAGMENT_SHADER_120 - self.GOOCH_FRAGMENT_SHADER = GOOCH_FRAGMENT_SHADER_120 - - def set_shaders_v130(self): - self.BASIC_VERTEX_SHADER = BASIC_VERTEX_SHADER_130 - self.FLAT_VERTEX_SHADER = FLAT_VERTEX_SHADER_130 - self.SILHOUETTE_VERTEX_SHADER = SILHOUETTE_VERTEX_SHADER_130 - self.GOOCH_VERTEX_SHADER = GOOCH_VERTEX_SHADER_130 - - self.BASIC_FRAGMENT_SHADER = BASIC_FRAGMENT_SHADER_130 - self.GOOCH_FRAGMENT_SHADER = GOOCH_FRAGMENT_SHADER_130 - - def prepare_shaders(self): - - ### Base shader - vertex = shaders.compileShader(self.BASIC_VERTEX_SHADER, GL_VERTEX_SHADER) - fragment = shaders.compileShader(self.BASIC_FRAGMENT_SHADER, GL_FRAGMENT_SHADER) - - self.shader = shaders.compileProgram(vertex, fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_normalMatrix', - 'u_lightPos', - 'u_materialDiffuse'), - ('a_vertex', - 'a_normal'), self.shader) - - ### Flat shader - flatvertex = shaders.compileShader(self.FLAT_VERTEX_SHADER, GL_VERTEX_SHADER) - self.flatshader = shaders.compileProgram(flatvertex, fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_materialDiffuse',), - ('a_vertex',), self.flatshader) - - ### Silhouette shader - silh_vertex = shaders.compileShader(self.SILHOUETTE_VERTEX_SHADER, GL_VERTEX_SHADER) - self.silhouette_shader = shaders.compileProgram(silh_vertex, fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_modelViewMatrix', - 'u_materialDiffuse', - 'u_bordersize' # width of the silhouette - ), - ('a_vertex', - 'a_normal'), self.silhouette_shader) - - ### Gooch shader - gooch_vertex = shaders.compileShader(self.GOOCH_VERTEX_SHADER, GL_VERTEX_SHADER) - gooch_fragment = shaders.compileShader(self.GOOCH_FRAGMENT_SHADER, GL_FRAGMENT_SHADER) - self.gooch_shader = shaders.compileProgram(gooch_vertex, gooch_fragment) - - self.set_shader_accessors(('u_modelMatrix', - 'u_viewProjectionMatrix', - 'u_normalMatrix', - 'u_lightPos', - 'u_materialDiffuse', - 'u_coolColor', - 'u_warmColor', - 'u_alpha', - 'u_beta' - ), - ('a_vertex', - 'a_normal'), self.gooch_shader) - - @staticmethod - def set_shader_accessors(uniforms, attributes, shader): - # add accessors to the shaders uniforms and attributes - for uniform in uniforms: - location = glGetUniformLocation(shader, uniform) - if location in (None, -1): - raise RuntimeError('No uniform: %s (maybe it is not used ' - 'anymore and has been optimized out by' - ' the shader compiler)' % uniform) - setattr(shader, uniform, location) - - for attribute in attributes: - location = glGetAttribLocation(shader, attribute) - if location in (None, -1): - raise RuntimeError('No attribute: %s' % attribute) - setattr(shader, attribute, location) - - @staticmethod - def prepare_gl_buffers(mesh): - - mesh.gl = {} - - # Fill the buffer for vertex and normals positions - v = numpy.array(mesh.vertices, 'f') - n = numpy.array(mesh.normals, 'f') - - mesh.gl["vbo"] = vbo.VBO(numpy.hstack((v, n))) - - # Fill the buffer for vertex positions - mesh.gl["faces"] = glGenBuffers(1) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) - glBufferData(GL_ELEMENT_ARRAY_BUFFER, - numpy.array(mesh.faces, dtype=numpy.int32), - GL_STATIC_DRAW) - - mesh.gl["nbfaces"] = len(mesh.faces) - - # Unbind buffers - glBindBuffer(GL_ARRAY_BUFFER, 0) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) - - @staticmethod - def get_rgb_from_colorid(colorid): - r = (colorid >> 0) & 0xff - g = (colorid >> 8) & 0xff - b = (colorid >> 16) & 0xff - - return r, g, b - - def get_color_id(self): - id = random.randint(0, 256 * 256 * 256) - if id not in self.colorid2node: - return id - else: - return self.get_color_id() - - def glize(self, scene, node): - - logger.info("Loading node <%s>" % node) - node.selected = True if self.currently_selected and self.currently_selected == node else False - - node.transformation = node.transformation.astype(numpy.float32) - - if node.meshes: - node.type = MESH - colorid = self.get_color_id() - self.colorid2node[colorid] = node - self.node2colorid[node.name] = colorid - - elif node.name in [c.name for c in scene.cameras]: - - # retrieve the ASSIMP camera object - [cam] = [c for c in scene.cameras if c.name == node.name] - node.type = CAMERA - logger.info("Added camera <%s>" % node.name) - logger.info("Camera position: %.3f, %.3f, %.3f" % tuple(node.transformation[:, 3][:3].tolist())) - self.cameras.append(node) - node.clipplanenear = cam.clipplanenear - node.clipplanefar = cam.clipplanefar - - if numpy.allclose(cam.lookat, [0, 0, -1]) and numpy.allclose(cam.up, [0, 1, 0]): # Cameras in .blend files - - # Rotate by 180deg around X to have Z pointing forward - node.transformation = numpy.dot(node.transformation, ROTATION_180_X) - else: - raise RuntimeError( - "I do not know how to normalize this camera orientation: lookat=%s, up=%s" % (cam.lookat, cam.up)) - - if cam.aspect == 0.0: - logger.warning("Camera aspect not set. Setting to default 4:3") - node.aspect = 1.333 - else: - node.aspect = cam.aspect - - node.horizontalfov = cam.horizontalfov - - else: - node.type = ENTITY - - for child in node.children: - self.glize(scene, child) - - def load_model(self, path, postprocess=aiProcessPreset_TargetRealtime_MaxQuality): - logger.info("Loading model:" + path + "...") - - if postprocess: - self.scene = pyassimp.load(path, processing=postprocess) - else: - self.scene = pyassimp.load(path) - logger.info("Done.") - - scene = self.scene - # log some statistics - logger.info(" meshes: %d" % len(scene.meshes)) - logger.info(" total faces: %d" % sum([len(mesh.faces) for mesh in scene.meshes])) - logger.info(" materials: %d" % len(scene.materials)) - self.bb_min, self.bb_max = get_bounding_box(self.scene) - logger.info(" bounding box:" + str(self.bb_min) + " - " + str(self.bb_max)) - - self.scene_center = [(a + b) / 2. for a, b in zip(self.bb_min, self.bb_max)] - - for index, mesh in enumerate(scene.meshes): - self.prepare_gl_buffers(mesh) - - self.glize(scene, scene.rootnode) - - # Finally release the model - pyassimp.release(scene) - logger.info("Ready for 3D rendering!") - - def cycle_cameras(self): - - self.current_cam_index = (self.current_cam_index + 1) % len(self.cameras) - self.current_cam = self.cameras[self.current_cam_index] - self.set_camera_projection(self.current_cam) - logger.info("Switched to camera <%s>" % self.current_cam) - - def set_overlay_projection(self): - glViewport(0, 0, self.w, self.h) - glMatrixMode(GL_PROJECTION) - glLoadIdentity() - glOrtho(0.0, self.w - 1.0, 0.0, self.h - 1.0, -1.0, 1.0) - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - - def set_camera_projection(self, camera=None): - - if not camera: - camera = self.current_cam - - znear = camera.clipplanenear or DEFAULT_CLIP_PLANE_NEAR - zfar = camera.clipplanefar or DEFAULT_CLIP_PLANE_FAR - aspect = camera.aspect - fov = camera.horizontalfov - - glMatrixMode(GL_PROJECTION) - glLoadIdentity() - - # Compute gl frustrum - tangent = math.tan(fov / 2.) - h = znear * tangent - w = h * aspect - - # params: left, right, bottom, top, near, far - glFrustum(-w, w, -h, h, znear, zfar) - # equivalent to: - # gluPerspective(fov * 180/math.pi, aspect, znear, zfar) - - self.projection_matrix = glGetFloatv(GL_PROJECTION_MATRIX).transpose() - - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - - def render_colors(self): - - glEnable(GL_DEPTH_TEST) - glDepthFunc(GL_LEQUAL) - - glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) - glEnable(GL_CULL_FACE) - - glUseProgram(self.flatshader) - - glUniformMatrix4fv(self.flatshader.u_viewProjectionMatrix, 1, GL_TRUE, - numpy.dot(self.projection_matrix, self.view_matrix)) - - self.recursive_render(self.scene.rootnode, self.flatshader, mode=COLORS) - - glUseProgram(0) - - def get_hovered_node(self, mousex, mousey): - """ - Attention: The performances of this method relies heavily on the size of the display! - """ - - # mouse out of the window? - if mousex < 0 or mousex >= self.w or mousey < 0 or mousey >= self.h: - return None - - self.render_colors() - # Capture image from the OpenGL buffer - buf = (GLubyte * (3 * self.w * self.h))(0) - glReadPixels(0, 0, self.w, self.h, GL_RGB, GL_UNSIGNED_BYTE, buf) - - # Reinterpret the RGB pixel buffer as a 1-D array of 24bits colors - a = numpy.ndarray(len(buf), numpy.dtype('>u1'), buf) - colors = numpy.zeros(len(buf) // 3, numpy.dtype('u1')[i::3] - - colorid = colors[mousex + mousey * self.w] - - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) - - if colorid in self.colorid2node: - return self.colorid2node[colorid] - - def render(self, wireframe=False, twosided=False): - - glEnable(GL_DEPTH_TEST) - glDepthFunc(GL_LEQUAL) - - glPolygonMode(GL_FRONT_AND_BACK, GL_LINE if wireframe else GL_FILL) - glDisable(GL_CULL_FACE) if twosided else glEnable(GL_CULL_FACE) - - self.render_grid() - - self.recursive_render(self.scene.rootnode, None, mode=HELPERS) - - ### First, the silhouette - - if False: - shader = self.silhouette_shader - - # glDepthMask(GL_FALSE) - glCullFace(GL_FRONT) # cull front faces - - glUseProgram(shader) - glUniform1f(shader.u_bordersize, 0.01) - - glUniformMatrix4fv(shader.u_viewProjectionMatrix, 1, GL_TRUE, - numpy.dot(self.projection_matrix, self.view_matrix)) - - self.recursive_render(self.scene.rootnode, shader, mode=SILHOUETTE) - - glUseProgram(0) - - ### Then, inner shading - # glDepthMask(GL_TRUE) - glCullFace(GL_BACK) - - use_gooch = False - if use_gooch: - shader = self.gooch_shader - - glUseProgram(shader) - glUniform3f(shader.u_lightPos, -.5, -.5, .5) - - ##### GOOCH specific - glUniform3f(shader.u_coolColor, 159.0 / 255, 148.0 / 255, 255.0 / 255) - glUniform3f(shader.u_warmColor, 255.0 / 255, 75.0 / 255, 75.0 / 255) - glUniform1f(shader.u_alpha, .25) - glUniform1f(shader.u_beta, .25) - ######### - else: - shader = self.shader - glUseProgram(shader) - glUniform3f(shader.u_lightPos, -.5, -.5, .5) - - glUniformMatrix4fv(shader.u_viewProjectionMatrix, 1, GL_TRUE, - numpy.dot(self.projection_matrix, self.view_matrix)) - - self.recursive_render(self.scene.rootnode, shader) - - glUseProgram(0) - - def render_axis(self, - transformation=numpy.identity(4, dtype=numpy.float32), - label=None, - size=0.2, - selected=False): - m = transformation.transpose() # OpenGL row major - - glPushMatrix() - glMultMatrixf(m) - - glLineWidth(3 if selected else 1) - - size = 2 * size if selected else size - - glBegin(GL_LINES) - - # draw line for x axis - glColor3f(1.0, 0.0, 0.0) - glVertex3f(0.0, 0.0, 0.0) - glVertex3f(size, 0.0, 0.0) - - # draw line for y axis - glColor3f(0.0, 1.0, 0.0) - glVertex3f(0.0, 0.0, 0.0) - glVertex3f(0.0, size, 0.0) - - # draw line for Z axis - glColor3f(0.0, 0.0, 1.0) - glVertex3f(0.0, 0.0, 0.0) - glVertex3f(0.0, 0.0, size) - - glEnd() - - if label: - self.showtext(label) - - glPopMatrix() - - @staticmethod - def render_camera(camera, transformation): - - m = transformation.transpose() # OpenGL row major - - aspect = camera.aspect - - u = 0.1 # unit size (in m) - l = 3 * u # length of the camera cone - f = 3 * u # aperture of the camera cone - - glPushMatrix() - glMultMatrixf(m) - - glLineWidth(2) - glBegin(GL_LINE_STRIP) - - glColor3f(.2, .2, .2) - - glVertex3f(u, u, -u) - glVertex3f(u, -u, -u) - glVertex3f(-u, -u, -u) - glVertex3f(-u, u, -u) - glVertex3f(u, u, -u) - - glVertex3f(u, u, 0.0) - glVertex3f(u, -u, 0.0) - glVertex3f(-u, -u, 0.0) - glVertex3f(-u, u, 0.0) - glVertex3f(u, u, 0.0) - - glVertex3f(f * aspect, f, l) - glVertex3f(f * aspect, -f, l) - glVertex3f(-f * aspect, -f, l) - glVertex3f(-f * aspect, f, l) - glVertex3f(f * aspect, f, l) - - glEnd() - - glBegin(GL_LINE_STRIP) - glVertex3f(u, -u, -u) - glVertex3f(u, -u, 0.0) - glVertex3f(f * aspect, -f, l) - glEnd() - - glBegin(GL_LINE_STRIP) - glVertex3f(-u, -u, -u) - glVertex3f(-u, -u, 0.0) - glVertex3f(-f * aspect, -f, l) - glEnd() - - glBegin(GL_LINE_STRIP) - glVertex3f(-u, u, -u) - glVertex3f(-u, u, 0.0) - glVertex3f(-f * aspect, f, l) - glEnd() - - glPopMatrix() - - @staticmethod - def render_grid(): - - glLineWidth(1) - glColor3f(0.5, 0.5, 0.5) - glBegin(GL_LINES) - for i in range(-10, 11): - glVertex3f(i, -10.0, 0.0) - glVertex3f(i, 10.0, 0.0) - - for i in range(-10, 11): - glVertex3f(-10.0, i, 0.0) - glVertex3f(10.0, i, 0.0) - glEnd() - - def recursive_render(self, node, shader, mode=BASE, with_normals=True): - """ Main recursive rendering method. - """ - - normals = with_normals - - if mode == COLORS: - normals = False - - - if not hasattr(node, "selected"): - node.selected = False - - m = get_world_transform(self.scene, node) - - # HELPERS mode - ### - if mode == HELPERS: - # if node.type == ENTITY: - self.render_axis(m, - label=node.name if node != self.scene.rootnode else None, - selected=node.selected if hasattr(node, "selected") else False) - - if node.type == CAMERA: - self.render_camera(node, m) - - for child in node.children: - self.recursive_render(child, shader, mode) - - return - - # Mesh rendering modes - ### - if node.type == MESH: - - for mesh in node.meshes: - - stride = 24 # 6 * 4 bytes - - if node.selected and mode == SILHOUETTE: - glUniform4f(shader.u_materialDiffuse, 1.0, 0.0, 0.0, 1.0) - glUniformMatrix4fv(shader.u_modelViewMatrix, 1, GL_TRUE, - numpy.dot(self.view_matrix, m)) - - else: - if mode == COLORS: - colorid = self.node2colorid[node.name] - r, g, b = self.get_rgb_from_colorid(colorid) - glUniform4f(shader.u_materialDiffuse, r / 255.0, g / 255.0, b / 255.0, 1.0) - elif mode == SILHOUETTE: - glUniform4f(shader.u_materialDiffuse, .0, .0, .0, 1.0) - else: - if node.selected: - diffuse = (1.0, 0.0, 0.0, 1.0) # selected nodes in red - else: - diffuse = mesh.material.properties["diffuse"] - if len(diffuse) == 3: # RGB instead of expected RGBA - diffuse.append(1.0) - glUniform4f(shader.u_materialDiffuse, *diffuse) - # if ambient: - # glUniform4f( shader.Material_ambient, *mat["ambient"] ) - - if mode == BASE: # not in COLORS or SILHOUETTE - normal_matrix = linalg.inv(numpy.dot(self.view_matrix, m)[0:3, 0:3]).transpose() - glUniformMatrix3fv(shader.u_normalMatrix, 1, GL_TRUE, normal_matrix) - - glUniformMatrix4fv(shader.u_modelMatrix, 1, GL_TRUE, m) - - vbo = mesh.gl["vbo"] - vbo.bind() - - glEnableVertexAttribArray(shader.a_vertex) - if normals: - glEnableVertexAttribArray(shader.a_normal) - - glVertexAttribPointer( - shader.a_vertex, - 3, GL_FLOAT, False, stride, vbo - ) - - if normals: - glVertexAttribPointer( - shader.a_normal, - 3, GL_FLOAT, False, stride, vbo + 12 - ) - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) - glDrawElements(GL_TRIANGLES, mesh.gl["nbfaces"] * 3, GL_UNSIGNED_INT, None) - - vbo.unbind() - glDisableVertexAttribArray(shader.a_vertex) - - if normals: - glDisableVertexAttribArray(shader.a_normal) - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) - - for child in node.children: - self.recursive_render(child, shader, mode) - - - def switch_to_overlay(self): - glPushMatrix() - self.set_overlay_projection() - - def switch_from_overlay(self): - self.set_camera_projection() - glPopMatrix() - - def select_node(self, node): - self.currently_selected = node - self.update_node_select(self.scene.rootnode) - - def update_node_select(self, node): - if node is self.currently_selected: - node.selected = True - else: - node.selected = False - - for child in node.children: - self.update_node_select(child) - - def loop(self): - - pygame.display.flip() - - if not self.process_events(): - return False # ESC has been pressed - - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) - - return True - - def process_events(self): - - LEFT_BUTTON = 1 - MIDDLE_BUTTON = 2 - RIGHT_BUTTON = 3 - WHEEL_UP = 4 - WHEEL_DOWN = 5 - - dx, dy = pygame.mouse.get_rel() - mousex, mousey = pygame.mouse.get_pos() - - zooming_one_shot = False - - ok = True - - for evt in pygame.event.get(): - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button == LEFT_BUTTON: - hovered = self.get_hovered_node(mousex, self.h - mousey) - if hovered: - if self.currently_selected and self.currently_selected == hovered: - self.select_node(None) - else: - logger.info("Node %s selected" % hovered) - self.select_node(hovered) - else: - self.is_rotating = True - if evt.type == pygame.MOUSEBUTTONUP and evt.button == LEFT_BUTTON: - self.is_rotating = False - - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button == MIDDLE_BUTTON: - self.is_panning = True - if evt.type == pygame.MOUSEBUTTONUP and evt.button == MIDDLE_BUTTON: - self.is_panning = False - - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button == RIGHT_BUTTON: - self.is_zooming = True - if evt.type == pygame.MOUSEBUTTONUP and evt.button == RIGHT_BUTTON: - self.is_zooming = False - - if evt.type == pygame.MOUSEBUTTONDOWN and evt.button in [WHEEL_UP, WHEEL_DOWN]: - zooming_one_shot = True - self.is_zooming = True - dy = -10 if evt.button == WHEEL_UP else 10 - - if evt.type == pygame.KEYDOWN: - ok = (ok and self.process_keystroke(evt.key, evt.mod)) - - self.controls_3d(dx, dy, zooming_one_shot) - - return ok - - def process_keystroke(self, key, mod): - - # process arrow keys if an object is selected - if self.currently_selected: - up = 0 - strafe = 0 - - if key == pygame.K_UP: - up = 1 - if key == pygame.K_DOWN: - up = -1 - if key == pygame.K_LEFT: - strafe = -1 - if key == pygame.K_RIGHT: - strafe = 1 - - self.move_selected_node(up, strafe) - - if key == pygame.K_f: - pygame.display.toggle_fullscreen() - - if key == pygame.K_TAB: - self.cycle_cameras() - - if key in [pygame.K_ESCAPE, pygame.K_q]: - return False - - return True - - def controls_3d(self, dx, dy, zooming_one_shot=False): - """ Orbiting the camera is implemented the following way: - - - the rotation is split into a rotation around the *world* Z axis - (controlled by the horizontal mouse motion along X) and a - rotation around the *X* axis of the camera (pitch) *shifted to - the focal origin* (the world origin for now). This is controlled - by the vertical motion of the mouse (Y axis). - - as a result, the resulting transformation of the camera in the - world frame C' is: - C' = (T · Rx · T⁻¹ · (Rz · C)⁻¹)⁻¹ - where: - - C is the original camera transformation in the world frame, - - Rz is the rotation along the Z axis (in the world frame) - - T is the translation camera -> world (ie, the inverse of the - translation part of C - - Rx is the rotation around X in the (translated) camera frame """ - - CAMERA_TRANSLATION_FACTOR = 0.01 - CAMERA_ROTATION_FACTOR = 0.01 - - if not (self.is_rotating or self.is_panning or self.is_zooming): - return - - current_pos = self.current_cam.transformation[:3, 3].copy() - distance = numpy.linalg.norm(self.focal_point - current_pos) - - if self.is_rotating: - rotation_camera_x = dy * CAMERA_ROTATION_FACTOR - rotation_world_z = dx * CAMERA_ROTATION_FACTOR - world_z_rotation = transformations.euler_matrix(0, 0, rotation_world_z) - cam_x_rotation = transformations.euler_matrix(rotation_camera_x, 0, 0) - - after_world_z_rotation = numpy.dot(world_z_rotation, self.current_cam.transformation) - - inverse_transformation = transformations.inverse_matrix(after_world_z_rotation) - - translation = transformations.translation_matrix( - transformations.decompose_matrix(inverse_transformation)[3]) - inverse_translation = transformations.inverse_matrix(translation) - - new_inverse = numpy.dot(inverse_translation, inverse_transformation) - new_inverse = numpy.dot(cam_x_rotation, new_inverse) - new_inverse = numpy.dot(translation, new_inverse) - - self.current_cam.transformation = transformations.inverse_matrix(new_inverse).astype(numpy.float32) - - if self.is_panning: - tx = -dx * CAMERA_TRANSLATION_FACTOR * distance - ty = dy * CAMERA_TRANSLATION_FACTOR * distance - cam_transform = transformations.translation_matrix((tx, ty, 0)).astype(numpy.float32) - self.current_cam.transformation = numpy.dot(self.current_cam.transformation, cam_transform) - - if self.is_zooming: - tz = dy * CAMERA_TRANSLATION_FACTOR * distance - cam_transform = transformations.translation_matrix((0, 0, tz)).astype(numpy.float32) - self.current_cam.transformation = numpy.dot(self.current_cam.transformation, cam_transform) - - if zooming_one_shot: - self.is_zooming = False - - self.update_view_camera() - - def update_view_camera(self): - - self.view_matrix = linalg.inv(self.current_cam.transformation) - - # Rotate by 180deg around X to have Z pointing backward (OpenGL convention) - self.view_matrix = numpy.dot(ROTATION_180_X, self.view_matrix) - - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - glMultMatrixf(self.view_matrix.transpose()) - - def move_selected_node(self, up, strafe): - self.currently_selected.transformation[0][3] += strafe - self.currently_selected.transformation[2][3] += up - - @staticmethod - def showtext(text, x=0, y=0, z=0, size=20): - - # TODO: alpha blending does not work... - # glEnable(GL_BLEND) - # glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) - - font = pygame.font.Font(None, size) - text_surface = font.render(text, True, (10, 10, 10, 255), - (255 * 0.18, 255 * 0.18, 255 * 0.18, 0)) - text_data = pygame.image.tostring(text_surface, "RGBA", True) - glRasterPos3d(x, y, z) - glDrawPixels(text_surface.get_width(), - text_surface.get_height(), - GL_RGBA, GL_UNSIGNED_BYTE, - text_data) - - # glDisable(GL_BLEND) - - -def main(model, width, height): - app = PyAssimp3DViewer(model, w=width, h=height) - - clock = pygame.time.Clock() - - while app.loop(): - - app.update_view_camera() - - ## Main rendering - app.render() - - ## GUI text display - app.switch_to_overlay() - app.showtext("Active camera: %s" % str(app.current_cam), 10, app.h - 30) - if app.currently_selected: - app.showtext("Selected node: %s" % app.currently_selected, 10, app.h - 50) - pos = app.h - 70 - - app.showtext("(%sm, %sm, %sm)" % (app.currently_selected.transformation[0, 3], - app.currently_selected.transformation[1, 3], - app.currently_selected.transformation[2, 3]), 30, pos) - - app.switch_from_overlay() - - # Make sure we do not go over 30fps - clock.tick(30) - - logger.info("Quitting! Bye bye!") - - -######################################################################### -######################################################################### - -if __name__ == '__main__': - if not len(sys.argv) > 1: - print("Usage: " + __file__ + " ") - sys.exit(2) - - main(model=sys.argv[1], width=1024, height=768) diff --git a/libs/assimp/port/PyAssimp/scripts/README.md b/libs/assimp/port/PyAssimp/scripts/README.md deleted file mode 100644 index 42caa27..0000000 --- a/libs/assimp/port/PyAssimp/scripts/README.md +++ /dev/null @@ -1,13 +0,0 @@ -pyassimp examples -================= - -- `sample.py`: shows how to load a model with pyassimp, and display some statistics. -- `3d_viewer.py`: an OpenGL 3D viewer that requires shaders -- `fixed_pipeline_3d_viewer`: an OpenGL 3D viewer using the old fixed-pipeline. - Only for illustration example. Base new projects on `3d_viewer.py`. - - -Requirements for the 3D viewers: - -- `pyopengl` (on Ubuntu/Debian, `sudo apt-get install python-opengl`) -- `pygame` (on Ubuntu/Debian, `sudo apt-get install python-pygame`) diff --git a/libs/assimp/port/PyAssimp/scripts/fixed_pipeline_3d_viewer.py b/libs/assimp/port/PyAssimp/scripts/fixed_pipeline_3d_viewer.py deleted file mode 100755 index c2f6ceb..0000000 --- a/libs/assimp/port/PyAssimp/scripts/fixed_pipeline_3d_viewer.py +++ /dev/null @@ -1,372 +0,0 @@ -#!/usr/bin/env python -#-*- coding: UTF-8 -*- - -""" This program demonstrates the use of pyassimp to load and -render objects with OpenGL. - -'c' cycles between cameras (if any available) -'q' to quit - -This example mixes 'old' OpenGL fixed-function pipeline with -Vertex Buffer Objects. - -Materials are supported but textures are currently ignored. - -For a more advanced example (with shaders + keyboard/mouse -controls), check scripts/sdl_viewer.py - -Author: Séverin Lemaignan, 2012 - -This sample is based on several sources, including: - - http://www.lighthouse3d.com/tutorials - - http://www.songho.ca/opengl/gl_transform.html - - http://code.activestate.com/recipes/325391/ - - ASSIMP's C++ SimpleOpenGL viewer -""" - -import sys -from OpenGL.GLUT import * -from OpenGL.GLU import * -from OpenGL.GL import * - -import logging -logger = logging.getLogger("pyassimp_opengl") -logging.basicConfig(level=logging.INFO) - -import math -import numpy - -import pyassimp -from pyassimp.postprocess import * -from pyassimp.helper import * - - -name = 'pyassimp OpenGL viewer' -height = 600 -width = 900 - -class GLRenderer(): - def __init__(self): - - self.scene = None - - self.using_fixed_cam = False - self.current_cam_index = 0 - - # store the global scene rotation - self.angle = 0. - - # for FPS calculation - self.prev_time = 0 - self.prev_fps_time = 0 - self.frames = 0 - - def prepare_gl_buffers(self, mesh): - """ Creates 3 buffer objets for each mesh, - to store the vertices, the normals, and the faces - indices. - """ - - mesh.gl = {} - - # Fill the buffer for vertex positions - mesh.gl["vertices"] = glGenBuffers(1) - glBindBuffer(GL_ARRAY_BUFFER, mesh.gl["vertices"]) - glBufferData(GL_ARRAY_BUFFER, - mesh.vertices, - GL_STATIC_DRAW) - - # Fill the buffer for normals - mesh.gl["normals"] = glGenBuffers(1) - glBindBuffer(GL_ARRAY_BUFFER, mesh.gl["normals"]) - glBufferData(GL_ARRAY_BUFFER, - mesh.normals, - GL_STATIC_DRAW) - - - # Fill the buffer for vertex positions - mesh.gl["triangles"] = glGenBuffers(1) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["triangles"]) - glBufferData(GL_ELEMENT_ARRAY_BUFFER, - mesh.faces, - GL_STATIC_DRAW) - - # Unbind buffers - glBindBuffer(GL_ARRAY_BUFFER,0) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0) - - def load_model(self, path, postprocess = None): - logger.info("Loading model:" + path + "...") - - if postprocess: - self.scene = pyassimp.load(path, processing=postprocess) - else: - self.scene = pyassimp.load(path) - logger.info("Done.") - - scene = self.scene - #log some statistics - logger.info(" meshes: %d" % len(scene.meshes)) - logger.info(" total faces: %d" % sum([len(mesh.faces) for mesh in scene.meshes])) - logger.info(" materials: %d" % len(scene.materials)) - self.bb_min, self.bb_max = get_bounding_box(self.scene) - logger.info(" bounding box:" + str(self.bb_min) + " - " + str(self.bb_max)) - - self.scene_center = [(a + b) / 2. for a, b in zip(self.bb_min, self.bb_max)] - - for index, mesh in enumerate(scene.meshes): - self.prepare_gl_buffers(mesh) - - # Finally release the model - pyassimp.release(scene) - - def cycle_cameras(self): - self.current_cam_index - if not self.scene.cameras: - return None - self.current_cam_index = (self.current_cam_index + 1) % len(self.scene.cameras) - cam = self.scene.cameras[self.current_cam_index] - logger.info("Switched to camera " + str(cam)) - return cam - - def set_default_camera(self): - - if not self.using_fixed_cam: - glLoadIdentity() - - gluLookAt(0.,0.,3., - 0.,0.,-5., - 0.,1.,0.) - - - - def set_camera(self, camera): - - if not camera: - return - - self.using_fixed_cam = True - - znear = camera.clipplanenear - zfar = camera.clipplanefar - aspect = camera.aspect - fov = camera.horizontalfov - - glMatrixMode(GL_PROJECTION) - glLoadIdentity() - - # Compute gl frustrum - tangent = math.tan(fov/2.) - h = znear * tangent - w = h * aspect - - # params: left, right, bottom, top, near, far - glFrustum(-w, w, -h, h, znear, zfar) - # equivalent to: - #gluPerspective(fov * 180/math.pi, aspect, znear, zfar) - - glMatrixMode(GL_MODELVIEW) - glLoadIdentity() - - cam = transform(camera.position, camera.transformation) - at = transform(camera.lookat, camera.transformation) - gluLookAt(cam[0], cam[2], -cam[1], - at[0], at[2], -at[1], - 0, 1, 0) - - def fit_scene(self, restore = False): - """ Compute a scale factor and a translation to fit and center - the whole geometry on the screen. - """ - - x_max = self.bb_max[0] - self.bb_min[0] - y_max = self.bb_max[1] - self.bb_min[1] - tmp = max(x_max, y_max) - z_max = self.bb_max[2] - self.bb_min[2] - tmp = max(z_max, tmp) - - if not restore: - tmp = 1. / tmp - - logger.info("Scaling the scene by %.03f" % tmp) - glScalef(tmp, tmp, tmp) - - # center the model - direction = -1 if not restore else 1 - glTranslatef( direction * self.scene_center[0], - direction * self.scene_center[1], - direction * self.scene_center[2] ) - - return x_max, y_max, z_max - - def apply_material(self, mat): - """ Apply an OpenGL, using one OpenGL display list per material to cache - the operation. - """ - - if not hasattr(mat, "gl_mat"): # evaluate once the mat properties, and cache the values in a glDisplayList. - diffuse = numpy.array(mat.properties.get("diffuse", [0.8, 0.8, 0.8, 1.0])) - specular = numpy.array(mat.properties.get("specular", [0., 0., 0., 1.0])) - ambient = numpy.array(mat.properties.get("ambient", [0.2, 0.2, 0.2, 1.0])) - emissive = numpy.array(mat.properties.get("emissive", [0., 0., 0., 1.0])) - shininess = min(mat.properties.get("shininess", 1.0), 128) - wireframe = mat.properties.get("wireframe", 0) - twosided = mat.properties.get("twosided", 1) - - setattr(mat, "gl_mat", glGenLists(1)) - glNewList(mat.gl_mat, GL_COMPILE) - - glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse) - glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular) - glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient) - glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emissive) - glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess) - glPolygonMode(GL_FRONT_AND_BACK, GL_LINE if wireframe else GL_FILL) - glDisable(GL_CULL_FACE) if twosided else glEnable(GL_CULL_FACE) - - glEndList() - - glCallList(mat.gl_mat) - - - - def do_motion(self): - - gl_time = glutGet(GLUT_ELAPSED_TIME) - - self.angle = (gl_time - self.prev_time) * 0.1 - - self.prev_time = gl_time - - # Compute FPS - self.frames += 1 - if gl_time - self.prev_fps_time >= 1000: - current_fps = self.frames * 1000 / (gl_time - self.prev_fps_time) - logger.info('%.0f fps' % current_fps) - self.frames = 0 - self.prev_fps_time = gl_time - - glutPostRedisplay() - - def recursive_render(self, node): - """ Main recursive rendering method. - """ - - # save model matrix and apply node transformation - glPushMatrix() - m = node.transformation.transpose() # OpenGL row major - glMultMatrixf(m) - - for mesh in node.meshes: - self.apply_material(mesh.material) - - glBindBuffer(GL_ARRAY_BUFFER, mesh.gl["vertices"]) - glEnableClientState(GL_VERTEX_ARRAY) - glVertexPointer(3, GL_FLOAT, 0, None) - - glBindBuffer(GL_ARRAY_BUFFER, mesh.gl["normals"]) - glEnableClientState(GL_NORMAL_ARRAY) - glNormalPointer(GL_FLOAT, 0, None) - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["triangles"]) - glDrawElements(GL_TRIANGLES,len(mesh.faces) * 3, GL_UNSIGNED_INT, None) - - glDisableClientState(GL_VERTEX_ARRAY) - glDisableClientState(GL_NORMAL_ARRAY) - - glBindBuffer(GL_ARRAY_BUFFER, 0) - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) - - for child in node.children: - self.recursive_render(child) - - glPopMatrix() - - - def display(self): - """ GLUT callback to redraw OpenGL surface - """ - glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) - - glRotatef(self.angle,0.,1.,0.) - self.recursive_render(self.scene.rootnode) - - glutSwapBuffers() - self.do_motion() - return - - #################################################################### - ## GLUT keyboard and mouse callbacks ## - #################################################################### - def onkeypress(self, key, x, y): - if key == 'c': - self.fit_scene(restore = True) - self.set_camera(self.cycle_cameras()) - if key == 'q': - sys.exit(0) - - def render(self, filename=None, fullscreen = False, autofit = True, postprocess = None): - """ - - :param autofit: if true, scale the scene to fit the whole geometry - in the viewport. - """ - - # First initialize the openGL context - glutInit(sys.argv) - glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH) - if not fullscreen: - glutInitWindowSize(width, height) - glutCreateWindow(name) - else: - glutGameModeString("1024x768") - if glutGameModeGet(GLUT_GAME_MODE_POSSIBLE): - glutEnterGameMode() - else: - print("Fullscreen mode not available!") - sys.exit(1) - - self.load_model(filename, postprocess = postprocess) - - - glClearColor(0.1,0.1,0.1,1.) - #glShadeModel(GL_SMOOTH) - - glEnable(GL_LIGHTING) - - glEnable(GL_CULL_FACE) - glEnable(GL_DEPTH_TEST) - - glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE) - glEnable(GL_NORMALIZE) - glEnable(GL_LIGHT0) - - glutDisplayFunc(self.display) - - - glMatrixMode(GL_PROJECTION) - glLoadIdentity() - gluPerspective(35.0, width/float(height) , 0.10, 100.0) - glMatrixMode(GL_MODELVIEW) - self.set_default_camera() - - if autofit: - # scale the whole asset to fit into our view frustum· - self.fit_scene() - - glPushMatrix() - - glutKeyboardFunc(self.onkeypress) - glutIgnoreKeyRepeat(1) - - glutMainLoop() - - -if __name__ == '__main__': - if not len(sys.argv) > 1: - print("Usage: " + __file__ + " ") - sys.exit(0) - - glrender = GLRenderer() - glrender.render(sys.argv[1], fullscreen = False, postprocess = aiProcessPreset_TargetRealtime_MaxQuality) - diff --git a/libs/assimp/port/PyAssimp/scripts/quicktest.py b/libs/assimp/port/PyAssimp/scripts/quicktest.py deleted file mode 100755 index cbeccb4..0000000 --- a/libs/assimp/port/PyAssimp/scripts/quicktest.py +++ /dev/null @@ -1,53 +0,0 @@ -#!/usr/bin/env python -#-*- coding: UTF-8 -*- - -""" -This module uses the sample.py script to load all test models it finds. - -Note: this is not an exhaustive test suite, it does not check the -data structures in detail. It just verifies whether basic -loading and querying of 3d models using pyassimp works. -""" - -import os -import sys - -# Make the development (ie. GIT repo) version of PyAssimp available for import. -sys.path.insert(0, '..') - -import sample -from pyassimp import errors - -# Paths to model files. -basepaths = [os.path.join('..', '..', '..', 'test', 'models'), - os.path.join('..', '..', '..', 'test', 'models-nonbsd')] - -# Valid extensions for 3D model files. -extensions = ['.3ds', '.x', '.lwo', '.obj', '.md5mesh', '.dxf', '.ply', '.stl', - '.dae', '.md5anim', '.lws', '.irrmesh', '.nff', '.off', '.blend'] - - -def run_tests(): - ok, err = 0, 0 - for path in basepaths: - print("Looking for models in %s..." % path) - for root, dirs, files in os.walk(path): - for afile in files: - base, ext = os.path.splitext(afile) - if ext in extensions: - try: - sample.main(os.path.join(root, afile)) - ok += 1 - except errors.AssimpError as error: - # Assimp error is fine; this is a controlled case. - print(error) - err += 1 - except Exception: - print("Error encountered while loading <%s>" - % os.path.join(root, afile)) - print('** Loaded %s models, got controlled errors for %s files' - % (ok, err)) - - -if __name__ == '__main__': - run_tests() diff --git a/libs/assimp/port/PyAssimp/scripts/sample.py b/libs/assimp/port/PyAssimp/scripts/sample.py deleted file mode 100755 index 3cd4b3e..0000000 --- a/libs/assimp/port/PyAssimp/scripts/sample.py +++ /dev/null @@ -1,89 +0,0 @@ -#!/usr/bin/env python -#-*- coding: UTF-8 -*- - -""" -This module demonstrates the functionality of PyAssimp. -""" - -import sys -import logging -logging.basicConfig(level=logging.INFO) - -import pyassimp -import pyassimp.postprocess - -def recur_node(node,level = 0): - print(" " + "\t" * level + "- " + str(node)) - for child in node.children: - recur_node(child, level + 1) - - -def main(filename=None): - - scene = pyassimp.load(filename, processing=pyassimp.postprocess.aiProcess_Triangulate) - - #the model we load - print("MODEL:" + filename) - print - - #write some statistics - print("SCENE:") - print(" meshes:" + str(len(scene.meshes))) - print(" materials:" + str(len(scene.materials))) - print(" textures:" + str(len(scene.textures))) - print - - print("NODES:") - recur_node(scene.rootnode) - - print - print("MESHES:") - for index, mesh in enumerate(scene.meshes): - print(" MESH" + str(index+1)) - print(" material id:" + str(mesh.materialindex+1)) - print(" vertices:" + str(len(mesh.vertices))) - print(" first 3 verts:\n" + str(mesh.vertices[:3])) - if mesh.normals.any(): - print(" first 3 normals:\n" + str(mesh.normals[:3])) - else: - print(" no normals") - print(" colors:" + str(len(mesh.colors))) - tcs = mesh.texturecoords - if tcs.any(): - for tc_index, tc in enumerate(tcs): - print(" texture-coords "+ str(tc_index) + ":" + str(len(tcs[tc_index])) + "first3:" + str(tcs[tc_index][:3])) - - else: - print(" no texture coordinates") - print(" uv-component-count:" + str(len(mesh.numuvcomponents))) - print(" faces:" + str(len(mesh.faces)) + " -> first:\n" + str(mesh.faces[:3])) - print(" bones:" + str(len(mesh.bones)) + " -> first:" + str([str(b) for b in mesh.bones[:3]])) - print - - print("MATERIALS:") - for index, material in enumerate(scene.materials): - print(" MATERIAL (id:" + str(index+1) + ")") - for key, value in material.properties.items(): - print(" %s: %s" % (key, value)) - print - - print("TEXTURES:") - for index, texture in enumerate(scene.textures): - print(" TEXTURE" + str(index+1)) - print(" width:" + str(texture.width)) - print(" height:" + str(texture.height)) - print(" hint:" + str(texture.achformathint)) - print(" data (size):" + str(len(texture.data))) - - # Finally release the model - pyassimp.release(scene) - -def usage(): - print("Usage: sample.py <3d model>") - -if __name__ == "__main__": - - if len(sys.argv) != 2: - usage() - else: - main(sys.argv[1]) diff --git a/libs/assimp/port/PyAssimp/scripts/transformations.py b/libs/assimp/port/PyAssimp/scripts/transformations.py deleted file mode 100644 index bf0cac9..0000000 --- a/libs/assimp/port/PyAssimp/scripts/transformations.py +++ /dev/null @@ -1,1705 +0,0 @@ -# -*- coding: utf-8 -*- -# transformations.py - -# Copyright (c) 2006, Christoph Gohlke -# Copyright (c) 2006-2009, The Regents of the University of California -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# * Neither the name of the copyright holders nor the names of any -# contributors may be used to endorse or promote products derived -# from this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. - -"""Homogeneous Transformation Matrices and Quaternions. - -A library for calculating 4x4 matrices for translating, rotating, reflecting, -scaling, shearing, projecting, orthogonalizing, and superimposing arrays of -3D homogeneous coordinates as well as for converting between rotation matrices, -Euler angles, and quaternions. Also includes an Arcball control object and -functions to decompose transformation matrices. - -:Authors: - `Christoph Gohlke `__, - Laboratory for Fluorescence Dynamics, University of California, Irvine - -:Version: 20090418 - -Requirements ------------- - -* `Python 2.6 `__ -* `Numpy 1.3 `__ -* `transformations.c 20090418 `__ - (optional implementation of some functions in C) - -Notes ------ - -Matrices (M) can be inverted using numpy.linalg.inv(M), concatenated using -numpy.dot(M0, M1), or used to transform homogeneous coordinates (v) using -numpy.dot(M, v) for shape (4, \*) "point of arrays", respectively -numpy.dot(v, M.T) for shape (\*, 4) "array of points". - -Calculations are carried out with numpy.float64 precision. - -This Python implementation is not optimized for speed. - -Vector, point, quaternion, and matrix function arguments are expected to be -"array like", i.e. tuple, list, or numpy arrays. - -Return types are numpy arrays unless specified otherwise. - -Angles are in radians unless specified otherwise. - -Quaternions ix+jy+kz+w are represented as [x, y, z, w]. - -Use the transpose of transformation matrices for OpenGL glMultMatrixd(). - -A triple of Euler angles can be applied/interpreted in 24 ways, which can -be specified using a 4 character string or encoded 4-tuple: - - *Axes 4-string*: e.g. 'sxyz' or 'ryxy' - - - first character : rotations are applied to 's'tatic or 'r'otating frame - - remaining characters : successive rotation axis 'x', 'y', or 'z' - - *Axes 4-tuple*: e.g. (0, 0, 0, 0) or (1, 1, 1, 1) - - - inner axis: code of axis ('x':0, 'y':1, 'z':2) of rightmost matrix. - - parity : even (0) if inner axis 'x' is followed by 'y', 'y' is followed - by 'z', or 'z' is followed by 'x'. Otherwise odd (1). - - repetition : first and last axis are same (1) or different (0). - - frame : rotations are applied to static (0) or rotating (1) frame. - -References ----------- - -(1) Matrices and transformations. Ronald Goldman. - In "Graphics Gems I", pp 472-475. Morgan Kaufmann, 1990. -(2) More matrices and transformations: shear and pseudo-perspective. - Ronald Goldman. In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991. -(3) Decomposing a matrix into simple transformations. Spencer Thomas. - In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991. -(4) Recovering the data from the transformation matrix. Ronald Goldman. - In "Graphics Gems II", pp 324-331. Morgan Kaufmann, 1991. -(5) Euler angle conversion. Ken Shoemake. - In "Graphics Gems IV", pp 222-229. Morgan Kaufmann, 1994. -(6) Arcball rotation control. Ken Shoemake. - In "Graphics Gems IV", pp 175-192. Morgan Kaufmann, 1994. -(7) Representing attitude: Euler angles, unit quaternions, and rotation - vectors. James Diebel. 2006. -(8) A discussion of the solution for the best rotation to relate two sets - of vectors. W Kabsch. Acta Cryst. 1978. A34, 827-828. -(9) Closed-form solution of absolute orientation using unit quaternions. - BKP Horn. J Opt Soc Am A. 1987. 4(4), 629-642. -(10) Quaternions. Ken Shoemake. - http://www.sfu.ca/~jwa3/cmpt461/files/quatut.pdf -(11) From quaternion to matrix and back. JMP van Waveren. 2005. - http://www.intel.com/cd/ids/developer/asmo-na/eng/293748.htm -(12) Uniform random rotations. Ken Shoemake. - In "Graphics Gems III", pp 124-132. Morgan Kaufmann, 1992. - - -Examples --------- - ->>> alpha, beta, gamma = 0.123, -1.234, 2.345 ->>> origin, xaxis, yaxis, zaxis = (0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1) ->>> I = identity_matrix() ->>> Rx = rotation_matrix(alpha, xaxis) ->>> Ry = rotation_matrix(beta, yaxis) ->>> Rz = rotation_matrix(gamma, zaxis) ->>> R = concatenate_matrices(Rx, Ry, Rz) ->>> euler = euler_from_matrix(R, 'rxyz') ->>> numpy.allclose([alpha, beta, gamma], euler) -True ->>> Re = euler_matrix(alpha, beta, gamma, 'rxyz') ->>> is_same_transform(R, Re) -True ->>> al, be, ga = euler_from_matrix(Re, 'rxyz') ->>> is_same_transform(Re, euler_matrix(al, be, ga, 'rxyz')) -True ->>> qx = quaternion_about_axis(alpha, xaxis) ->>> qy = quaternion_about_axis(beta, yaxis) ->>> qz = quaternion_about_axis(gamma, zaxis) ->>> q = quaternion_multiply(qx, qy) ->>> q = quaternion_multiply(q, qz) ->>> Rq = quaternion_matrix(q) ->>> is_same_transform(R, Rq) -True ->>> S = scale_matrix(1.23, origin) ->>> T = translation_matrix((1, 2, 3)) ->>> Z = shear_matrix(beta, xaxis, origin, zaxis) ->>> R = random_rotation_matrix(numpy.random.rand(3)) ->>> M = concatenate_matrices(T, R, Z, S) ->>> scale, shear, angles, trans, persp = decompose_matrix(M) ->>> numpy.allclose(scale, 1.23) -True ->>> numpy.allclose(trans, (1, 2, 3)) -True ->>> numpy.allclose(shear, (0, math.tan(beta), 0)) -True ->>> is_same_transform(R, euler_matrix(axes='sxyz', *angles)) -True ->>> M1 = compose_matrix(scale, shear, angles, trans, persp) ->>> is_same_transform(M, M1) -True - -""" - -from __future__ import division - -import warnings -import math - -import numpy - -# Documentation in HTML format can be generated with Epydoc -__docformat__ = "restructuredtext en" - - -def identity_matrix(): - """Return 4x4 identity/unit matrix. - - >>> I = identity_matrix() - >>> numpy.allclose(I, numpy.dot(I, I)) - True - >>> numpy.sum(I), numpy.trace(I) - (4.0, 4.0) - >>> numpy.allclose(I, numpy.identity(4, dtype=numpy.float64)) - True - - """ - return numpy.identity(4, dtype=numpy.float64) - - -def translation_matrix(direction): - """Return matrix to translate by direction vector. - - >>> v = numpy.random.random(3) - 0.5 - >>> numpy.allclose(v, translation_matrix(v)[:3, 3]) - True - - """ - M = numpy.identity(4) - M[:3, 3] = direction[:3] - return M - - -def translation_from_matrix(matrix): - """Return translation vector from translation matrix. - - >>> v0 = numpy.random.random(3) - 0.5 - >>> v1 = translation_from_matrix(translation_matrix(v0)) - >>> numpy.allclose(v0, v1) - True - - """ - return numpy.array(matrix, copy=False)[:3, 3].copy() - - -def reflection_matrix(point, normal): - """Return matrix to mirror at plane defined by point and normal vector. - - >>> v0 = numpy.random.random(4) - 0.5 - >>> v0[3] = 1.0 - >>> v1 = numpy.random.random(3) - 0.5 - >>> R = reflection_matrix(v0, v1) - >>> numpy.allclose(2., numpy.trace(R)) - True - >>> numpy.allclose(v0, numpy.dot(R, v0)) - True - >>> v2 = v0.copy() - >>> v2[:3] += v1 - >>> v3 = v0.copy() - >>> v2[:3] -= v1 - >>> numpy.allclose(v2, numpy.dot(R, v3)) - True - - """ - normal = unit_vector(normal[:3]) - M = numpy.identity(4) - M[:3, :3] -= 2.0 * numpy.outer(normal, normal) - M[:3, 3] = (2.0 * numpy.dot(point[:3], normal)) * normal - return M - - -def reflection_from_matrix(matrix): - """Return mirror plane point and normal vector from reflection matrix. - - >>> v0 = numpy.random.random(3) - 0.5 - >>> v1 = numpy.random.random(3) - 0.5 - >>> M0 = reflection_matrix(v0, v1) - >>> point, normal = reflection_from_matrix(M0) - >>> M1 = reflection_matrix(point, normal) - >>> is_same_transform(M0, M1) - True - - """ - M = numpy.array(matrix, dtype=numpy.float64, copy=False) - # normal: unit eigenvector corresponding to eigenvalue -1 - l, V = numpy.linalg.eig(M[:3, :3]) - i = numpy.where(abs(numpy.real(l) + 1.0) < 1e-8)[0] - if not len(i): - raise ValueError("no unit eigenvector corresponding to eigenvalue -1") - normal = numpy.real(V[:, i[0]]).squeeze() - # point: any unit eigenvector corresponding to eigenvalue 1 - l, V = numpy.linalg.eig(M) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-8)[0] - if not len(i): - raise ValueError("no unit eigenvector corresponding to eigenvalue 1") - point = numpy.real(V[:, i[-1]]).squeeze() - point /= point[3] - return point, normal - - -def rotation_matrix(angle, direction, point=None): - """Return matrix to rotate about axis defined by point and direction. - - >>> angle = (random.random() - 0.5) * (2*math.pi) - >>> direc = numpy.random.random(3) - 0.5 - >>> point = numpy.random.random(3) - 0.5 - >>> R0 = rotation_matrix(angle, direc, point) - >>> R1 = rotation_matrix(angle-2*math.pi, direc, point) - >>> is_same_transform(R0, R1) - True - >>> R0 = rotation_matrix(angle, direc, point) - >>> R1 = rotation_matrix(-angle, -direc, point) - >>> is_same_transform(R0, R1) - True - >>> I = numpy.identity(4, numpy.float64) - >>> numpy.allclose(I, rotation_matrix(math.pi*2, direc)) - True - >>> numpy.allclose(2., numpy.trace(rotation_matrix(math.pi/2, - ... direc, point))) - True - - """ - sina = math.sin(angle) - cosa = math.cos(angle) - direction = unit_vector(direction[:3]) - # rotation matrix around unit vector - R = numpy.array(((cosa, 0.0, 0.0), - (0.0, cosa, 0.0), - (0.0, 0.0, cosa)), dtype=numpy.float64) - R += numpy.outer(direction, direction) * (1.0 - cosa) - direction *= sina - R += numpy.array((( 0.0, -direction[2], direction[1]), - ( direction[2], 0.0, -direction[0]), - (-direction[1], direction[0], 0.0)), - dtype=numpy.float64) - M = numpy.identity(4) - M[:3, :3] = R - if point is not None: - # rotation not around origin - point = numpy.array(point[:3], dtype=numpy.float64, copy=False) - M[:3, 3] = point - numpy.dot(R, point) - return M - - -def rotation_from_matrix(matrix): - """Return rotation angle and axis from rotation matrix. - - >>> angle = (random.random() - 0.5) * (2*math.pi) - >>> direc = numpy.random.random(3) - 0.5 - >>> point = numpy.random.random(3) - 0.5 - >>> R0 = rotation_matrix(angle, direc, point) - >>> angle, direc, point = rotation_from_matrix(R0) - >>> R1 = rotation_matrix(angle, direc, point) - >>> is_same_transform(R0, R1) - True - - """ - R = numpy.array(matrix, dtype=numpy.float64, copy=False) - R33 = R[:3, :3] - # direction: unit eigenvector of R33 corresponding to eigenvalue of 1 - l, W = numpy.linalg.eig(R33.T) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-8)[0] - if not len(i): - raise ValueError("no unit eigenvector corresponding to eigenvalue 1") - direction = numpy.real(W[:, i[-1]]).squeeze() - # point: unit eigenvector of R33 corresponding to eigenvalue of 1 - l, Q = numpy.linalg.eig(R) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-8)[0] - if not len(i): - raise ValueError("no unit eigenvector corresponding to eigenvalue 1") - point = numpy.real(Q[:, i[-1]]).squeeze() - point /= point[3] - # rotation angle depending on direction - cosa = (numpy.trace(R33) - 1.0) / 2.0 - if abs(direction[2]) > 1e-8: - sina = (R[1, 0] + (cosa-1.0)*direction[0]*direction[1]) / direction[2] - elif abs(direction[1]) > 1e-8: - sina = (R[0, 2] + (cosa-1.0)*direction[0]*direction[2]) / direction[1] - else: - sina = (R[2, 1] + (cosa-1.0)*direction[1]*direction[2]) / direction[0] - angle = math.atan2(sina, cosa) - return angle, direction, point - - -def scale_matrix(factor, origin=None, direction=None): - """Return matrix to scale by factor around origin in direction. - - Use factor -1 for point symmetry. - - >>> v = (numpy.random.rand(4, 5) - 0.5) * 20.0 - >>> v[3] = 1.0 - >>> S = scale_matrix(-1.234) - >>> numpy.allclose(numpy.dot(S, v)[:3], -1.234*v[:3]) - True - >>> factor = random.random() * 10 - 5 - >>> origin = numpy.random.random(3) - 0.5 - >>> direct = numpy.random.random(3) - 0.5 - >>> S = scale_matrix(factor, origin) - >>> S = scale_matrix(factor, origin, direct) - - """ - if direction is None: - # uniform scaling - M = numpy.array(((factor, 0.0, 0.0, 0.0), - (0.0, factor, 0.0, 0.0), - (0.0, 0.0, factor, 0.0), - (0.0, 0.0, 0.0, 1.0)), dtype=numpy.float64) - if origin is not None: - M[:3, 3] = origin[:3] - M[:3, 3] *= 1.0 - factor - else: - # nonuniform scaling - direction = unit_vector(direction[:3]) - factor = 1.0 - factor - M = numpy.identity(4) - M[:3, :3] -= factor * numpy.outer(direction, direction) - if origin is not None: - M[:3, 3] = (factor * numpy.dot(origin[:3], direction)) * direction - return M - - -def scale_from_matrix(matrix): - """Return scaling factor, origin and direction from scaling matrix. - - >>> factor = random.random() * 10 - 5 - >>> origin = numpy.random.random(3) - 0.5 - >>> direct = numpy.random.random(3) - 0.5 - >>> S0 = scale_matrix(factor, origin) - >>> factor, origin, direction = scale_from_matrix(S0) - >>> S1 = scale_matrix(factor, origin, direction) - >>> is_same_transform(S0, S1) - True - >>> S0 = scale_matrix(factor, origin, direct) - >>> factor, origin, direction = scale_from_matrix(S0) - >>> S1 = scale_matrix(factor, origin, direction) - >>> is_same_transform(S0, S1) - True - - """ - M = numpy.array(matrix, dtype=numpy.float64, copy=False) - M33 = M[:3, :3] - factor = numpy.trace(M33) - 2.0 - try: - # direction: unit eigenvector corresponding to eigenvalue factor - l, V = numpy.linalg.eig(M33) - i = numpy.where(abs(numpy.real(l) - factor) < 1e-8)[0][0] - direction = numpy.real(V[:, i]).squeeze() - direction /= vector_norm(direction) - except IndexError: - # uniform scaling - factor = (factor + 2.0) / 3.0 - direction = None - # origin: any eigenvector corresponding to eigenvalue 1 - l, V = numpy.linalg.eig(M) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-8)[0] - if not len(i): - raise ValueError("no eigenvector corresponding to eigenvalue 1") - origin = numpy.real(V[:, i[-1]]).squeeze() - origin /= origin[3] - return factor, origin, direction - - -def projection_matrix(point, normal, direction=None, - perspective=None, pseudo=False): - """Return matrix to project onto plane defined by point and normal. - - Using either perspective point, projection direction, or none of both. - - If pseudo is True, perspective projections will preserve relative depth - such that Perspective = dot(Orthogonal, PseudoPerspective). - - >>> P = projection_matrix((0, 0, 0), (1, 0, 0)) - >>> numpy.allclose(P[1:, 1:], numpy.identity(4)[1:, 1:]) - True - >>> point = numpy.random.random(3) - 0.5 - >>> normal = numpy.random.random(3) - 0.5 - >>> direct = numpy.random.random(3) - 0.5 - >>> persp = numpy.random.random(3) - 0.5 - >>> P0 = projection_matrix(point, normal) - >>> P1 = projection_matrix(point, normal, direction=direct) - >>> P2 = projection_matrix(point, normal, perspective=persp) - >>> P3 = projection_matrix(point, normal, perspective=persp, pseudo=True) - >>> is_same_transform(P2, numpy.dot(P0, P3)) - True - >>> P = projection_matrix((3, 0, 0), (1, 1, 0), (1, 0, 0)) - >>> v0 = (numpy.random.rand(4, 5) - 0.5) * 20.0 - >>> v0[3] = 1.0 - >>> v1 = numpy.dot(P, v0) - >>> numpy.allclose(v1[1], v0[1]) - True - >>> numpy.allclose(v1[0], 3.0-v1[1]) - True - - """ - M = numpy.identity(4) - point = numpy.array(point[:3], dtype=numpy.float64, copy=False) - normal = unit_vector(normal[:3]) - if perspective is not None: - # perspective projection - perspective = numpy.array(perspective[:3], dtype=numpy.float64, - copy=False) - M[0, 0] = M[1, 1] = M[2, 2] = numpy.dot(perspective-point, normal) - M[:3, :3] -= numpy.outer(perspective, normal) - if pseudo: - # preserve relative depth - M[:3, :3] -= numpy.outer(normal, normal) - M[:3, 3] = numpy.dot(point, normal) * (perspective+normal) - else: - M[:3, 3] = numpy.dot(point, normal) * perspective - M[3, :3] = -normal - M[3, 3] = numpy.dot(perspective, normal) - elif direction is not None: - # parallel projection - direction = numpy.array(direction[:3], dtype=numpy.float64, copy=False) - scale = numpy.dot(direction, normal) - M[:3, :3] -= numpy.outer(direction, normal) / scale - M[:3, 3] = direction * (numpy.dot(point, normal) / scale) - else: - # orthogonal projection - M[:3, :3] -= numpy.outer(normal, normal) - M[:3, 3] = numpy.dot(point, normal) * normal - return M - - -def projection_from_matrix(matrix, pseudo=False): - """Return projection plane and perspective point from projection matrix. - - Return values are same as arguments for projection_matrix function: - point, normal, direction, perspective, and pseudo. - - >>> point = numpy.random.random(3) - 0.5 - >>> normal = numpy.random.random(3) - 0.5 - >>> direct = numpy.random.random(3) - 0.5 - >>> persp = numpy.random.random(3) - 0.5 - >>> P0 = projection_matrix(point, normal) - >>> result = projection_from_matrix(P0) - >>> P1 = projection_matrix(*result) - >>> is_same_transform(P0, P1) - True - >>> P0 = projection_matrix(point, normal, direct) - >>> result = projection_from_matrix(P0) - >>> P1 = projection_matrix(*result) - >>> is_same_transform(P0, P1) - True - >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=False) - >>> result = projection_from_matrix(P0, pseudo=False) - >>> P1 = projection_matrix(*result) - >>> is_same_transform(P0, P1) - True - >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=True) - >>> result = projection_from_matrix(P0, pseudo=True) - >>> P1 = projection_matrix(*result) - >>> is_same_transform(P0, P1) - True - - """ - M = numpy.array(matrix, dtype=numpy.float64, copy=False) - M33 = M[:3, :3] - l, V = numpy.linalg.eig(M) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-8)[0] - if not pseudo and len(i): - # point: any eigenvector corresponding to eigenvalue 1 - point = numpy.real(V[:, i[-1]]).squeeze() - point /= point[3] - # direction: unit eigenvector corresponding to eigenvalue 0 - l, V = numpy.linalg.eig(M33) - i = numpy.where(abs(numpy.real(l)) < 1e-8)[0] - if not len(i): - raise ValueError("no eigenvector corresponding to eigenvalue 0") - direction = numpy.real(V[:, i[0]]).squeeze() - direction /= vector_norm(direction) - # normal: unit eigenvector of M33.T corresponding to eigenvalue 0 - l, V = numpy.linalg.eig(M33.T) - i = numpy.where(abs(numpy.real(l)) < 1e-8)[0] - if len(i): - # parallel projection - normal = numpy.real(V[:, i[0]]).squeeze() - normal /= vector_norm(normal) - return point, normal, direction, None, False - else: - # orthogonal projection, where normal equals direction vector - return point, direction, None, None, False - else: - # perspective projection - i = numpy.where(abs(numpy.real(l)) > 1e-8)[0] - if not len(i): - raise ValueError( - "no eigenvector not corresponding to eigenvalue 0") - point = numpy.real(V[:, i[-1]]).squeeze() - point /= point[3] - normal = - M[3, :3] - perspective = M[:3, 3] / numpy.dot(point[:3], normal) - if pseudo: - perspective -= normal - return point, normal, None, perspective, pseudo - - -def clip_matrix(left, right, bottom, top, near, far, perspective=False): - """Return matrix to obtain normalized device coordinates from frustrum. - - The frustrum bounds are axis-aligned along x (left, right), - y (bottom, top) and z (near, far). - - Normalized device coordinates are in range [-1, 1] if coordinates are - inside the frustrum. - - If perspective is True the frustrum is a truncated pyramid with the - perspective point at origin and direction along z axis, otherwise an - orthographic canonical view volume (a box). - - Homogeneous coordinates transformed by the perspective clip matrix - need to be dehomogenized (divided by w coordinate). - - >>> frustrum = numpy.random.rand(6) - >>> frustrum[1] += frustrum[0] - >>> frustrum[3] += frustrum[2] - >>> frustrum[5] += frustrum[4] - >>> M = clip_matrix(*frustrum, perspective=False) - >>> numpy.dot(M, [frustrum[0], frustrum[2], frustrum[4], 1.0]) - array([-1., -1., -1., 1.]) - >>> numpy.dot(M, [frustrum[1], frustrum[3], frustrum[5], 1.0]) - array([ 1., 1., 1., 1.]) - >>> M = clip_matrix(*frustrum, perspective=True) - >>> v = numpy.dot(M, [frustrum[0], frustrum[2], frustrum[4], 1.0]) - >>> v / v[3] - array([-1., -1., -1., 1.]) - >>> v = numpy.dot(M, [frustrum[1], frustrum[3], frustrum[4], 1.0]) - >>> v / v[3] - array([ 1., 1., -1., 1.]) - - """ - if left >= right or bottom >= top or near >= far: - raise ValueError("invalid frustrum") - if perspective: - if near <= _EPS: - raise ValueError("invalid frustrum: near <= 0") - t = 2.0 * near - M = ((-t/(right-left), 0.0, (right+left)/(right-left), 0.0), - (0.0, -t/(top-bottom), (top+bottom)/(top-bottom), 0.0), - (0.0, 0.0, -(far+near)/(far-near), t*far/(far-near)), - (0.0, 0.0, -1.0, 0.0)) - else: - M = ((2.0/(right-left), 0.0, 0.0, (right+left)/(left-right)), - (0.0, 2.0/(top-bottom), 0.0, (top+bottom)/(bottom-top)), - (0.0, 0.0, 2.0/(far-near), (far+near)/(near-far)), - (0.0, 0.0, 0.0, 1.0)) - return numpy.array(M, dtype=numpy.float64) - - -def shear_matrix(angle, direction, point, normal): - """Return matrix to shear by angle along direction vector on shear plane. - - The shear plane is defined by a point and normal vector. The direction - vector must be orthogonal to the plane's normal vector. - - A point P is transformed by the shear matrix into P" such that - the vector P-P" is parallel to the direction vector and its extent is - given by the angle of P-P'-P", where P' is the orthogonal projection - of P onto the shear plane. - - >>> angle = (random.random() - 0.5) * 4*math.pi - >>> direct = numpy.random.random(3) - 0.5 - >>> point = numpy.random.random(3) - 0.5 - >>> normal = numpy.cross(direct, numpy.random.random(3)) - >>> S = shear_matrix(angle, direct, point, normal) - >>> numpy.allclose(1.0, numpy.linalg.det(S)) - True - - """ - normal = unit_vector(normal[:3]) - direction = unit_vector(direction[:3]) - if abs(numpy.dot(normal, direction)) > 1e-6: - raise ValueError("direction and normal vectors are not orthogonal") - angle = math.tan(angle) - M = numpy.identity(4) - M[:3, :3] += angle * numpy.outer(direction, normal) - M[:3, 3] = -angle * numpy.dot(point[:3], normal) * direction - return M - - -def shear_from_matrix(matrix): - """Return shear angle, direction and plane from shear matrix. - - >>> angle = (random.random() - 0.5) * 4*math.pi - >>> direct = numpy.random.random(3) - 0.5 - >>> point = numpy.random.random(3) - 0.5 - >>> normal = numpy.cross(direct, numpy.random.random(3)) - >>> S0 = shear_matrix(angle, direct, point, normal) - >>> angle, direct, point, normal = shear_from_matrix(S0) - >>> S1 = shear_matrix(angle, direct, point, normal) - >>> is_same_transform(S0, S1) - True - - """ - M = numpy.array(matrix, dtype=numpy.float64, copy=False) - M33 = M[:3, :3] - # normal: cross independent eigenvectors corresponding to the eigenvalue 1 - l, V = numpy.linalg.eig(M33) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-4)[0] - if len(i) < 2: - raise ValueError("No two linear independent eigenvectors found %s" % l) - V = numpy.real(V[:, i]).squeeze().T - lenorm = -1.0 - for i0, i1 in ((0, 1), (0, 2), (1, 2)): - n = numpy.cross(V[i0], V[i1]) - l = vector_norm(n) - if l > lenorm: - lenorm = l - normal = n - normal /= lenorm - # direction and angle - direction = numpy.dot(M33 - numpy.identity(3), normal) - angle = vector_norm(direction) - direction /= angle - angle = math.atan(angle) - # point: eigenvector corresponding to eigenvalue 1 - l, V = numpy.linalg.eig(M) - i = numpy.where(abs(numpy.real(l) - 1.0) < 1e-8)[0] - if not len(i): - raise ValueError("no eigenvector corresponding to eigenvalue 1") - point = numpy.real(V[:, i[-1]]).squeeze() - point /= point[3] - return angle, direction, point, normal - - -def decompose_matrix(matrix): - """Return sequence of transformations from transformation matrix. - - matrix : array_like - Non-degenerative homogeneous transformation matrix - - Return tuple of: - scale : vector of 3 scaling factors - shear : list of shear factors for x-y, x-z, y-z axes - angles : list of Euler angles about static x, y, z axes - translate : translation vector along x, y, z axes - perspective : perspective partition of matrix - - Raise ValueError if matrix is of wrong type or degenerative. - - >>> T0 = translation_matrix((1, 2, 3)) - >>> scale, shear, angles, trans, persp = decompose_matrix(T0) - >>> T1 = translation_matrix(trans) - >>> numpy.allclose(T0, T1) - True - >>> S = scale_matrix(0.123) - >>> scale, shear, angles, trans, persp = decompose_matrix(S) - >>> scale[0] - 0.123 - >>> R0 = euler_matrix(1, 2, 3) - >>> scale, shear, angles, trans, persp = decompose_matrix(R0) - >>> R1 = euler_matrix(*angles) - >>> numpy.allclose(R0, R1) - True - - """ - M = numpy.array(matrix, dtype=numpy.float64, copy=True).T - if abs(M[3, 3]) < _EPS: - raise ValueError("M[3, 3] is zero") - M /= M[3, 3] - P = M.copy() - P[:, 3] = 0, 0, 0, 1 - if not numpy.linalg.det(P): - raise ValueError("Matrix is singular") - - scale = numpy.zeros((3, ), dtype=numpy.float64) - shear = [0, 0, 0] - angles = [0, 0, 0] - - if any(abs(M[:3, 3]) > _EPS): - perspective = numpy.dot(M[:, 3], numpy.linalg.inv(P.T)) - M[:, 3] = 0, 0, 0, 1 - else: - perspective = numpy.array((0, 0, 0, 1), dtype=numpy.float64) - - translate = M[3, :3].copy() - M[3, :3] = 0 - - row = M[:3, :3].copy() - scale[0] = vector_norm(row[0]) - row[0] /= scale[0] - shear[0] = numpy.dot(row[0], row[1]) - row[1] -= row[0] * shear[0] - scale[1] = vector_norm(row[1]) - row[1] /= scale[1] - shear[0] /= scale[1] - shear[1] = numpy.dot(row[0], row[2]) - row[2] -= row[0] * shear[1] - shear[2] = numpy.dot(row[1], row[2]) - row[2] -= row[1] * shear[2] - scale[2] = vector_norm(row[2]) - row[2] /= scale[2] - shear[1:] /= scale[2] - - if numpy.dot(row[0], numpy.cross(row[1], row[2])) < 0: - scale *= -1 - row *= -1 - - angles[1] = math.asin(-row[0, 2]) - if math.cos(angles[1]): - angles[0] = math.atan2(row[1, 2], row[2, 2]) - angles[2] = math.atan2(row[0, 1], row[0, 0]) - else: - #angles[0] = math.atan2(row[1, 0], row[1, 1]) - angles[0] = math.atan2(-row[2, 1], row[1, 1]) - angles[2] = 0.0 - - return scale, shear, angles, translate, perspective - - -def compose_matrix(scale=None, shear=None, angles=None, translate=None, - perspective=None): - """Return transformation matrix from sequence of transformations. - - This is the inverse of the decompose_matrix function. - - Sequence of transformations: - scale : vector of 3 scaling factors - shear : list of shear factors for x-y, x-z, y-z axes - angles : list of Euler angles about static x, y, z axes - translate : translation vector along x, y, z axes - perspective : perspective partition of matrix - - >>> scale = numpy.random.random(3) - 0.5 - >>> shear = numpy.random.random(3) - 0.5 - >>> angles = (numpy.random.random(3) - 0.5) * (2*math.pi) - >>> trans = numpy.random.random(3) - 0.5 - >>> persp = numpy.random.random(4) - 0.5 - >>> M0 = compose_matrix(scale, shear, angles, trans, persp) - >>> result = decompose_matrix(M0) - >>> M1 = compose_matrix(*result) - >>> is_same_transform(M0, M1) - True - - """ - M = numpy.identity(4) - if perspective is not None: - P = numpy.identity(4) - P[3, :] = perspective[:4] - M = numpy.dot(M, P) - if translate is not None: - T = numpy.identity(4) - T[:3, 3] = translate[:3] - M = numpy.dot(M, T) - if angles is not None: - R = euler_matrix(angles[0], angles[1], angles[2], 'sxyz') - M = numpy.dot(M, R) - if shear is not None: - Z = numpy.identity(4) - Z[1, 2] = shear[2] - Z[0, 2] = shear[1] - Z[0, 1] = shear[0] - M = numpy.dot(M, Z) - if scale is not None: - S = numpy.identity(4) - S[0, 0] = scale[0] - S[1, 1] = scale[1] - S[2, 2] = scale[2] - M = numpy.dot(M, S) - M /= M[3, 3] - return M - - -def orthogonalization_matrix(lengths, angles): - """Return orthogonalization matrix for crystallographic cell coordinates. - - Angles are expected in degrees. - - The de-orthogonalization matrix is the inverse. - - >>> O = orthogonalization_matrix((10., 10., 10.), (90., 90., 90.)) - >>> numpy.allclose(O[:3, :3], numpy.identity(3, float) * 10) - True - >>> O = orthogonalization_matrix([9.8, 12.0, 15.5], [87.2, 80.7, 69.7]) - >>> numpy.allclose(numpy.sum(O), 43.063229) - True - - """ - a, b, c = lengths - angles = numpy.radians(angles) - sina, sinb, _ = numpy.sin(angles) - cosa, cosb, cosg = numpy.cos(angles) - co = (cosa * cosb - cosg) / (sina * sinb) - return numpy.array(( - ( a*sinb*math.sqrt(1.0-co*co), 0.0, 0.0, 0.0), - (-a*sinb*co, b*sina, 0.0, 0.0), - ( a*cosb, b*cosa, c, 0.0), - ( 0.0, 0.0, 0.0, 1.0)), - dtype=numpy.float64) - - -def superimposition_matrix(v0, v1, scaling=False, usesvd=True): - """Return matrix to transform given vector set into second vector set. - - v0 and v1 are shape (3, \*) or (4, \*) arrays of at least 3 vectors. - - If usesvd is True, the weighted sum of squared deviations (RMSD) is - minimized according to the algorithm by W. Kabsch [8]. Otherwise the - quaternion based algorithm by B. Horn [9] is used (slower when using - this Python implementation). - - The returned matrix performs rotation, translation and uniform scaling - (if specified). - - >>> v0 = numpy.random.rand(3, 10) - >>> M = superimposition_matrix(v0, v0) - >>> numpy.allclose(M, numpy.identity(4)) - True - >>> R = random_rotation_matrix(numpy.random.random(3)) - >>> v0 = ((1,0,0), (0,1,0), (0,0,1), (1,1,1)) - >>> v1 = numpy.dot(R, v0) - >>> M = superimposition_matrix(v0, v1) - >>> numpy.allclose(v1, numpy.dot(M, v0)) - True - >>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20.0 - >>> v0[3] = 1.0 - >>> v1 = numpy.dot(R, v0) - >>> M = superimposition_matrix(v0, v1) - >>> numpy.allclose(v1, numpy.dot(M, v0)) - True - >>> S = scale_matrix(random.random()) - >>> T = translation_matrix(numpy.random.random(3)-0.5) - >>> M = concatenate_matrices(T, R, S) - >>> v1 = numpy.dot(M, v0) - >>> v0[:3] += numpy.random.normal(0.0, 1e-9, 300).reshape(3, -1) - >>> M = superimposition_matrix(v0, v1, scaling=True) - >>> numpy.allclose(v1, numpy.dot(M, v0)) - True - >>> M = superimposition_matrix(v0, v1, scaling=True, usesvd=False) - >>> numpy.allclose(v1, numpy.dot(M, v0)) - True - >>> v = numpy.empty((4, 100, 3), dtype=numpy.float64) - >>> v[:, :, 0] = v0 - >>> M = superimposition_matrix(v0, v1, scaling=True, usesvd=False) - >>> numpy.allclose(v1, numpy.dot(M, v[:, :, 0])) - True - - """ - v0 = numpy.array(v0, dtype=numpy.float64, copy=False)[:3] - v1 = numpy.array(v1, dtype=numpy.float64, copy=False)[:3] - - if v0.shape != v1.shape or v0.shape[1] < 3: - raise ValueError("Vector sets are of wrong shape or type.") - - # move centroids to origin - t0 = numpy.mean(v0, axis=1) - t1 = numpy.mean(v1, axis=1) - v0 = v0 - t0.reshape(3, 1) - v1 = v1 - t1.reshape(3, 1) - - if usesvd: - # Singular Value Decomposition of covariance matrix - u, s, vh = numpy.linalg.svd(numpy.dot(v1, v0.T)) - # rotation matrix from SVD orthonormal bases - R = numpy.dot(u, vh) - if numpy.linalg.det(R) < 0.0: - # R does not constitute right handed system - R -= numpy.outer(u[:, 2], vh[2, :]*2.0) - s[-1] *= -1.0 - # homogeneous transformation matrix - M = numpy.identity(4) - M[:3, :3] = R - else: - # compute symmetric matrix N - xx, yy, zz = numpy.sum(v0 * v1, axis=1) - xy, yz, zx = numpy.sum(v0 * numpy.roll(v1, -1, axis=0), axis=1) - xz, yx, zy = numpy.sum(v0 * numpy.roll(v1, -2, axis=0), axis=1) - N = ((xx+yy+zz, yz-zy, zx-xz, xy-yx), - (yz-zy, xx-yy-zz, xy+yx, zx+xz), - (zx-xz, xy+yx, -xx+yy-zz, yz+zy), - (xy-yx, zx+xz, yz+zy, -xx-yy+zz)) - # quaternion: eigenvector corresponding to most positive eigenvalue - l, V = numpy.linalg.eig(N) - q = V[:, numpy.argmax(l)] - q /= vector_norm(q) # unit quaternion - q = numpy.roll(q, -1) # move w component to end - # homogeneous transformation matrix - M = quaternion_matrix(q) - - # scale: ratio of rms deviations from centroid - if scaling: - v0 *= v0 - v1 *= v1 - M[:3, :3] *= math.sqrt(numpy.sum(v1) / numpy.sum(v0)) - - # translation - M[:3, 3] = t1 - T = numpy.identity(4) - T[:3, 3] = -t0 - M = numpy.dot(M, T) - return M - - -def euler_matrix(ai, aj, ak, axes='sxyz'): - """Return homogeneous rotation matrix from Euler angles and axis sequence. - - ai, aj, ak : Euler's roll, pitch and yaw angles - axes : One of 24 axis sequences as string or encoded tuple - - >>> R = euler_matrix(1, 2, 3, 'syxz') - >>> numpy.allclose(numpy.sum(R[0]), -1.34786452) - True - >>> R = euler_matrix(1, 2, 3, (0, 1, 0, 1)) - >>> numpy.allclose(numpy.sum(R[0]), -0.383436184) - True - >>> ai, aj, ak = (4.0*math.pi) * (numpy.random.random(3) - 0.5) - >>> for axes in _AXES2TUPLE.keys(): - ... R = euler_matrix(ai, aj, ak, axes) - >>> for axes in _TUPLE2AXES.keys(): - ... R = euler_matrix(ai, aj, ak, axes) - - """ - try: - firstaxis, parity, repetition, frame = _AXES2TUPLE[axes] - except (AttributeError, KeyError): - _ = _TUPLE2AXES[axes] - firstaxis, parity, repetition, frame = axes - - i = firstaxis - j = _NEXT_AXIS[i+parity] - k = _NEXT_AXIS[i-parity+1] - - if frame: - ai, ak = ak, ai - if parity: - ai, aj, ak = -ai, -aj, -ak - - si, sj, sk = math.sin(ai), math.sin(aj), math.sin(ak) - ci, cj, ck = math.cos(ai), math.cos(aj), math.cos(ak) - cc, cs = ci*ck, ci*sk - sc, ss = si*ck, si*sk - - M = numpy.identity(4) - if repetition: - M[i, i] = cj - M[i, j] = sj*si - M[i, k] = sj*ci - M[j, i] = sj*sk - M[j, j] = -cj*ss+cc - M[j, k] = -cj*cs-sc - M[k, i] = -sj*ck - M[k, j] = cj*sc+cs - M[k, k] = cj*cc-ss - else: - M[i, i] = cj*ck - M[i, j] = sj*sc-cs - M[i, k] = sj*cc+ss - M[j, i] = cj*sk - M[j, j] = sj*ss+cc - M[j, k] = sj*cs-sc - M[k, i] = -sj - M[k, j] = cj*si - M[k, k] = cj*ci - return M - - -def euler_from_matrix(matrix, axes='sxyz'): - """Return Euler angles from rotation matrix for specified axis sequence. - - axes : One of 24 axis sequences as string or encoded tuple - - Note that many Euler angle triplets can describe one matrix. - - >>> R0 = euler_matrix(1, 2, 3, 'syxz') - >>> al, be, ga = euler_from_matrix(R0, 'syxz') - >>> R1 = euler_matrix(al, be, ga, 'syxz') - >>> numpy.allclose(R0, R1) - True - >>> angles = (4.0*math.pi) * (numpy.random.random(3) - 0.5) - >>> for axes in _AXES2TUPLE.keys(): - ... R0 = euler_matrix(axes=axes, *angles) - ... R1 = euler_matrix(axes=axes, *euler_from_matrix(R0, axes)) - ... if not numpy.allclose(R0, R1): print axes, "failed" - - """ - try: - firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()] - except (AttributeError, KeyError): - _ = _TUPLE2AXES[axes] - firstaxis, parity, repetition, frame = axes - - i = firstaxis - j = _NEXT_AXIS[i+parity] - k = _NEXT_AXIS[i-parity+1] - - M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:3, :3] - if repetition: - sy = math.sqrt(M[i, j]*M[i, j] + M[i, k]*M[i, k]) - if sy > _EPS: - ax = math.atan2( M[i, j], M[i, k]) - ay = math.atan2( sy, M[i, i]) - az = math.atan2( M[j, i], -M[k, i]) - else: - ax = math.atan2(-M[j, k], M[j, j]) - ay = math.atan2( sy, M[i, i]) - az = 0.0 - else: - cy = math.sqrt(M[i, i]*M[i, i] + M[j, i]*M[j, i]) - if cy > _EPS: - ax = math.atan2( M[k, j], M[k, k]) - ay = math.atan2(-M[k, i], cy) - az = math.atan2( M[j, i], M[i, i]) - else: - ax = math.atan2(-M[j, k], M[j, j]) - ay = math.atan2(-M[k, i], cy) - az = 0.0 - - if parity: - ax, ay, az = -ax, -ay, -az - if frame: - ax, az = az, ax - return ax, ay, az - - -def euler_from_quaternion(quaternion, axes='sxyz'): - """Return Euler angles from quaternion for specified axis sequence. - - >>> angles = euler_from_quaternion([0.06146124, 0, 0, 0.99810947]) - >>> numpy.allclose(angles, [0.123, 0, 0]) - True - - """ - return euler_from_matrix(quaternion_matrix(quaternion), axes) - - -def quaternion_from_euler(ai, aj, ak, axes='sxyz'): - """Return quaternion from Euler angles and axis sequence. - - ai, aj, ak : Euler's roll, pitch and yaw angles - axes : One of 24 axis sequences as string or encoded tuple - - >>> q = quaternion_from_euler(1, 2, 3, 'ryxz') - >>> numpy.allclose(q, [0.310622, -0.718287, 0.444435, 0.435953]) - True - - """ - try: - firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()] - except (AttributeError, KeyError): - _ = _TUPLE2AXES[axes] - firstaxis, parity, repetition, frame = axes - - i = firstaxis - j = _NEXT_AXIS[i+parity] - k = _NEXT_AXIS[i-parity+1] - - if frame: - ai, ak = ak, ai - if parity: - aj = -aj - - ai /= 2.0 - aj /= 2.0 - ak /= 2.0 - ci = math.cos(ai) - si = math.sin(ai) - cj = math.cos(aj) - sj = math.sin(aj) - ck = math.cos(ak) - sk = math.sin(ak) - cc = ci*ck - cs = ci*sk - sc = si*ck - ss = si*sk - - quaternion = numpy.empty((4, ), dtype=numpy.float64) - if repetition: - quaternion[i] = cj*(cs + sc) - quaternion[j] = sj*(cc + ss) - quaternion[k] = sj*(cs - sc) - quaternion[3] = cj*(cc - ss) - else: - quaternion[i] = cj*sc - sj*cs - quaternion[j] = cj*ss + sj*cc - quaternion[k] = cj*cs - sj*sc - quaternion[3] = cj*cc + sj*ss - if parity: - quaternion[j] *= -1 - - return quaternion - - -def quaternion_about_axis(angle, axis): - """Return quaternion for rotation about axis. - - >>> q = quaternion_about_axis(0.123, (1, 0, 0)) - >>> numpy.allclose(q, [0.06146124, 0, 0, 0.99810947]) - True - - """ - quaternion = numpy.zeros((4, ), dtype=numpy.float64) - quaternion[:3] = axis[:3] - qlen = vector_norm(quaternion) - if qlen > _EPS: - quaternion *= math.sin(angle/2.0) / qlen - quaternion[3] = math.cos(angle/2.0) - return quaternion - - -def quaternion_matrix(quaternion): - """Return homogeneous rotation matrix from quaternion. - - >>> R = quaternion_matrix([0.06146124, 0, 0, 0.99810947]) - >>> numpy.allclose(R, rotation_matrix(0.123, (1, 0, 0))) - True - - """ - q = numpy.array(quaternion[:4], dtype=numpy.float64, copy=True) - nq = numpy.dot(q, q) - if nq < _EPS: - return numpy.identity(4) - q *= math.sqrt(2.0 / nq) - q = numpy.outer(q, q) - return numpy.array(( - (1.0-q[1, 1]-q[2, 2], q[0, 1]-q[2, 3], q[0, 2]+q[1, 3], 0.0), - ( q[0, 1]+q[2, 3], 1.0-q[0, 0]-q[2, 2], q[1, 2]-q[0, 3], 0.0), - ( q[0, 2]-q[1, 3], q[1, 2]+q[0, 3], 1.0-q[0, 0]-q[1, 1], 0.0), - ( 0.0, 0.0, 0.0, 1.0) - ), dtype=numpy.float64) - - -def quaternion_from_matrix(matrix): - """Return quaternion from rotation matrix. - - >>> R = rotation_matrix(0.123, (1, 2, 3)) - >>> q = quaternion_from_matrix(R) - >>> numpy.allclose(q, [0.0164262, 0.0328524, 0.0492786, 0.9981095]) - True - - """ - q = numpy.empty((4, ), dtype=numpy.float64) - M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:4, :4] - t = numpy.trace(M) - if t > M[3, 3]: - q[3] = t - q[2] = M[1, 0] - M[0, 1] - q[1] = M[0, 2] - M[2, 0] - q[0] = M[2, 1] - M[1, 2] - else: - i, j, k = 0, 1, 2 - if M[1, 1] > M[0, 0]: - i, j, k = 1, 2, 0 - if M[2, 2] > M[i, i]: - i, j, k = 2, 0, 1 - t = M[i, i] - (M[j, j] + M[k, k]) + M[3, 3] - q[i] = t - q[j] = M[i, j] + M[j, i] - q[k] = M[k, i] + M[i, k] - q[3] = M[k, j] - M[j, k] - q *= 0.5 / math.sqrt(t * M[3, 3]) - return q - - -def quaternion_multiply(quaternion1, quaternion0): - """Return multiplication of two quaternions. - - >>> q = quaternion_multiply([1, -2, 3, 4], [-5, 6, 7, 8]) - >>> numpy.allclose(q, [-44, -14, 48, 28]) - True - - """ - x0, y0, z0, w0 = quaternion0 - x1, y1, z1, w1 = quaternion1 - return numpy.array(( - x1*w0 + y1*z0 - z1*y0 + w1*x0, - -x1*z0 + y1*w0 + z1*x0 + w1*y0, - x1*y0 - y1*x0 + z1*w0 + w1*z0, - -x1*x0 - y1*y0 - z1*z0 + w1*w0), dtype=numpy.float64) - - -def quaternion_conjugate(quaternion): - """Return conjugate of quaternion. - - >>> q0 = random_quaternion() - >>> q1 = quaternion_conjugate(q0) - >>> q1[3] == q0[3] and all(q1[:3] == -q0[:3]) - True - - """ - return numpy.array((-quaternion[0], -quaternion[1], - -quaternion[2], quaternion[3]), dtype=numpy.float64) - - -def quaternion_inverse(quaternion): - """Return inverse of quaternion. - - >>> q0 = random_quaternion() - >>> q1 = quaternion_inverse(q0) - >>> numpy.allclose(quaternion_multiply(q0, q1), [0, 0, 0, 1]) - True - - """ - return quaternion_conjugate(quaternion) / numpy.dot(quaternion, quaternion) - - -def quaternion_slerp(quat0, quat1, fraction, spin=0, shortestpath=True): - """Return spherical linear interpolation between two quaternions. - - >>> q0 = random_quaternion() - >>> q1 = random_quaternion() - >>> q = quaternion_slerp(q0, q1, 0.0) - >>> numpy.allclose(q, q0) - True - >>> q = quaternion_slerp(q0, q1, 1.0, 1) - >>> numpy.allclose(q, q1) - True - >>> q = quaternion_slerp(q0, q1, 0.5) - >>> angle = math.acos(numpy.dot(q0, q)) - >>> numpy.allclose(2.0, math.acos(numpy.dot(q0, q1)) / angle) or \ - numpy.allclose(2.0, math.acos(-numpy.dot(q0, q1)) / angle) - True - - """ - q0 = unit_vector(quat0[:4]) - q1 = unit_vector(quat1[:4]) - if fraction == 0.0: - return q0 - elif fraction == 1.0: - return q1 - d = numpy.dot(q0, q1) - if abs(abs(d) - 1.0) < _EPS: - return q0 - if shortestpath and d < 0.0: - # invert rotation - d = -d - q1 *= -1.0 - angle = math.acos(d) + spin * math.pi - if abs(angle) < _EPS: - return q0 - isin = 1.0 / math.sin(angle) - q0 *= math.sin((1.0 - fraction) * angle) * isin - q1 *= math.sin(fraction * angle) * isin - q0 += q1 - return q0 - - -def random_quaternion(rand=None): - """Return uniform random unit quaternion. - - rand: array like or None - Three independent random variables that are uniformly distributed - between 0 and 1. - - >>> q = random_quaternion() - >>> numpy.allclose(1.0, vector_norm(q)) - True - >>> q = random_quaternion(numpy.random.random(3)) - >>> q.shape - (4,) - - """ - if rand is None: - rand = numpy.random.rand(3) - else: - assert len(rand) == 3 - r1 = numpy.sqrt(1.0 - rand[0]) - r2 = numpy.sqrt(rand[0]) - pi2 = math.pi * 2.0 - t1 = pi2 * rand[1] - t2 = pi2 * rand[2] - return numpy.array((numpy.sin(t1)*r1, - numpy.cos(t1)*r1, - numpy.sin(t2)*r2, - numpy.cos(t2)*r2), dtype=numpy.float64) - - -def random_rotation_matrix(rand=None): - """Return uniform random rotation matrix. - - rnd: array like - Three independent random variables that are uniformly distributed - between 0 and 1 for each returned quaternion. - - >>> R = random_rotation_matrix() - >>> numpy.allclose(numpy.dot(R.T, R), numpy.identity(4)) - True - - """ - return quaternion_matrix(random_quaternion(rand)) - - -class Arcball(object): - """Virtual Trackball Control. - - >>> ball = Arcball() - >>> ball = Arcball(initial=numpy.identity(4)) - >>> ball.place([320, 320], 320) - >>> ball.down([500, 250]) - >>> ball.drag([475, 275]) - >>> R = ball.matrix() - >>> numpy.allclose(numpy.sum(R), 3.90583455) - True - >>> ball = Arcball(initial=[0, 0, 0, 1]) - >>> ball.place([320, 320], 320) - >>> ball.setaxes([1,1,0], [-1, 1, 0]) - >>> ball.setconstrain(True) - >>> ball.down([400, 200]) - >>> ball.drag([200, 400]) - >>> R = ball.matrix() - >>> numpy.allclose(numpy.sum(R), 0.2055924) - True - >>> ball.next() - - """ - - def __init__(self, initial=None): - """Initialize virtual trackball control. - - initial : quaternion or rotation matrix - - """ - self._axis = None - self._axes = None - self._radius = 1.0 - self._center = [0.0, 0.0] - self._vdown = numpy.array([0, 0, 1], dtype=numpy.float64) - self._constrain = False - - if initial is None: - self._qdown = numpy.array([0, 0, 0, 1], dtype=numpy.float64) - else: - initial = numpy.array(initial, dtype=numpy.float64) - if initial.shape == (4, 4): - self._qdown = quaternion_from_matrix(initial) - elif initial.shape == (4, ): - initial /= vector_norm(initial) - self._qdown = initial - else: - raise ValueError("initial not a quaternion or matrix.") - - self._qnow = self._qpre = self._qdown - - def place(self, center, radius): - """Place Arcball, e.g. when window size changes. - - center : sequence[2] - Window coordinates of trackball center. - radius : float - Radius of trackball in window coordinates. - - """ - self._radius = float(radius) - self._center[0] = center[0] - self._center[1] = center[1] - - def setaxes(self, *axes): - """Set axes to constrain rotations.""" - if axes is None: - self._axes = None - else: - self._axes = [unit_vector(axis) for axis in axes] - - def setconstrain(self, constrain): - """Set state of constrain to axis mode.""" - self._constrain = constrain == True - - def getconstrain(self): - """Return state of constrain to axis mode.""" - return self._constrain - - def down(self, point): - """Set initial cursor window coordinates and pick constrain-axis.""" - self._vdown = arcball_map_to_sphere(point, self._center, self._radius) - self._qdown = self._qpre = self._qnow - - if self._constrain and self._axes is not None: - self._axis = arcball_nearest_axis(self._vdown, self._axes) - self._vdown = arcball_constrain_to_axis(self._vdown, self._axis) - else: - self._axis = None - - def drag(self, point): - """Update current cursor window coordinates.""" - vnow = arcball_map_to_sphere(point, self._center, self._radius) - - if self._axis is not None: - vnow = arcball_constrain_to_axis(vnow, self._axis) - - self._qpre = self._qnow - - t = numpy.cross(self._vdown, vnow) - if numpy.dot(t, t) < _EPS: - self._qnow = self._qdown - else: - q = [t[0], t[1], t[2], numpy.dot(self._vdown, vnow)] - self._qnow = quaternion_multiply(q, self._qdown) - - def next(self, acceleration=0.0): - """Continue rotation in direction of last drag.""" - q = quaternion_slerp(self._qpre, self._qnow, 2.0+acceleration, False) - self._qpre, self._qnow = self._qnow, q - - def matrix(self): - """Return homogeneous rotation matrix.""" - return quaternion_matrix(self._qnow) - - -def arcball_map_to_sphere(point, center, radius): - """Return unit sphere coordinates from window coordinates.""" - v = numpy.array(((point[0] - center[0]) / radius, - (center[1] - point[1]) / radius, - 0.0), dtype=numpy.float64) - n = v[0]*v[0] + v[1]*v[1] - if n > 1.0: - v /= math.sqrt(n) # position outside of sphere - else: - v[2] = math.sqrt(1.0 - n) - return v - - -def arcball_constrain_to_axis(point, axis): - """Return sphere point perpendicular to axis.""" - v = numpy.array(point, dtype=numpy.float64, copy=True) - a = numpy.array(axis, dtype=numpy.float64, copy=True) - v -= a * numpy.dot(a, v) # on plane - n = vector_norm(v) - if n > _EPS: - if v[2] < 0.0: - v *= -1.0 - v /= n - return v - if a[2] == 1.0: - return numpy.array([1, 0, 0], dtype=numpy.float64) - return unit_vector([-a[1], a[0], 0]) - - -def arcball_nearest_axis(point, axes): - """Return axis, which arc is nearest to point.""" - point = numpy.array(point, dtype=numpy.float64, copy=False) - nearest = None - mx = -1.0 - for axis in axes: - t = numpy.dot(arcball_constrain_to_axis(point, axis), point) - if t > mx: - nearest = axis - mx = t - return nearest - - -# epsilon for testing whether a number is close to zero -_EPS = numpy.finfo(float).eps * 4.0 - -# axis sequences for Euler angles -_NEXT_AXIS = [1, 2, 0, 1] - -# map axes strings to/from tuples of inner axis, parity, repetition, frame -_AXES2TUPLE = { - 'sxyz': (0, 0, 0, 0), 'sxyx': (0, 0, 1, 0), 'sxzy': (0, 1, 0, 0), - 'sxzx': (0, 1, 1, 0), 'syzx': (1, 0, 0, 0), 'syzy': (1, 0, 1, 0), - 'syxz': (1, 1, 0, 0), 'syxy': (1, 1, 1, 0), 'szxy': (2, 0, 0, 0), - 'szxz': (2, 0, 1, 0), 'szyx': (2, 1, 0, 0), 'szyz': (2, 1, 1, 0), - 'rzyx': (0, 0, 0, 1), 'rxyx': (0, 0, 1, 1), 'ryzx': (0, 1, 0, 1), - 'rxzx': (0, 1, 1, 1), 'rxzy': (1, 0, 0, 1), 'ryzy': (1, 0, 1, 1), - 'rzxy': (1, 1, 0, 1), 'ryxy': (1, 1, 1, 1), 'ryxz': (2, 0, 0, 1), - 'rzxz': (2, 0, 1, 1), 'rxyz': (2, 1, 0, 1), 'rzyz': (2, 1, 1, 1)} - -_TUPLE2AXES = dict((v, k) for k, v in _AXES2TUPLE.items()) - -# helper functions - -def vector_norm(data, axis=None, out=None): - """Return length, i.e. eucledian norm, of ndarray along axis. - - >>> v = numpy.random.random(3) - >>> n = vector_norm(v) - >>> numpy.allclose(n, numpy.linalg.norm(v)) - True - >>> v = numpy.random.rand(6, 5, 3) - >>> n = vector_norm(v, axis=-1) - >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=2))) - True - >>> n = vector_norm(v, axis=1) - >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1))) - True - >>> v = numpy.random.rand(5, 4, 3) - >>> n = numpy.empty((5, 3), dtype=numpy.float64) - >>> vector_norm(v, axis=1, out=n) - >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1))) - True - >>> vector_norm([]) - 0.0 - >>> vector_norm([1.0]) - 1.0 - - """ - data = numpy.array(data, dtype=numpy.float64, copy=True) - if out is None: - if data.ndim == 1: - return math.sqrt(numpy.dot(data, data)) - data *= data - out = numpy.atleast_1d(numpy.sum(data, axis=axis)) - numpy.sqrt(out, out) - return out - else: - data *= data - numpy.sum(data, axis=axis, out=out) - numpy.sqrt(out, out) - - -def unit_vector(data, axis=None, out=None): - """Return ndarray normalized by length, i.e. eucledian norm, along axis. - - >>> v0 = numpy.random.random(3) - >>> v1 = unit_vector(v0) - >>> numpy.allclose(v1, v0 / numpy.linalg.norm(v0)) - True - >>> v0 = numpy.random.rand(5, 4, 3) - >>> v1 = unit_vector(v0, axis=-1) - >>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=2)), 2) - >>> numpy.allclose(v1, v2) - True - >>> v1 = unit_vector(v0, axis=1) - >>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=1)), 1) - >>> numpy.allclose(v1, v2) - True - >>> v1 = numpy.empty((5, 4, 3), dtype=numpy.float64) - >>> unit_vector(v0, axis=1, out=v1) - >>> numpy.allclose(v1, v2) - True - >>> list(unit_vector([])) - [] - >>> list(unit_vector([1.0])) - [1.0] - - """ - if out is None: - data = numpy.array(data, dtype=numpy.float64, copy=True) - if data.ndim == 1: - data /= math.sqrt(numpy.dot(data, data)) - return data - else: - if out is not data: - out[:] = numpy.array(data, copy=False) - data = out - length = numpy.atleast_1d(numpy.sum(data*data, axis)) - numpy.sqrt(length, length) - if axis is not None: - length = numpy.expand_dims(length, axis) - data /= length - if out is None: - return data - - -def random_vector(size): - """Return array of random doubles in the half-open interval [0.0, 1.0). - - >>> v = random_vector(10000) - >>> numpy.all(v >= 0.0) and numpy.all(v < 1.0) - True - >>> v0 = random_vector(10) - >>> v1 = random_vector(10) - >>> numpy.any(v0 == v1) - False - - """ - return numpy.random.random(size) - - -def inverse_matrix(matrix): - """Return inverse of square transformation matrix. - - >>> M0 = random_rotation_matrix() - >>> M1 = inverse_matrix(M0.T) - >>> numpy.allclose(M1, numpy.linalg.inv(M0.T)) - True - >>> for size in range(1, 7): - ... M0 = numpy.random.rand(size, size) - ... M1 = inverse_matrix(M0) - ... if not numpy.allclose(M1, numpy.linalg.inv(M0)): print size - - """ - return numpy.linalg.inv(matrix) - - -def concatenate_matrices(*matrices): - """Return concatenation of series of transformation matrices. - - >>> M = numpy.random.rand(16).reshape((4, 4)) - 0.5 - >>> numpy.allclose(M, concatenate_matrices(M)) - True - >>> numpy.allclose(numpy.dot(M, M.T), concatenate_matrices(M, M.T)) - True - - """ - M = numpy.identity(4) - for i in matrices: - M = numpy.dot(M, i) - return M - - -def is_same_transform(matrix0, matrix1): - """Return True if two matrices perform same transformation. - - >>> is_same_transform(numpy.identity(4), numpy.identity(4)) - True - >>> is_same_transform(numpy.identity(4), random_rotation_matrix()) - False - - """ - matrix0 = numpy.array(matrix0, dtype=numpy.float64, copy=True) - matrix0 /= matrix0[3, 3] - matrix1 = numpy.array(matrix1, dtype=numpy.float64, copy=True) - matrix1 /= matrix1[3, 3] - return numpy.allclose(matrix0, matrix1) - - -def _import_module(module_name, warn=True, prefix='_py_', ignore='_'): - """Try import all public attributes from module into global namespace. - - Existing attributes with name clashes are renamed with prefix. - Attributes starting with underscore are ignored by default. - - Return True on successful import. - - """ - try: - module = __import__(module_name) - except ImportError: - if warn: - warnings.warn("Failed to import module " + module_name) - else: - for attr in dir(module): - if ignore and attr.startswith(ignore): - continue - if prefix: - if attr in globals(): - globals()[prefix + attr] = globals()[attr] - elif warn: - warnings.warn("No Python implementation of " + attr) - globals()[attr] = getattr(module, attr) - return True -- cgit v1.2.1