Scene

  1# coding: utf-8
  2import json
  3from Landscape import Landscape
  4from Sensor import SensorOrthographic, SensorPerspective, SensorFisheye, SensorPhotonTracing, SensorLiDAR
  5from Illumination import Illumination
  6from Observation import ObservationOrthographic, ObservationPerspective, ObservationPhotonTracing, ObservationFisheye
  7from AdvancedParams import AdvancedParams
  8from Element import Element
  9from typing import Union
 10
 11
 12class Scene(Element):
 13    """
 14    The Scene class that represents the virtual scene, containing landscape, illumination,
 15    observation, sensor, and advanced parameters
 16    """
 17
 18    def __init__(self, sim=None):
 19        super().__init__()
 20        self.__sensor = SensorOrthographic()
 21        # self.__lidarSensor = None
 22        self.__landscape = Landscape()
 23        self.__illumination = Illumination()
 24        self.__observation = ObservationOrthographic()
 25        self.__advanced_params = AdvancedParams()
 26        self.set_sim(sim)
 27
 28    def set_sensor(self, sensor: Union[SensorOrthographic, SensorPerspective, SensorFisheye, SensorPhotonTracing, SensorLiDAR]):
 29        """
 30        Set the sensor for simulation
 31        :param sensor: Sensor of different types
 32        :return:
 33        """
 34        self.__sensor = sensor
 35        self.__sensor.set_sim(self.get_sim())
 36        if isinstance(self.__sensor, SensorLiDAR):
 37            self.__sensor.get_scanning_device().set_sim(self.get_sim())
 38        # correct atmosphere skl according to number of bands
 39        new_len = len(self.__sensor.get_spectral_bands().split(","))
 40        ill = self.get_sim().get_scene().get_illumination()
 41        ats_skl = ill.get_ats_percentage()
 42        arr = ats_skl.split(",")
 43        old_len = len(arr)
 44        if new_len >= old_len:
 45            for i in range(0, new_len - old_len):
 46                arr.append("0.0")
 47        else:
 48            arr = arr[0:new_len]
 49        ill.set_ats_percentage(','.join(arr))
 50
 51        # compute bounding box when virtual plane is enabled
 52        if self.__sensor.get_virtualPlane() is not None:
 53            self.get_sim().prepare_for_ui()
 54
 55    def get_sensor(self):
 56        """
 57        Return the current sensor
 58        :return:
 59        """
 60        return self.__sensor
 61
 62    def with_lidar_sensor(self):
 63        """
 64        Whether the scene is configured with a LiDAR sensor
 65        :return:
 66        """
 67        if isinstance(self.__sensor, SensorLiDAR):
 68            return True
 69        else:
 70            return False
 71
 72    def set_landscape(self, landscape: Landscape):
 73        """
 74        Set the landscape for the scene
 75        :param landscape:
 76        :return:
 77        """
 78        self.__landscape = landscape
 79        self.__landscape.set_sim(self.get_sim())
 80
 81    def get_landscape(self):
 82        """
 83        Get the landscape
 84        :return:
 85        """
 86        return self.__landscape
 87
 88    def set_illumination(self, illumination: Illumination):
 89        """
 90        Set the illumination for the scene
 91        :param illumination:
 92        :return:
 93        """
 94        self.__illumination = illumination
 95        self.__illumination.set_sim(self.get_sim())
 96
 97    def get_illumination(self):
 98        """
 99        Get the current illumination
100        :return:
101        """
102        return self.__illumination
103
104    def set_observation(self, observation: Union[ObservationOrthographic, ObservationPerspective, ObservationPhotonTracing, ObservationFisheye]):
105        """
106        Set observation
107        :param observation:
108        :return:
109        """
110        self.__observation = observation
111        self.__observation.set_sim(self.get_sim())
112
113    def get_observation(self):
114        """
115        Get the observation
116        :return:
117        """
118        return self.__observation
119
120    def set_advanced_params(self, advanced_params: AdvancedParams):
121        """
122        Set the advanced parameter
123        :param advanced_params:
124        :return:
125        """
126        self.__advanced_params = advanced_params
127
128    def get_advanced_params(self):
129        """
130        Get the advanced parameter
131        :return:
132        """
133        return self.__advanced_params
134
135    def to_json_object(self, sim):
136        """
137        Save scene to json string
138        :param sim: the simulation
139        :return:
140        """
141        json_object = {"Advanced": self.__advanced_params.to_json_object(),
142                       "illumination": self.__illumination.to_json_object(),
143                       "observation": self.__observation.to_json_object(),
144                       "sensor": self.__sensor.to_json_object(),
145                       "scene": self.__landscape.to_json_object(sim, self.__sensor)}
146        return json_object
147
148    def write_scene(self, json_file_path):
149        """
150        Write the scene to file
151        :param json_file_path:
152        :return:
153        """
154        f_out = open(json_file_path, "w")
155        json.dump(self.to_json_object(self.get_sim()), f_out, indent=2)
156        f_out.close()