Add simApplyTexture & simGetShapeViz (#104)

* Add pyrep.backend.sim.simApplyTexture

* Add Shape.apply_texture

* Add sim.simGetShapeViz and Shape.get_shape_viz

* Add test_apply_texture

Author: wkentaro

pyrep/backend/sim.py

@@ -1,6 +1,25 @@
 from .simConst import *
 from ._sim_cffi import ffi, lib
 import numpy as np
+import collections
+
+
+SShapeVizInfo = collections.namedtuple(
+    'SShapeVizInfo',
+    [
+        'vertices',
+        'indices',
+        'normals',
+        'shadingAngle',
+        'colors',
+        'texture',
+        'textureId',
+        'textureRes',
+        'textureCoords',
+        'textureApplyMode',
+        'textureOptions',
+    ],
+)
 
 
 def _check_return(ret):
@@ -881,6 +900,41 @@ def simGetShapeMesh(shapeHandle):
     return retVerticies, retIndices, outNormals
 
 
+def simGetShapeViz(shapeHandle, index):
+    info = ffi.new('struct SShapeVizInfo *')
+    ret = lib.simGetShapeViz(shapeHandle, index, info)
+    _check_return(ret)
+
+    vertices = [info.vertices[i] for i in range(info.verticesSize)]
+    indices = [info.indices[i] for i in range(info.indicesSize)]
+    normals = [info.normals[i] for i in range(info.indicesSize * 3)]
+    colors = list(info.colors)
+    textureSize = info.textureRes[0] * info.textureRes[1] * 4
+    if textureSize == 0:
+        texture = []
+        textureCoords = []
+    else:
+        texture = np.frombuffer(
+            ffi.buffer(info.texture, textureSize), np.uint8)
+        texture = texture.tolist()
+        textureCoords = [info.textureCoords[i] for i in
+                        range(info.indicesSize * 2)]
+
+    return SShapeVizInfo(
+        vertices=vertices,
+        indices=indices,
+        normals=normals,
+        shadingAngle=info.shadingAngle,
+        colors=colors,
+        texture=texture,
+        textureId=info.textureId,
+        textureRes=info.textureRes,
+        textureCoords=textureCoords,
+        textureApplyMode=info.textureApplyMode,
+        textureOptions=info.textureOptions,
+    )
+
+
 def simConvexDecompose(shapeHandle, options, intParams, floatParams):
     return lib.simConvexDecompose(shapeHandle, options, intParams, floatParams)
 
@@ -931,6 +985,14 @@ def simGetScriptAssociatedWithObject(objectHandle):
     return ret
 
 
+def simApplyTexture(shapeHandle, textureCoordinates, textCoordSize,
+                    texture, textureResolution, options):
+    ret = lib.simApplyTexture(shapeHandle, textureCoordinates, textCoordSize,
+                              texture, textureResolution, options)
+    _check_return(ret)
+    return ret
+
+
 def simCreateTexture(fileName, options):
     # The textureID param that is returned from simCreateTexture seems
     # to be incorrect (in regards to calling simGetShapeTextureId on the

pyrep/objects/shape.py

@@ -1,9 +1,28 @@
 from typing import List, Tuple
+import numpy as np
 from pyrep.backend import sim
 from pyrep.objects.object import Object, object_type_to_class
 from pyrep.const import ObjectType, PrimitiveShape, TextureMappingMode
 from pyrep.textures.texture import Texture
 import os
+import collections
+
+
+SShapeVizInfo = collections.namedtuple(
+    'SShapeVizInfo',
+    [
+        'vertices',
+        'indices',
+        'normals',
+        'shading_angle',
+        'colors',
+        'texture',
+        'texture_id',
+        'texture_coords',
+        'texture_apply_mode',
+        'texture_options',
+    ],
+)
 
 
 class Shape(Object):
@@ -357,5 +376,83 @@ def ungroup(self) -> List['Shape']:
         handles = sim.simUngroupShape(self.get_handle())
         return [Shape(handle) for handle in handles]
 
+    def apply_texture(self, texture_coords: np.ndarray, texture: np.ndarray,
+                      interpolate: bool = True, decal_mode: bool = False,
+                      is_rgba: bool = False, fliph: bool = False,
+                      flipv: bool = False) -> None:
+        """Apply texture to the shape.
+
+        :param texture_coords: A list of (u, v) values that indicate the
+            vertex position on the shape. For each of the shape's triangle,
+            there should be exactly 3 UV texture coordinate pairs
+        :param texture: The RGB or RGBA texture.
+        :param interpolate: A flag to interpolate adjacent texture pixels.
+        :param decal_mode: Texture is applied as a decal (its appearance
+            won't be influenced by light conditions).
+        :param is_rgba: A flag to use RGBA texture.
+        :param fliph: A flag to flip texture horizontally.
+        :param flipv: A flag to flip texture vertically. Note that CoppeliaSim
+            texture coordinates are flipped vertically compared with Pillow
+            and OpenCV and this flag must be true in general.
+        """
+        texture_coords = np.asarray(texture_coords)
+        if not isinstance(texture, np.ndarray):
+            raise TypeError('texture must be np.ndarray type')
+        height, width = texture.shape[:2]
+
+        options = 0
+        if not interpolate:
+            options |= 1
+        if decal_mode:
+            options |= 2
+        if is_rgba:
+            options |= 16
+        if fliph:
+            options |= 32
+        if flipv:
+            options |= 64
+
+        sim.simApplyTexture(
+            self._handle,
+            textureCoordinates=texture_coords.flatten().tolist(),
+            textCoordSize=texture_coords.size,
+            texture=texture.flatten().tolist(),
+            textureResolution=(width, height),
+            options=options,
+        )
+
+    def get_shape_viz(self, index):
+        """Retrieves a shape's visual information.
+
+        :param index: 0-based index of the shape element to retrieve
+            (compound shapes contain more than one shape element)
+
+        :return: SShapeVizInfo.
+        """
+        info = sim.simGetShapeViz(shapeHandle=self._handle, index=index)
+
+        vertices = np.array(info.vertices, dtype=float).reshape(-1, 3)
+        indices = np.array(info.indices, dtype=float).reshape(-1, 3)
+        normals = np.array(info.normals, dtype=float).reshape(-1, 3)
+        colors = np.array(info.colors, dtype=float)
+        texture = np.array(info.texture, dtype=np.uint8).reshape(
+            info.textureRes[1], info.textureRes[0], 4)
+        textureCoords = np.array(info.textureCoords, dtype=float).reshape(
+            -1, 2)
+
+        res = SShapeVizInfo(
+            vertices=vertices,
+            indices=indices,
+            normals=normals,
+            shading_angle=info.shadingAngle,
+            colors=colors,
+            texture=texture,
+            texture_id=info.textureId,
+            texture_coords=textureCoords,
+            texture_apply_mode=info.textureApplyMode,
+            texture_options=info.textureOptions,
+        )
+        return res
+
 
 object_type_to_class[ObjectType.SHAPE] = Shape

tests/assets/test_scene.ttt

@@ -85,6 +85,34 @@ def test_set_texture(self):
         self.assertEqual(texture.get_texture_id(),
                          self.dynamic_cube.get_texture().get_texture_id())
 
+    def test_get_shape_viz(self):
+        visual = Shape('cracker_box_visual')
+        info = visual.get_shape_viz(index=0)
+        self.assertIsInstance(info.vertices, np.ndarray)
+        self.assertEqual(info.vertices.shape[1], 3)
+        self.assertIsInstance(info.indices, np.ndarray)
+        self.assertEqual(info.indices.shape[1], 3)
+        self.assertIsInstance(info.normals, np.ndarray)
+        self.assertEqual(info.normals.shape[1], 3)
+        self.assertIsInstance(info.shading_angle, float)
+        self.assertIsInstance(info.colors, np.ndarray)
+        self.assertTupleEqual(info.colors.shape, (9,))
+        self.assertIsInstance(info.texture, np.ndarray)
+        self.assertTupleEqual(info.texture.shape, (512, 512, 4))
+        self.assertIsInstance(info.texture_id, int)
+        self.assertIsInstance(info.texture_coords, np.ndarray)
+        self.assertEqual(info.texture_coords.shape[1], 2)
+        self.assertIsInstance(info.texture_apply_mode, int)
+        self.assertIsInstance(info.texture_options, int)
+
+    def test_apply_texture(self):
+        visual = Shape('cracker_box_visual')
+        info = visual.get_shape_viz(index=0)
+        self.assertNotEqual(info.texture_coords.size, 0)
+        self.assertNotEqual(info.texture.size, 0)
+        texture = info.texture[:, :, [2, 1, 0, 3]]  # rgba -> bgra
+        visual.apply_texture(info.texture_coords, texture, is_rgba=True)
+
 
 if __name__ == '__main__':
     unittest.main()