added Light class. (#287)

* added Light class.

* reverted test_scene.ttt back to version 4.1 instead of 4.2.

* fixed failing test test_get_objects_in_tree.

* removed warnings assertion from test_get_objects_in_tree.

Author: djl11

pyrep/backend/sim.py

@@ -1474,6 +1474,21 @@ def simAddForce(shapeHandle, position, force):
 
 def simAddForceAndTorque(shapeHandle, force, torque):
     ret = lib.simAddForceAndTorque(shapeHandle,
-                          ffi.NULL if force is None else force,
-                          ffi.NULL if torque is None else torque)
+                                   ffi.NULL if force is None else force,
+                                   ffi.NULL if torque is None else torque)
     _check_return(ret)
+
+
+def simSetLightParameters(shapeHandle, state, diffusePart=None, specularPart=None):
+    ret = lib.simSetLightParameters(shapeHandle, state, ffi.NULL,
+                                    ffi.NULL if diffusePart is None else diffusePart,
+                                    ffi.NULL if specularPart is None else specularPart)
+    _check_return(ret)
+
+
+def simGetLightParameters(shapeHandle):
+    diffusePart = ffi.new('float[3]')
+    specularPart = ffi.new('float[3]')
+    ret = lib.simGetLightParameters(shapeHandle, ffi.NULL, diffusePart, specularPart)
+    _check_return(ret)
+    return ret, list(diffusePart), list(specularPart)

pyrep/objects/light.py

@@ -0,0 +1,125 @@
+import warnings
+import numpy as np
+from typing import Union
+from pyrep.backend import sim
+from pyrep.const import ObjectType
+from pyrep.objects.object import Object, object_type_to_class
+
+
+class Light(Object):
+    """A light.
+    """
+
+    def __init__(self, name_or_handle: Union[str, int]):
+        super().__init__(name_or_handle)
+
+    def _get_requested_type(self) -> ObjectType:
+        return ObjectType.LIGHT
+
+    # On and Off
+
+    def turn_on(self):
+        """ Turn the light on.
+        """
+        sim.simSetLightParameters(self._handle, True)
+
+    def turn_off(self):
+        """ Turn the light off.
+        """
+        sim.simSetLightParameters(self._handle, False)
+
+    def is_on(self):
+        """ Determines whether the light is on.
+        return: Boolean
+        """
+        return sim.simGetLightParameters(self._handle)[0]
+
+    def is_off(self):
+        """ Determines whether the light is off.
+        return: Boolean
+        """
+        return not sim.simGetLightParameters(self._handle)[0]
+
+    # Get and Set Color
+
+    def get_diffuse(self):
+        """ Get the diffuse colors of the light.
+        return: 3-vector np.array of diffuse colors
+        """
+        return np.asarray(sim.simGetLightParameters(self._handle)[1])
+
+    def set_diffuse(self, diffuse):
+        """ Set the diffuse colors of the light.
+        """
+        sim.simSetLightParameters(self._handle, self.is_on(), list(diffuse))
+
+    def get_specular(self):
+        """ Get the specular colors of the light.
+        return: 3-vector np.array of specular colors
+        """
+        return np.asarray(sim.simGetLightParameters(self._handle)[2])
+
+    def set_specular(self, specular):
+        """ Set the specular colors of the light.
+        """
+        sim.simSetLightParameters(self._handle, self.is_on(), specularPart=list(specular))
+
+    # Intensity Properties
+
+    def get_intensity_properties(self):
+        """ Gets light intensity properties.
+
+        :return: The light intensity properties cast_shadows, spot_exponent, spot_cutoff, const_atten_factor,
+        linear_atten_factor, quad_atten_factor
+        """
+        cast_shadows = sim.simGetObjectInt32Parameter(self._handle, sim.sim_lightintparam_pov_casts_shadows)
+        spot_exponent = sim.simGetObjectFloatParameter(self._handle, sim.sim_lightfloatparam_spot_exponent)
+        spot_cutoff = sim.simGetObjectFloatParameter(self._handle, sim.sim_lightfloatparam_spot_cutoff)
+        const_atten_factor = sim.simGetObjectFloatParameter(self._handle, sim.sim_lightfloatparam_const_attenuation)
+        linear_atten_factor = sim.simGetObjectFloatParameter(self._handle, sim.sim_lightfloatparam_lin_attenuation)
+        quad_atten_factor = sim.simGetObjectFloatParameter(self._handle, sim.sim_lightfloatparam_quad_attenuation)
+        return bool(cast_shadows), spot_exponent, spot_cutoff, const_atten_factor, linear_atten_factor,\
+               quad_atten_factor
+
+    def set_intensity_properties(self, cast_shadows=None, spot_exponent=None, spot_cutoff=None, const_atten_factor=None,
+                                 linear_atten_factor=None, quad_atten_factor=None):
+        """ Set light intensity properties.
+
+        :param cast_shadows: POV-Ray light casts shadows
+        :param spot_exponent: light spot exponent
+        :param spot_cutoff: light spot cutoff
+        :param const_atten_factor: light constant attenuation factor, currently not supported
+        :param linear_atten_factor: light linear attenuation factor, currently not supported
+        :param quad_atten_factor: light quadratic attenuation factor, currently not supported
+        """
+        if cast_shadows is not None:
+            sim.simSetObjectInt32Parameter(
+                self._handle, sim.sim_lightintparam_pov_casts_shadows, int(cast_shadows))
+        if spot_exponent is not None:
+            if spot_exponent % 1 != 0:
+                warnings.warn('spot exponent must be an integer, rounding input of {} to {}'.format(
+                    spot_exponent, round(spot_exponent)))
+            sim.simSetObjectFloatParameter(
+                self._handle, sim.sim_lightfloatparam_spot_exponent, float(round(spot_exponent)))
+        if spot_cutoff is not None:
+            spot_cutoff = float(spot_cutoff)
+            if spot_cutoff > np.pi/2:
+                warnings.warn('Tried to set spot_cutoff to {}, but the maximum allowed value is pi/2,'
+                              'therefore setting to pi/2'.format(spot_cutoff))
+            sim.simSetObjectFloatParameter(
+                self._handle, sim.sim_lightfloatparam_spot_cutoff, float(spot_cutoff))
+        if const_atten_factor is not None:
+            raise Exception('CoppeliaSim currently does not support setting attenuation factors')
+            # sim.simSetObjectFloatParameter(
+            #    self._handle, sim.sim_lightfloatparam_const_attenuation, float(const_atten_factor))
+        if linear_atten_factor is not None:
+            raise Exception('CoppeliaSim currently does not support setting attenuation factors')
+            # sim.simSetObjectFloatParameter(
+            #    self._handle, sim.sim_lightfloatparam_lin_attenuation, float(linear_atten_factor))
+        if quad_atten_factor is not None:
+            raise Exception('CoppeliaSim currently does not support setting attenuation factors')
+            # sim.simSetObjectFloatParameter(
+            #    self._handle, sim.sim_lightfloatparam_quad_attenuation, float(quad_atten_factor))
+
+
+object_type_to_class[ObjectType.LIGHT] = Light

pyrep/objects/object.py

@@ -661,7 +661,6 @@ def _get_objects_in_tree(root_object=None, object_type=ObjectType.ALL,
             try:
                 objects.append(Object.get_object(handle))
             except KeyError:
-                # e.g., CAMERA and LIGHT are not officially supported
                 name = Object.get_object_name(handle)
                 type = Object.get_object_type(name)
                 warnings.warn(

tests/assets/test_scene.ttt

@@ -0,0 +1,109 @@
+import unittest
+import numpy as np
+from tests.core import TestCore
+from pyrep.objects.light import Light
+
+
+class TestLights(TestCore):
+
+    def setUp(self):
+        super().setUp()
+        [self.pyrep.step() for _ in range(10)]
+        self.spot_light = Light('spot_light')
+        self.omni_light = Light('omni_light')
+        self.directed_light = Light('directed_light')
+        self.lights = [self.spot_light, self.omni_light, self.directed_light]
+        self.light_types = [1, 2, 3]
+
+    # turn on and off
+
+    def test_turn_on_and_off(self):
+        for light in self.lights:
+            light.turn_on()
+            self.assertTrue(light.is_on())
+            light.turn_off()
+            self.assertTrue(light.is_off())
+
+    # light color
+
+    def test_get_set_light_diffuse(self):
+        for light in self.lights:
+            orig_diffuse = light.get_diffuse()
+            new_diffuse = np.array([0.2, 0.5, 0.9])
+            light.set_diffuse(new_diffuse)
+            self.assertTrue(np.allclose(light.get_diffuse(), new_diffuse))
+            light.set_diffuse(orig_diffuse)
+            self.assertTrue(np.allclose(light.get_diffuse(), orig_diffuse))
+
+    def test_get_set_light_specular(self):
+        for light in self.lights:
+            orig_specular = light.get_specular()
+            new_specular = np.array([0.2, 0.5, 0.9])
+            light.set_specular(new_specular)
+            self.assertTrue(np.allclose(light.get_specular(), new_specular))
+            light.set_specular(orig_specular)
+            self.assertTrue(np.allclose(light.get_specular(), orig_specular))
+
+    # light intensity properties
+
+    def test_get_set_cast_shadows(self):
+        for light in self.lights:
+            orig = light.get_intensity_properties()[0]
+            new = not orig
+            light.set_intensity_properties(cast_shadows=new)
+            self.assertTrue(light.get_intensity_properties()[0] is new)
+            light.set_intensity_properties(cast_shadows=orig)
+            self.assertTrue(np.allclose(light.get_intensity_properties()[0], orig))
+
+    def test_get_set_spot_exponent(self):
+        for light in self.lights:
+            orig = light.get_intensity_properties()[1]
+            new = orig + 2
+            light.set_intensity_properties(spot_exponent=new)
+            self.assertEqual(light.get_intensity_properties()[1], new)
+            light.set_intensity_properties(spot_exponent=orig)
+            self.assertEqual(light.get_intensity_properties()[1], orig)
+
+    def test_get_set_spot_cutoff(self):
+        for light in self.lights:
+            orig = light.get_intensity_properties()[2]
+            new = orig - 0.5
+            light.set_intensity_properties(spot_cutoff=new)
+            self.assertEqual(light.get_intensity_properties()[2], new)
+            light.set_intensity_properties(spot_cutoff=orig)
+            self.assertEqual(light.get_intensity_properties()[2], orig)
+
+    # ToDo: re-add these tests once attenuation factor setting is supported in CoppeliaSim.
+    #  setObjectFloatParams() does not change the properties of the light even with in-scene lua code.
+    '''
+    def test_get_set_const_atten_factor(self):
+        for light in self.lights:
+            orig = light.get_intensity_properties()[3]
+            new = orig + 1.5
+            light.set_intensity_properties(const_atten_factor=new)
+            assert light.get_intensity_properties()[3] == new
+            light.set_intensity_properties(const_atten_factor=orig)
+            assert light.get_intensity_properties()[3] == orig
+
+    def test_get_set_linear_atten_factor(self):
+        for light in self.lights:
+            orig = light.get_intensity_properties()[4]
+            new = orig + 1.5
+            light.set_intensity_properties(linear_atten_factor=new)
+            assert light.get_intensity_properties()[4] == new
+            light.set_intensity_properties(linear_atten_factor=orig)
+            assert light.get_intensity_properties()[4] == orig
+
+    def test_get_set_quad_atten_factor(self):
+        for light in self.lights:
+            orig = light.get_intensity_properties()[5]
+            new = orig + 1.5
+            light.set_intensity_properties(quad_atten_factor=new)
+            assert light.get_intensity_properties()[5] == new
+            light.set_intensity_properties(quad_atten_factor=orig)
+            assert light.get_intensity_properties()[5] == orig
+    '''
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_lights.py

@@ -95,10 +95,7 @@ def test_create_texture_and_get_texture(self):
                          plane.get_texture().get_texture_id())
 
     def test_get_objects_in_tree(self):
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always')
-            objects = self.pyrep.get_objects_in_tree()
-            self.assertNotEqual(len(w), 0)
+        objects = self.pyrep.get_objects_in_tree()
         for obj in objects:
             self.assertIsInstance(obj, Object)
 

tests/test_pyrep.py

@@ -1,7 +1,7 @@
 import unittest
 from tests.core import TestCore
+from pyrep.const import RenderMode
 from pyrep.sensors.spherical_vision_sensor import SphericalVisionSensor
-from pyrep.const import RenderMode, PerspectiveMode
 
 
 class TestSphericalVisionSensors(TestCore):