diff --git a/doc/changelog.d/691.miscellaneous.md b/doc/changelog.d/691.miscellaneous.md new file mode 100644 index 000000000..85b1388b6 --- /dev/null +++ b/doc/changelog.d/691.miscellaneous.md @@ -0,0 +1 @@ +Sensor diff --git a/doc/source/cheat_sheet/cheat_sheet_script.qmd b/doc/source/cheat_sheet/cheat_sheet_script.qmd index aec202615..f7e268ec9 100644 --- a/doc/source/cheat_sheet/cheat_sheet_script.qmd +++ b/doc/source/cheat_sheet/cheat_sheet_script.qmd @@ -212,13 +212,18 @@ from ansys.speos.core.sensor import SensorRadiance r_sensor = project.create_sensor(name='Radiance.1', feature_type=SensorRadiance) # define size dim = r_sensor.set_dimensions() -dim.set_x_start(-5).set_x_end(5).set_x_sampling(10) -dim.set_y_start(-5).set_y_end(5).set_y_sampling(10) +dim.x_start = -5 +dim.x_end = 5 +dim.x_sampling = 10 +dim.y_start = -5 +dim.y_end = 5 +dim.y_sampling = 10 # define type and Wavelength range col = r_sensor.set_type_colorimetric() wl = col.set_wavelengths_range() -wl.set_start(380).set_end(780) -wl.set_sampling(50) +wl.start = 380 +wl.end = 780 +wl.sampling = 50 # define Layer separation r_sensor.set_layer_type_source() r_sensor.commit() @@ -246,12 +251,10 @@ c_sensor.set_distortion_file_uri( 'distortion_file_path') # Choose photometric mode photo_cam = c_sensor.set_mode_photometric() -photo_cam.set_transmittance_file_uri( - 'transmittance_file_path') +photo_cam.transmittance_file_uri = 'transmittance_file_path' # Choose color mode c_mode = photo_cam.set_mode_color() -c_mode.set_blue_spectrum_file_uri( - 'blue_spectrum_path') +c_mode.blue_spectrum_file_uri = 'blue_spectrum_path' # same method for red and green spectrum c_sensor.commit() ``` diff --git a/examples/core/prism-example.py b/examples/core/prism-example.py index 081b03420..7f01d2597 100644 --- a/examples/core/prism-example.py +++ b/examples/core/prism-example.py @@ -93,14 +93,17 @@ irr_features = p.find(name=".*", name_regex=True, feature_type=SensorIrradiance) irr = irr_features[0] -irr.set_type_spectral().set_wavelengths_range().set_start(500).set_end(600).set_sampling(11) +wl = irr.set_type_spectral().set_wavelengths_range() +wl.start = 500 +wl.end = 600 +wl.sampling = 11 irr.commit() # Create and add a new sensor, e.g. 3d irradiance sensor body = p.find(name="PrismBody", name_regex=True, feature_type=Body)[0] sensor_3d = p.create_sensor(name="3d_irradiance", feature_type=Sensor3DIrradiance) -sensor_3d.set_geometries([body.geo_path]) +sensor_3d.geometries = [body.geo_path] sensor_3d.commit() sim.set_sensor_paths(["Irradiance.1:564", "3d_irradiance"]) sim.commit() diff --git a/examples/core/sensor.py b/examples/core/sensor.py index 910d22efd..4e4b822cb 100644 --- a/examples/core/sensor.py +++ b/examples/core/sensor.py @@ -99,13 +99,14 @@ def create_face(body): red_spectrum_path = str(assets_data_path / FILES / "CameraSensitivityRed.spectrum") sensor1 = p.create_sensor(name="Camera.1", feature_type=SensorCamera) -sensor1.set_distortion_file_uri(uri=distortion_file_path) +sensor1.distortion_file_uri = distortion_file_path # Choose photometric mode -sensor1.set_mode_photometric().set_transmittance_file_uri(uri=transmittance_file_path) +sensor1.set_mode_photometric().transmittance_file_uri = transmittance_file_path # Choose color mode (will imply to give spectrum file for blue, green and red) -sensor1.set_mode_photometric().set_mode_color().set_blue_spectrum_file_uri(uri=blue_spectrum_path) -sensor1.set_mode_photometric().set_mode_color().set_green_spectrum_file_uri(uri=green_spectrum_path) -sensor1.set_mode_photometric().set_mode_color().set_red_spectrum_file_uri(uri=red_spectrum_path) +mode_color = sensor1.photometric.set_mode_color() +mode_color.blue_spectrum_file_uri = blue_spectrum_path +mode_color.green_spectrum_file_uri = green_spectrum_path +mode_color.red_spectrum_file_uri = red_spectrum_path print(sensor1) # - @@ -134,17 +135,19 @@ def create_face(body): red_spectrum_path = str(assets_data_path / FILES / "CameraSensitivityRed.spectrum") sensor2 = p.create_sensor(name="Camera.2", feature_type=SensorCamera) -sensor2.set_distortion_file_uri(uri=distortion_file_path) -sensor2.set_mode_photometric().set_transmittance_file_uri(uri=transmittance_file_path) -sensor2.set_mode_photometric().set_layer_type_source() -sensor2.set_mode_photometric().set_mode_color().set_blue_spectrum_file_uri(uri=blue_spectrum_path) -sensor2.set_mode_photometric().set_mode_color().set_green_spectrum_file_uri(uri=green_spectrum_path) -sensor2.set_mode_photometric().set_mode_color().set_red_spectrum_file_uri(uri=red_spectrum_path) -sensor2.set_focal_length(5.5) -sensor2.set_height(value=6).set_width(value=6) # dimensions -sensor2.set_axis_system( - [20, 10, 40, 1, 0, 0, 0, 1, 0, 0, 0, 1] -) # camera location [Origin, Xvector, Yvector, Zvector] +sensor2.distortion_file_uri = distortion_file_path +photometric = sensor2.set_mode_photometric() +photometric.transmittance_file_uri = transmittance_file_path +photometric.set_layer_type_source() +color = photometric.set_mode_color() +color.blue_spectrum_file_uri = blue_spectrum_path +color.green_spectrum_file_uri = green_spectrum_path +color.red_spectrum_file_uri = red_spectrum_path +sensor2.focal_length = 5.5 +sensor2.height = 6 +sensor2.width = 6 # dimensions +sensor2.axis_system = [20, 10, 40, 1, 0, 0, 0, 1, 0, 0, 0, 1] +# camera location [Origin, Xvector, Yvector, Zvector] sensor2.commit() print(sensor2) @@ -172,7 +175,8 @@ def create_face(body): # If you don't, you will still only watch what is committed on the server. # modify f number and axis system -sensor1.set_f_number(value=11).set_axis_system([17, 10, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1]) +sensor1.f_number = 11 +sensor1.axis_system = [17, 10, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1] sensor1.commit() print(sensor1) @@ -217,7 +221,8 @@ def create_face(body): sensor4.commit() print(sensor4) -sensor4.set_focal(value=200).set_type_spectral() +sensor4.focal = 200 +sensor4.set_type_spectral() sensor4.set_layer_type_source() sensor4.commit() print(sensor4) @@ -229,7 +234,7 @@ def create_face(body): create_helper_geometries(p) sensor5 = p.create_sensor(name="3D_Irradiance.2", feature_type=Sensor3DIrradiance) -sensor5.set_geometries([GeoRef.from_native_link("TheBodyB/TheFaceF")]) +sensor5.geometries = [GeoRef.from_native_link("TheBodyB/TheFaceF")] sensor5.commit() print(sensor5) diff --git a/examples/workflow/combine-speos.py b/examples/workflow/combine-speos.py index ad47b70a5..59a24bc98 100644 --- a/examples/workflow/combine-speos.py +++ b/examples/workflow/combine-speos.py @@ -113,18 +113,24 @@ # ### Create a sensor ssr = p.create_sensor(name="Camera.1", feature_type=SensorCamera) -ssr.set_distortion_file_uri( - uri=str(assets_data_path / "CameraInputFiles" / "CameraDistortion_190deg.OPTDistortion") -).set_mode_photometric().set_transmittance_file_uri( - uri=str(assets_data_path / "CameraInputFiles" / "CameraTransmittance.spectrum") -).set_mode_color().set_red_spectrum_file_uri( - uri=str(assets_data_path / "CameraInputFiles" / "CameraSensitivityRed.spectrum") -).set_blue_spectrum_file_uri( - uri=str(assets_data_path / "CameraInputFiles" / "CameraSensitivityBlue.spectrum") -).set_green_spectrum_file_uri( - uri=str(assets_data_path / "CameraInputFiles" / "CameraSensitivityGreen.spectrum") +ssr.distortion_file_uri = str( + assets_data_path / "CameraInputFiles" / "CameraDistortion_190deg.OPTDistortion" ) -ssr.set_axis_system([-2000, 1500, 11000, -1, 0, 0, 0, 1, 0, 0, 0, -1]) +ssr.set_mode_photometric().transmittance_file_uri = str( + assets_data_path / "CameraInputFiles" / "CameraTransmittance.spectrum" +) +color_mode = ssr.set_mode_photometric().set_mode_color() +color_mode.red_spectrum_file_uri = str( + assets_data_path / "CameraInputFiles" / "CameraSensitivityRed.spectrum" +) +color_mode.blue_spectrum_file_uri = str( + assets_data_path / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" +) +color_mode.green_spectrum_file_uri = str( + assets_data_path / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" +) + +ssr.axis_system = [-2000, 1500, 11000, -1, 0, 0, 0, 1, 0, 0, 0, -1] ssr.commit() # ### Create a source @@ -195,7 +201,7 @@ # Modify the camera, e.g. focal length to 10 cam1 = p.find(name="Camera.1", feature_type=SensorCamera)[0] -cam1.set_focal_length(value=10) +cam1.focal_length = 10 cam1.commit() # Re-run the simulation and review result diff --git a/src/ansys/speos/core/generic/constants.py b/src/ansys/speos/core/generic/constants.py index 19ab3d01c..734d57f13 100644 --- a/src/ansys/speos/core/generic/constants.py +++ b/src/ansys/speos/core/generic/constants.py @@ -22,7 +22,11 @@ """Collection of all constants used in pySpeos.""" +from dataclasses import dataclass, field +from enum import Enum import os +from pathlib import Path +from typing import Optional, Union DEFAULT_HOST: str = "localhost" """Default host used by Speos RPC server and client """ @@ -38,3 +42,347 @@ """Maximum message Size accepted by grpc channel, By default, 4194304. """ + +ORIGIN = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] +"""Global Origin""" + + +@dataclass +class WavelengthsRangeParameters: + """Wavelength parameters.""" + + start: int = 400 + """Wavelength start value.""" + end: int = 700 + """Wavelength end value.""" + sampling: int = 13 + """Wavelength sampling.""" + + +@dataclass +class DimensionsParameters: + """Dimension Parameters.""" + + x_start: float = -50 + """Lower bound x axis.""" + x_end: float = 50 + """Upper bound x axis.""" + x_sampling: int = 100 + """Sampling x axis.""" + y_start: float = -50 + """Lower bound y axis.""" + y_end: float = 50 + """Upper bound y axis.""" + y_sampling: int = 100 + """Sampling y axis.""" + + +class LayerTypes(str, Enum): + """Layer Separation types without parameters.""" + + none = "none" + by_source = "by_source" + by_polarization = "by_polarization" + + +class SCAFilteringTypes(str, Enum): + """Surface contribution analyser filtering types.""" + + intersected_one_time = "intersected_one_time" + last_impact = "last_impact" + + +class SequenceTypes(str, Enum): + """Sequence types to separate the sequence data.""" + + by_face = "by_face" + by_geometry = "by_geometry" + + +@dataclass +class LayerBySequenceParameters: + """Layer separation type Parameters for Sequence separation.""" + + maximum_nb_of_sequence: int = 10 + sequence_type: Union[SequenceTypes.by_face, SequenceTypes.by_geometry] = ( + SequenceTypes.by_geometry + ) + + +@dataclass +class GeometryLayerParameters: + """Geometry layer parameters.""" + + name: Optional[str] = None + geometry: Optional[list] = None + + +@dataclass +class LayerByFaceParameters: + """Layer separation type Parameters for Face separation.""" + + geometries: Optional[list[GeometryLayerParameters]] = None + sca_filtering_types: Union[ + SCAFilteringTypes.intersected_one_time, SCAFilteringTypes.last_impact + ] = SCAFilteringTypes.last_impact + + +@dataclass +class LayerByIncidenceAngleParameters: + """Layer separation type Parameters for Incidence angle separation.""" + + incidence_sampling: int = 9 + + +class PngBits(str, Enum): + """Bit resolution of create PNG image.""" + + png_08 = "png_08" + png_10 = "png_10" + png_12 = "png_12" + png_16 = "png_16" + + +class ColorBalanceModeTypes(str, Enum): + """Color Balance Mode types without parameters.""" + + none = "none" + grey_world = "grey_world" + + +@dataclass +class BalanceModeUserWhiteParameters: + """Parameters for Balance mode: User White.""" + + red_gain: float = 1.0 + """Gain value for Red.""" + green_gain: float = 1.0 + """Gain value for green.""" + blue_gain: float = 1.0 + """Gain value for blue.""" + + +@dataclass +class BalanceModeDisplayPrimariesParameters: + """Parameters for Balance mode: Display primaries.""" + + red_display_file_uri: Union[str, Path] = "" + """Spectrum path of the red display spectrum.""" + green_display_file_uri: Union[str, Path] = "" + """Spectrum path of the green display spectrum.""" + blue_display_file_uri: Union[str, Path] = "" + """Spectrum path of the red display spectrum.""" + + +@dataclass +class ColorParameters: + """Color mode Camera Parameter.""" + + balance_mode: Union[ + ColorBalanceModeTypes.none, + ColorBalanceModeTypes.grey_world, + BalanceModeUserWhiteParameters, + BalanceModeDisplayPrimariesParameters, + ] = ColorBalanceModeTypes.none + """Camera Balance mode.""" + red_spectrum_file_uri: Union[str, Path] = "" + """Path to sensitivity spectrum of red Channel.""" + green_spectrum_file_uri: Union[str, Path] = "" + """Path to sensitivity spectrum of green Channel.""" + blue_spectrum_file_uri: Union[str, Path] = "" + """Path to sensitivity spectrum of blue Channel.""" + + +@dataclass +class MonoChromaticParameters: + """Monochromatic Camera Parameters.""" + + sensitivity: Union[str, Path] = "" + """Path to Sensitivity Spectrum.""" + + +@dataclass +class PhotometricCameraParameters: + """Photometric Parameters for Camera.""" + + color_mode: Union[MonoChromaticParameters, ColorParameters] = field( + default_factory=ColorParameters + ) + """Color mode of the Camera Sensor.""" + layer_type: Union[LayerTypes.none, LayerTypes.by_source] = LayerTypes.none + """Layer separation parameter.""" + png_bits: PngBits = PngBits.png_16 + """PNG bit resolution of the Camera Sensor.""" + wavelength_range: WavelengthsRangeParameters = field(default_factory=WavelengthsRangeParameters) + """Wavelength range of the Camera Sensor.""" + acquisition_integration_time: float = 0.01 + """Integration Time value for the Camera Sensor.""" + acquisition_lag_time: float = 0 + """Acquisition lag time for the Camera Sensor.""" + gamma_correction: float = 2.2 + """Gamma correction Value for the Camera Sensor.""" + transmittance_file_uri: str = "" + """Transmittance spectrum location""" + + +@dataclass +class CameraSensorParameters: + """Camera Sensor Parameters.""" + + sensor_type_parameters: Union[None, PhotometricCameraParameters] = field( + default_factory=PhotometricCameraParameters + ) + """Camera sensor type None means geometric sensor""" + axis_system: list[float] = field(default_factory=lambda: ORIGIN) + """Location of the sensor Origin""" + focal_length: float = 5 + """Default focal length of the Camera Sensor.""" + imager_distance: float = 10 + """Default imager distance of the camera sensor.""" + f_number: float = 20 + """Default f number of the camera sensor.""" + horz_pixel: int = 640 + """Default pixel number in horizontal direction.""" + vert_pixel: int = 480 + """Default pixel number in vertical direction.""" + width: float = 5.0 + """Default width of the camera chip.""" + height: float = 5.0 + """Default height of the camera chip.""" + trajectory_fil_uri: Union[str, Path] = "" + """Trajectory file information.""" + lxp_path_number: Optional[int] = None + + +@dataclass +class ColorimetricParameters: + """Colorimetric settings of the Sensor.""" + + wavelength_range: WavelengthsRangeParameters = field(default_factory=WavelengthsRangeParameters) + """Wavelength range of the Sensor.""" + + +@dataclass +class SpectralParameters: + """Colorimetric settings of the Sensor.""" + + wavelength_range: WavelengthsRangeParameters = field(default_factory=WavelengthsRangeParameters) + """Wavelength range of the Sensor.""" + + +class IntegrationTypes(str, Enum): + """Integration types without parameters.""" + + planar = "planar" + radial = "radial" + hemispherical = "hemispherical" + cylindrical = "cylindrical" + semi_cylindrical = "semi_cylindrical" + + +class RayfileTypes(str, Enum): + """Rayfile types without parameters.""" + + none = "none" + classic = "classic" + polarization = "polarization" + tm25 = "tm25" + tm25_no_polarization = "tm25_no_polarization" + + +class SensorTypes(str, Enum): + """Sensor types without parameters.""" + + photometric = "photometric" + radiometric = "radiometric" + + +@dataclass +class MeasuresParameters: + """Measurements for 3d Irradiance Sensor.""" + + reflection: bool = True + """Reflection measure activation state.""" + transmission: bool = True + """Transmission measure activation state.""" + absorption: bool = True + """Ansorption measure activation state.""" + + +@dataclass +class IrradianceSensorParameters: + """Irradiance Sensor Parameters.""" + + dimensions: DimensionsParameters = field(default_factory=DimensionsParameters) + """Dimensions of the sensor.""" + axis_system: list[float] = field(default_factory=lambda: ORIGIN) + """Position of the sensor.""" + sensor_type: Union[ + SensorTypes.photometric, ColorimetricParameters, SpectralParameters, SensorTypes.radiometric + ] = SensorTypes.photometric + """Type of the sensor.""" + integration_type: IntegrationTypes = IntegrationTypes.planar + """Integration type of the sensor.""" + integration_direction: Optional[list[float]] = None + """Integration direction of the sensor.""" + rayfile_type: Union[RayfileTypes] = RayfileTypes.none + """Type of rayfile stored by the sensor.""" + layer_type: Union[ + LayerTypes, + LayerByFaceParameters, + LayerBySequenceParameters, + LayerByIncidenceAngleParameters, + ] = LayerTypes.none + """Type of layer separation used by the sensor.""" + outpath_face_geometry: Optional[list] = None + """Outpath face used by the sensor""" + + +@dataclass +class RadianceSensorParameters: + """Radiance Sensor Constants.""" + + dimensions: DimensionsParameters = field(default_factory=DimensionsParameters) + """Dimensions of the sensor.""" + axis_system: list[float] = field(default_factory=lambda: ORIGIN) + """Position of the sensor.""" + sensor_type: Union[ + SensorTypes.photometric, ColorimetricParameters, SpectralParameters, SensorTypes.radiometric + ] = SensorTypes.photometric + """Type of the sensor.""" + focal_length: float = 250.0 + """Distance between observer point and sensor and axis-system, + will be ignored if observer is used.""" + integration_angle: float = 5 + """Integration angle.""" + observer: Union[None, list[float]] = None + """The position of the observer point.""" + layer_type: Union[ + LayerTypes.none, + LayerTypes.by_source, + LayerByFaceParameters, + LayerBySequenceParameters, + ] = LayerTypes.none + """Type of layer separation used by the sensor.""" + + +@dataclass +class Irradiance3DSensorParameters: + """Parameters class for 3D Irradiance Sensor.""" + + sensor_type: Union[SensorTypes.photometric, ColorimetricParameters, SensorTypes.radiometric] = ( + SensorTypes.photometric + ) + """Type of the sensor.""" + measures: MeasuresParameters = field(default_factory=MeasuresParameters) + """Measurement activation state.""" + integration_type: Union[IntegrationTypes.planar, IntegrationTypes.radial] = ( + IntegrationTypes.planar + ) + """Integration type.""" + rayfile_type: Union[RayfileTypes] = RayfileTypes.none + """Rayfile type stored.""" + layer_type: Union[LayerTypes.none, LayerTypes.by_source] = LayerTypes.none + """Layer separation type.""" + geometries: Optional[list] = None + """Sensor geometry.""" diff --git a/src/ansys/speos/core/project.py b/src/ansys/speos/core/project.py index b5c37fe8a..ad8f9c2e7 100644 --- a/src/ansys/speos/core/project.py +++ b/src/ansys/speos/core/project.py @@ -826,28 +826,28 @@ def _fill_features(self): project=self, name=ssr_inst.name, sensor_instance=ssr_inst, - default_values=False, + default_parameters=None, ) elif ssr_inst.HasField("radiance_properties"): ssr_feat = SensorRadiance( project=self, name=ssr_inst.name, sensor_instance=ssr_inst, - default_values=False, + default_parameters=None, ) elif ssr_inst.HasField("camera_properties"): ssr_feat = SensorCamera( project=self, name=ssr_inst.name, sensor_instance=ssr_inst, - default_values=False, + default_parameters=None, ) elif ssr_inst.HasField("irradiance_3d_properties"): ssr_feat = Sensor3DIrradiance( project=self, name=ssr_inst.name, sensor_instance=ssr_inst, - default_values=False, + default_parameters=None, ) if ssr_feat is not None: self._features.append(ssr_feat) diff --git a/src/ansys/speos/core/sensor.py b/src/ansys/speos/core/sensor.py index 67536e6fc..ee8a62205 100644 --- a/src/ansys/speos/core/sensor.py +++ b/src/ansys/speos/core/sensor.py @@ -25,7 +25,8 @@ from __future__ import annotations from difflib import SequenceMatcher -from typing import List, Mapping, Optional, Union +from pathlib import Path +from typing import Mapping, Optional, Union import uuid import warnings @@ -34,11 +35,33 @@ import numpy as np import ansys.speos.core as core +import ansys.speos.core.body as body +import ansys.speos.core.face as face +from ansys.speos.core.generic.constants import ( + BalanceModeDisplayPrimariesParameters, + BalanceModeUserWhiteParameters, + CameraSensorParameters, + ColorimetricParameters, + ColorParameters, + DimensionsParameters, + Irradiance3DSensorParameters, + IrradianceSensorParameters, + LayerByFaceParameters, + LayerByIncidenceAngleParameters, + LayerBySequenceParameters, + MeasuresParameters, + MonoChromaticParameters, + PhotometricCameraParameters, + RadianceSensorParameters, + SpectralParameters, + WavelengthsRangeParameters, +) import ansys.speos.core.generic.general_methods as general_methods from ansys.speos.core.generic.visualization_methods import _VisualData, local2absolute from ansys.speos.core.geo_ref import GeoRef from ansys.speos.core.kernel.scene import ProtoScene from ansys.speos.core.kernel.sensor_template import ProtoSensorTemplate +import ansys.speos.core.part as part import ansys.speos.core.project as project import ansys.speos.core.proto_message_utils as proto_message_utils @@ -107,8 +130,14 @@ def __init__( self.reset() @property - def lxp_path_number(self): - """Number of LXP rays simulated for the Sensor.""" + def lxp_path_number(self) -> Union[None, int]: + """Number of LXP rays simulated for the Sensor. + + Returns + ------- + int + Number of Rays stored in the lpf file for this Sensor + """ if self._sensor_instance.HasField("lxp_properties"): return self._sensor_instance.lxp_properties.nb_max_paths return None @@ -150,7 +179,7 @@ class WavelengthsRange: def __init__( self, wavelengths_range: Union[common_pb2.WavelengthsRange, sensor_pb2.TypeColorimetric], - default_values: bool = True, + default_parameters: Union[None, WavelengthsRangeParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -158,68 +187,98 @@ def __init__( raise RuntimeError(msg) self._wavelengths_range = wavelengths_range - if default_values: + if default_parameters: # Default values - self.set_start().set_end().set_sampling() + self.start = default_parameters.start + self.end = default_parameters.end + self.sampling = default_parameters.sampling + + @property + def start(self) -> float: + """Minimum wavelength of the range. - def set_start(self, value: float = 400) -> BaseSensor.WavelengthsRange: - """Set the minimum wavelength of the range. + By default, ``400``. + + Returns + ------- + float + Lower Bound of the wavelength range. + """ + if isinstance(self._wavelengths_range, common_pb2.WavelengthsRange): + return self._wavelengths_range.w_start + else: + return self._wavelengths_range.wavelength_start + + @start.setter + def start(self, value: float): + """Minimum wavelength of the range. Parameters ---------- value : float Minimum wavelength (nm). - By default, ``400``. + """ + if isinstance(self._wavelengths_range, common_pb2.WavelengthsRange): + self._wavelengths_range.w_start = value + else: + self._wavelengths_range.wavelength_start = value + + @property + def end(self) -> float: + """Maximum wavelength of the range. + + By default, ``700``. Returns ------- - ansys.speos.core.sensor.BaseSensor.WavelengthsRange - WavelengthsRange. + float + Upper Bound of the wavelength range. """ if isinstance(self._wavelengths_range, common_pb2.WavelengthsRange): - self._wavelengths_range.w_start = value + return self._wavelengths_range.w_end else: - self._wavelengths_range.wavelength_start = value - return self + return self._wavelengths_range.wavelength_end - def set_end(self, value: float = 700) -> BaseSensor.WavelengthsRange: - """Set the maximum wavelength of the range. + @end.setter + def end(self, value: float): + """Maximum wavelength of the range. Parameters ---------- value : float Maximum wavelength (nm). - By default, ``700``. - - Returns - ------- - ansys.speos.core.sensor.BaseSensor.WavelengthsRange - WavelengthsRange. """ if isinstance(self._wavelengths_range, common_pb2.WavelengthsRange): self._wavelengths_range.w_end = value else: self._wavelengths_range.wavelength_end = value - return self - def set_sampling(self, value: int = 13) -> BaseSensor.WavelengthsRange: - """Set the sampling of wavelengths range. + @property + def sampling(self) -> int: + """Wavelength sampling of between start and end value. + + By default, ``13``. + + Returns + ------- + int + Number of Samples used to split the wavelength range. + """ + if isinstance(self._wavelengths_range, common_pb2.WavelengthsRange): + return self._wavelengths_range.w_sampling + + @sampling.setter + def sampling(self, value): + """Wavelength sampling of between start and end value. Parameters ---------- value : int Number of wavelengths to be taken into account between the minimum and maximum wavelengths range. - By default, ``13``. - - Returns - ------- - ansys.speos.core.sensor.BaseSensor.WavelengthsRange - WavelengthsRange. """ if isinstance(self._wavelengths_range, common_pb2.WavelengthsRange): self._wavelengths_range.w_sampling = value - return self class Dimensions: """Dimensions of the sensor. @@ -244,7 +303,7 @@ class Dimensions: def __init__( self, sensor_dimensions: common_pb2.SensorDimensions, - default_values: bool = True, + default_parameters: Union[None, DimensionsParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -252,111 +311,158 @@ def __init__( raise RuntimeError(msg) self._sensor_dimensions = sensor_dimensions - if default_values: + if default_parameters: # Default values - self.set_x_start().set_x_end().set_x_sampling().set_y_start().set_y_end().set_y_sampling() + self.x_start = default_parameters.x_start + self.y_start = default_parameters.y_start + self.x_end = default_parameters.x_end + self.y_end = default_parameters.y_end + self.x_sampling = default_parameters.x_sampling + self.y_sampling = default_parameters.y_sampling + + @property + def x_start(self) -> float: + """Minimum value on x axis. - def set_x_start(self, value: float = -50) -> BaseSensor.Dimensions: - """Set the minimum value on x axis. + By default, ``-50``. + + Returns + ------- + float + minimum value in x axis + """ + return self._sensor_dimensions.x_start + + @x_start.setter + def x_start(self, value: float): + """Minimum value on x axis. Parameters ---------- value : float Minimum value on x axis (mm). - By default, ``-50``. + """ + self._sensor_dimensions.x_start = value + + @property + def x_end(self) -> float: + """Maximum value on x axis. + + By default, ``50``. Returns ------- - ansys.speos.core.sensor.BaseSensor.Dimensions - Dimensions. + float + maximum value on x axis. """ - self._sensor_dimensions.x_start = value - return self + return self._sensor_dimensions.x_end - def set_x_end(self, value: float = 50) -> BaseSensor.Dimensions: - """Set the maximum value on x axis. + @x_end.setter + def x_end(self, value: float): + """Maximum value on x axis. Parameters ---------- value : float Maximum value on x axis (mm). - By default, ``50``. + """ + self._sensor_dimensions.x_end = value + + @property + def x_sampling(self) -> int: + """Value of the sampling on x axis. + + By default, ``100``. Returns ------- - ansys.speos.core.sensor.BaseSensor.Dimensions - Dimensions. + float + sampling value on x axis. """ - self._sensor_dimensions.x_end = value - return self + return self._sensor_dimensions.x_sampling - def set_x_sampling(self, value: int = 100) -> BaseSensor.Dimensions: - """Set the sampling value on x axis. + @x_sampling.setter + def x_sampling(self, value: int): + """Value of the sampling on x axis. Parameters ---------- value : int The number of pixels of the XMP map on x axis. - By default, ``100``. + """ + self._sensor_dimensions.x_sampling = value + + @property + def y_start(self) -> float: + """Minimum value on y axis. + + By default, ``-50``. Returns ------- - ansys.speos.core.sensor.BaseSensor.Dimensions - Dimensions. + float + minimum value in y axis """ - self._sensor_dimensions.x_sampling = value - return self + return self._sensor_dimensions.y_start - def set_y_start(self, value: float = -50) -> BaseSensor.Dimensions: - """Set the minimum value on y axis. + @y_start.setter + def y_start(self, value: float): + """Minimum value on y axis. Parameters ---------- value : float Minimum value on y axis (mm). - By default, ``-50``. + """ + self._sensor_dimensions.y_start = value + + @property + def y_end(self) -> float: + """Maximum value on y axis. + + By default, ``50``. Returns ------- - ansys.speos.core.sensor.BaseSensor.Dimensions - Dimensions. + float + maximum value on y axis. """ - self._sensor_dimensions.y_start = value - return self + return self._sensor_dimensions.y_end - def set_y_end(self, value: float = 50) -> BaseSensor.Dimensions: - """Set the maximum value on y axis. + @y_end.setter + def y_end(self, value: float): + """Maximum value on y axis. Parameters ---------- value : float Maximum value on y axis (mm). - By default, ``50``. + """ + self._sensor_dimensions.y_end = value + + @property + def y_sampling(self) -> int: + """Value of the sampling on y axis. + + By default, ``100``. Returns ------- - ansys.speos.core.sensor.BaseSensor.Dimensions - Dimensions. + float + sampling value on y axis. """ - self._sensor_dimensions.y_end = value - return self + return self._sensor_dimensions.y_sampling - def set_y_sampling(self, value: int = 100) -> BaseSensor.Dimensions: - """Set the sampling value on y axis. + @y_sampling.setter + def y_sampling(self, value: int): + """Value of the sampling on y axis. Parameters ---------- value : int The number of pixels of the XMP map on y axis. - By default, ``100``. - - Returns - ------- - ansys.speos.core.sensor.BaseSensor.Dimensions - Dimensions. """ self._sensor_dimensions.y_sampling = value - return self class Colorimetric: """Type of sensor : Colorimetric. @@ -369,7 +475,7 @@ class Colorimetric: ---------- sensor_type_colorimetric : ansys.api.speos.sensor.v1.common_pb2.SensorTypeColorimetric SensorTypeColorimetric protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -383,7 +489,7 @@ class Colorimetric: def __init__( self, sensor_type_colorimetric: common_pb2.SensorTypeColorimetric, - default_values: bool = True, + default_parameters: Union[None, ColorimetricParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -391,16 +497,19 @@ def __init__( raise RuntimeError(msg) self._sensor_type_colorimetric = sensor_type_colorimetric - # Attribute to keep track of wavelength range object - self._wavelengths_range = BaseSensor.WavelengthsRange( - wavelengths_range=self._sensor_type_colorimetric.wavelengths_range, - default_values=default_values, - stable_ctr=stable_ctr, - ) - - if default_values: + if default_parameters: # Default values - self.set_wavelengths_range() + self._wavelengths_range = BaseSensor.WavelengthsRange( + wavelengths_range=self._sensor_type_colorimetric.wavelengths_range, + default_parameters=default_parameters.wavelength_range, + stable_ctr=stable_ctr, + ) + else: + self._wavelengths_range = BaseSensor.WavelengthsRange( + wavelengths_range=self._sensor_type_colorimetric.wavelengths_range, + default_parameters=None, + stable_ctr=stable_ctr, + ) def set_wavelengths_range(self) -> BaseSensor.WavelengthsRange: """Set the range of wavelengths. @@ -445,7 +554,7 @@ class Spectral: def __init__( self, sensor_type_spectral: common_pb2.SensorTypeSpectral, - default_values: bool = True, + default_parameters: Union[None, SpectralParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -453,16 +562,19 @@ def __init__( raise RuntimeError(msg) self._sensor_type_spectral = sensor_type_spectral - # Attribute to keep track of wavelength range object - self._wavelengths_range = BaseSensor.WavelengthsRange( - wavelengths_range=self._sensor_type_spectral.wavelengths_range, - default_values=default_values, - stable_ctr=stable_ctr, - ) - - if default_values: + if default_parameters: # Default values - self.set_wavelengths_range() + self._wavelengths_range = BaseSensor.WavelengthsRange( + wavelengths_range=self._sensor_type_spectral.wavelengths_range, + default_parameters=default_parameters.wavelength_range, + stable_ctr=stable_ctr, + ) + else: + self._wavelengths_range = BaseSensor.WavelengthsRange( + wavelengths_range=self._sensor_type_spectral.wavelengths_range, + default_parameters=None, + stable_ctr=stable_ctr, + ) def set_wavelengths_range(self) -> BaseSensor.WavelengthsRange: """Set the range of wavelengths. @@ -488,16 +600,45 @@ class FaceLayer: ---------- name : str Name of the layer. - geometries : List[ansys.speos.core.geo_ref.GeoRef] + geometries : list[ansys.speos.core.geo_ref.GeoRef] List of geometries included in this layer. """ - def __init__(self, name: str, geometries: List[GeoRef]) -> None: + def __init__(self, name: str, geometries: list[GeoRef]) -> None: self.name = name """Name of the layer""" - self.geometries = geometries - """List of geometries included in this layer.""" + self.geometry = geometries + + @property + def geometry(self): + """List of geometries included in this layer. + + Returns + ------- + list[GeoRef] + List of the Geometries contained in the FaceLayer group + """ + return self._geometry + + @geometry.setter + def geometry( + self, value: Optional[list[Union[GeoRef, body.Body, face.Face, part.Part.SubPart]]] + ): + """Set the geometry for this Face Layer group. + + Parameters + ---------- + value : Optional[list[Union[GeoRef, body.Body, face.Face, part.Part.SubPart]]] + Geometry within the Face Layer group + """ + geo_paths = [] + for gr in value: + if isinstance(gr, GeoRef): + geo_paths.append(gr) + elif isinstance(gr, (face.Face, body.Body, part.Part.SubPart)): + geo_paths.append(gr.geo_path) + self._geometry = geo_paths class LayerTypeFace: """Type of layer : Face. @@ -510,7 +651,7 @@ class LayerTypeFace: layer_type_face : \ ansys.api.speos.scene.v2.scene_pb2.Scene.SensorInstance.LayerTypeFace LayerTypeFace protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -524,7 +665,7 @@ class LayerTypeFace: def __init__( self, layer_type_face: ProtoScene.SensorInstance.LayerTypeFace, - default_values: bool = True, + default_parameters: Union[None, LayerByFaceParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -533,9 +674,16 @@ def __init__( self._layer_type_face = layer_type_face - if default_values: + if default_parameters: # Default values - self.set_sca_filtering_mode_last_impact() + match default_parameters.sca_filtering_types: + case "last_impact": + self.set_sca_filtering_mode_last_impact() + case "intersected_one_time": + self.set_sca_filtering_mode_intersected_one_time() + if default_parameters.geometries: + for item in default_parameters.geometries: + self.layers.append(BaseSensor.FaceLayer(item.name, item.geometry)) def set_sca_filtering_mode_intersected_one_time( self, @@ -567,31 +715,40 @@ def set_sca_filtering_mode_last_impact( ) return self - def set_layers(self, values: List[BaseSensor.FaceLayer]) -> BaseSensor.LayerTypeFace: + @property + def layers(self) -> list[BaseSensor.FaceLayer]: + """List of Face layer Groups of this sensor. + + Returns + ------- + list[ansys.speos.core.sensor.BaseSensor.FaceLayer] + list of FaceLayer Classes + """ + layer_data = [] + for layer in self._layer_type_face.layers: + layer_data.append(BaseSensor.FaceLayer(layer.name, layer.geometries)) + return layer_data + + @layers.setter + def layers(self, values: list[BaseSensor.FaceLayer]): """Set the layers. Parameters ---------- - values : List[ansys.speos.core.sensor.BaseSensor.FaceLayer] + values : list[ansys.speos.core.sensor.BaseSensor.FaceLayer] List of layers - - Returns - ------- - ansys.speos.core.sensor.BaseSensor.LayerTypeFace - LayerTypeFace. """ my_list = [ ProtoScene.SensorInstance.LayerTypeFace.Layer( name=layer.name, geometries=ProtoScene.GeoPaths( - geo_paths=[gr.to_native_link() for gr in layer.geometries] + geo_paths=[gr.to_native_link() for gr in layer.geometry] ), ) for layer in values ] self._layer_type_face.ClearField("layers") self._layer_type_face.layers.extend(my_list) - return self class LayerTypeSequence: """Type of layer : Sequence. @@ -604,7 +761,7 @@ class LayerTypeSequence: layer_type_sequence : \ ansys.api.speos.scene.v2.scene_pb2.Scene.SensorInstance.LayerTypeSequence LayerTypeSequence protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -618,7 +775,7 @@ class LayerTypeSequence: def __init__( self, layer_type_sequence: ProtoScene.SensorInstance.LayerTypeSequence, - default_values: bool = True, + default_parameters: Union[None, LayerBySequenceParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -627,26 +784,38 @@ def __init__( self._layer_type_sequence = layer_type_sequence - if default_values: + if default_parameters: # Default values - self.set_maximum_nb_of_sequence().set_define_sequence_per_geometries() + self.maximum_nb_of_sequence = default_parameters.maximum_nb_of_sequence + match default_parameters.sequence_type: + case "by_face": + self.set_define_sequence_per_faces() + case "by_geometry": + self.set_define_sequence_per_geometries() + + @property + def maximum_nb_of_sequence(self) -> int: + """Value of the maximum number of sequences. - def set_maximum_nb_of_sequence(self, value: int = 10) -> BaseSensor.LayerTypeSequence: - """Set the maximum number of sequences. + By default, ``10``. + + Returns + ------- + int + maximum number of sequences. + """ + return self._layer_type_sequence.maximum_nb_of_sequence + + @maximum_nb_of_sequence.setter + def maximum_nb_of_sequence(self, value: int): + """Value of the maximum number of sequences. Parameters ---------- value : int Maximum number of sequences. - By default, ``10``. - - Returns - ------- - ansys.speos.core.sensor.BaseSensor.LayerTypeSequence - LayerTypeSequence. """ self._layer_type_sequence.maximum_nb_of_sequence = value - return self def set_define_sequence_per_geometries( self, @@ -687,7 +856,7 @@ class LayerTypeIncidenceAngle: layer_type_incidence_angle : \ ansys.api.speos.scene.v2.scene_pb2.Scene.SensorInstance.LayerTypeIncidenceAngle LayerTypeIncidenceAngle protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -701,7 +870,7 @@ class LayerTypeIncidenceAngle: def __init__( self, layer_type_incidence_angle: ProtoScene.SensorInstance.LayerTypeIncidenceAngle, - default_values: bool = True, + default_parameters: Union[None, LayerByIncidenceAngleParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -710,26 +879,34 @@ def __init__( self._layer_type_incidence_angle = layer_type_incidence_angle - if default_values: + if default_parameters: # Default values - self.set_sampling() + self.sampling = default_parameters.incidence_sampling + + @property + def sampling(self) -> BaseSensor.LayerTypeIncidenceAngle: + """Value of the sampling for incidence angles. - def set_sampling(self, value: int = 9) -> BaseSensor.LayerTypeIncidenceAngle: - """Set the sampling for incidence angles. + By default, ``9``. + + Returns + ------- + int + Sampling for incidence angles. + """ + return self._layer_type_incidence_angle.sampling + + @sampling.setter + def sampling(self, value: int) -> BaseSensor.LayerTypeIncidenceAngle: + """Value of the sampling for incidence angles. Parameters ---------- value : int Sampling for incidence angles. By default, ``9``. - - Returns - ------- - ansys.speos.core.sensor.BaseSensor.LayerTypeIncidenceAngle - LayerTypeIncidenceAngle. """ self._layer_type_incidence_angle.sampling = value - return self def _to_dict(self) -> dict: out_dict = {} @@ -1024,7 +1201,7 @@ class BalanceModeUserWhite: def __init__( self, balance_mode_user_white: camera_sensor_pb2.SensorCameraBalanceModeUserwhite, - default_values: bool = True, + default_parameters: Union[None, BalanceModeUserWhiteParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -1032,66 +1209,84 @@ def __init__( raise RuntimeError(msg) self._balance_mode_user_white = balance_mode_user_white - if default_values: + if default_parameters: # Default values - self.set_red_gain().set_green_gain().set_blue_gain() + self._balance_mode_user_white.SetInParent() + self.red_gain = default_parameters.red_gain + self.green_gain = default_parameters.green_gain + self.blue_gain = default_parameters.blue_gain - def set_red_gain( - self, value: float = 1 - ) -> SensorCamera.Photometric.Color.BalanceModeUserWhite: + @property + def red_gain(self) -> float: + """Value of the red gain of the Camera Sensor. + + By default, ``1``. + + Returns + ------- + float + Red gain. + """ + return self._balance_mode_user_white.red_gain + + @red_gain.setter + def red_gain(self, value: float): """Set red gain. Parameters ---------- value : float Red gain. - By default, ``1``. + """ + self._balance_mode_user_white.red_gain = value + + @property + def green_gain(self) -> float: + """Value of the green gain of the Camera Sensor. + + By default, ``1``. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color.BalanceModeUserWhite - BalanceModeUserWhite. + float + green gain. """ - self._balance_mode_user_white.red_gain = value - return self + return self._balance_mode_user_white.green_gain - def set_green_gain( - self, value: float = 1 - ) -> SensorCamera.Photometric.Color.BalanceModeUserWhite: + @green_gain.setter + def green_gain(self, value: float): """Set green gain. Parameters ---------- value : float - Green gain. - By default, ``1``. + green gain. + """ + self._balance_mode_user_white.green_gain = value + + @property + def blue_gain(self) -> float: + """Value of the Blue gain of the Camera Sensor. + + By default, ``1``. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color.BalanceModeUserWhite - BalanceModeUserWhite. + float + blue gain. """ - self._balance_mode_user_white.green_gain = value - return self + return self._balance_mode_user_white.blue_gain - def set_blue_gain( - self, value: float = 1 - ) -> SensorCamera.Photometric.Color.BalanceModeUserWhite: - """Set blue gain. + @blue_gain.setter + def blue_gain(self, value: float): + """Set blue gain value. Parameters ---------- value : float - Blue gain. - By default, ``1``. - - Returns - ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color.BalanceModeUserWhite - BalanceModeUserWhite. + blue gain. """ self._balance_mode_user_white.blue_gain = value - return self class BalanceModeDisplayPrimaries: """BalanceMode : DisplayPrimaries. @@ -1119,7 +1314,7 @@ class BalanceModeDisplayPrimaries: def __init__( self, balance_mode_display: camera_sensor_pb2.SensorCameraBalanceModeDisplay, - default_values: bool = True, + default_parameters: Union[None, BalanceModeDisplayPrimariesParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -1130,68 +1325,86 @@ def __init__( self._balance_mode_display = balance_mode_display - if default_values: + if default_parameters: # Default values self._balance_mode_display.SetInParent() + if default_parameters.red_display_file_uri: + self.red_display_file_uri = default_parameters.red_display_file_uri + if default_parameters.green_display_file_uri: + self.green_display_file_uri = default_parameters.green_display_file_uri + if default_parameters.green_display_file_uri: + self.blue_display_file_uri = default_parameters.blue_display_file_uri - def set_red_display_file_uri( - self, uri: str - ) -> SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries: - """Set the red display file. + @property + def red_display_file_uri(self) -> str: + """Location of the red display file. + + Returns + ------- + str + Red display file. + """ + return self._balance_mode_display.red_display_file_uri + + @red_display_file_uri.setter + def red_display_file_uri(self, uri: Union[str, Path]): + """Location of the red display file. Parameters ---------- - uri : str + uri : Union[str, Path] Red display file. + """ + self._balance_mode_display.red_display_file_uri = str(Path(uri)) + + @property + def green_display_file_uri(self) -> str: + """Location of the green display file. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries - BalanceModeDisplayPrimaries. + str + green display file. """ - self._balance_mode_display.red_display_file_uri = uri - return self + return self._balance_mode_display.green_display_file_uri - def set_green_display_file_uri( - self, uri: str - ) -> SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries: - """Set the green display file. + @green_display_file_uri.setter + def green_display_file_uri(self, uri: Union[str, Path]): + """Location of the green display file. Parameters ---------- - uri : str - Green display file. + uri : Union[str, Path] + green display file. + """ + self._balance_mode_display.green_display_file_uri = str(Path(uri)) + + @property + def blue_display_file_uri(self) -> str: + """Location of the blue display file. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries - BalanceModeDisplayPrimaries. + str + blue display file. """ - self._balance_mode_display.green_display_file_uri = uri - return self + return self._balance_mode_display.blue_display_file_uri - def set_blue_display_file_uri( - self, uri: str - ) -> SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries: - """Set the blue display file. + @blue_display_file_uri.setter + def blue_display_file_uri(self, uri: Union[str, Path]): + """Location of the blue display file. Parameters ---------- - uri : str - Blue display file. - - Returns - ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries - BalanceModeDisplayPrimaries. + uri : Union[str, Path] + blue display file. """ - self._balance_mode_display.blue_display_file_uri = uri - return self + self._balance_mode_display.blue_display_file_uri = str(Path(uri)) def __init__( self, mode_color: camera_sensor_pb2.SensorCameraColorModeColor, - default_values: bool = True, + default_parameters: Union[None, ColorParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -1202,57 +1415,98 @@ def __init__( # Attribute gathering more complex camera balance mode self._mode = None - if default_values: + if default_parameters: # Default values - self.set_balance_mode_none() + if isinstance(default_parameters.balance_mode, BalanceModeUserWhiteParameters): + self._mode = SensorCamera.Photometric.Color.BalanceModeUserWhite( + balance_mode_user_white=self._mode_color.balance_mode_userwhite, + default_parameters=default_parameters.balance_mode, + stable_ctr=True, + ) + elif isinstance( + default_parameters.balance_mode, BalanceModeDisplayPrimariesParameters + ): + self._mode = SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries( + balance_mode_display=self._mode_color.balance_mode_display, + default_parameters=default_parameters.balance_mode, + stable_ctr=True, + ) + elif default_parameters.balance_mode == "grey_world": + self.set_balance_mode_grey_world() + elif default_parameters.balance_mode == "none": + self.set_balance_mode_none() + if default_parameters.red_spectrum_file_uri: + self.red_spectrum_file_uri = default_parameters.red_spectrum_file_uri + if default_parameters.green_spectrum_file_uri: + self.green_spectrum_file_uri = default_parameters.green_spectrum_file_uri + if default_parameters.blue_spectrum_file_uri: + self.blue_spectrum_file_uri = default_parameters.blue_spectrum_file_uri + + @property + def red_spectrum_file_uri(self) -> str: + """Location of the red spectrum. + + Returns + ------- + str + Red spectrum file. It is expressed in a .spectrum file. + """ + return self._mode_color.red_spectrum_file_uri - def set_red_spectrum_file_uri(self, uri: str) -> SensorCamera.Photometric.Color: - """Set the red spectrum. + @red_spectrum_file_uri.setter + def red_spectrum_file_uri(self, uri: Union[str, Path]): + """Location of the red spectrum. Parameters ---------- - uri : str + uri : Union[str, Path] Red spectrum file. It is expressed in a .spectrum file. + """ + self._mode_color.red_spectrum_file_uri = str(Path(uri)) + + @property + def blue_spectrum_file_uri(self) -> str: + """Location of the blue spectrum. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color - Color mode. + str + blue spectrum file. It is expressed in a .spectrum file. """ - self._mode_color.red_spectrum_file_uri = uri - return self + return self._mode_color.blue_spectrum_file_uri - def set_green_spectrum_file_uri(self, uri: str) -> SensorCamera.Photometric.Color: - """Set the green spectrum. + @blue_spectrum_file_uri.setter + def blue_spectrum_file_uri(self, uri: Union[str, Path]): + """Location of the blue spectrum. Parameters ---------- - uri : str - Green spectrum file. It is expressed in a .spectrum file. + uri : Union[str, Path] + blue spectrum file. It is expressed in a .spectrum file. + """ + self._mode_color.blue_spectrum_file_uri = str(Path(uri)) + + @property + def green_spectrum_file_uri(self) -> str: + """Location of the green spectrum. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color - Color mode. + str + green spectrum file. It is expressed in a .spectrum file. """ - self._mode_color.green_spectrum_file_uri = uri - return self + return self._mode_color.green_spectrum_file_uri - def set_blue_spectrum_file_uri(self, uri: str) -> SensorCamera.Photometric.Color: - """Set the blue spectrum. + @green_spectrum_file_uri.setter + def green_spectrum_file_uri(self, uri: Union[str, Path]): + """Location of the green spectrum. Parameters ---------- - uri : str - Blue spectrum file. It is expressed in a .spectrum file. - - Returns - ------- - ansys.speos.core.sensor.SensorCamera.Photometric.Color - Color mode. + uri : Union[str, Path] + green spectrum file. It is expressed in a .spectrum file. """ - self._mode_color.blue_spectrum_file_uri = uri - return self + self._mode_color.green_spectrum_file_uri = str(Path(uri)) def set_balance_mode_none(self) -> SensorCamera.Photometric.Color: """Set the balance mode as none. @@ -1306,7 +1560,7 @@ def set_balance_mode_user_white( # Happens in case of project created via load of speos file self._mode = SensorCamera.Photometric.Color.BalanceModeUserWhite( balance_mode_user_white=self._mode_color.balance_mode_userwhite, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance( @@ -1315,6 +1569,7 @@ def set_balance_mode_user_white( # if the _mode is not BalanceModeUserWhite then we create a new type. self._mode = SensorCamera.Photometric.Color.BalanceModeUserWhite( balance_mode_user_white=self._mode_color.balance_mode_userwhite, + default_parameters=BalanceModeUserWhiteParameters(), stable_ctr=True, ) elif ( @@ -1344,7 +1599,7 @@ def set_balance_mode_display_primaries( # Happens in case of project created via load of speos file self._mode = SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries( balance_mode_display=self._mode_color.balance_mode_display, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance( @@ -1353,6 +1608,7 @@ def set_balance_mode_display_primaries( # if the _mode is not BalanceModeDisplayPrimaries then we create a new type. self._mode = SensorCamera.Photometric.Color.BalanceModeDisplayPrimaries( balance_mode_display=self._mode_color.balance_mode_display, + default_parameters=BalanceModeDisplayPrimariesParameters(), stable_ctr=True, ) elif self._mode._balance_mode_display is not self._mode_color.balance_mode_display: @@ -1364,7 +1620,7 @@ def __init__( self, mode_photometric: camera_sensor_pb2.SensorCameraModePhotometric, camera_props: ProtoScene.SensorInstance.CameraProperties, - default_values: bool = True, + default_parameters: Union[None, PhotometricCameraParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -1377,37 +1633,89 @@ def __init__( self._mode = None # Attribute to keep track of wavelength range object - self._wavelengths_range = SensorCamera.WavelengthsRange( - wavelengths_range=self._mode_photometric.wavelengths_range, - stable_ctr=stable_ctr, - ) - if default_values: + if default_parameters: # Default values - self.set_acquisition_integration().set_acquisition_lag_time().set_gamma_correction().set_png_bits_16().set_mode_color() - self.set_wavelengths_range() - # Default values properties - self.set_layer_type_none() + self.acquisition_integration = default_parameters.acquisition_integration_time + self.acquisition_lag_time = default_parameters.acquisition_lag_time + self.gamma_correction = default_parameters.gamma_correction + if default_parameters.transmittance_file_uri: + self.transmittance_file_uri = default_parameters.transmittance_file_uri + match default_parameters.png_bits: + case "png_08": + self.set_png_bits_08() + case "png_10": + self.set_png_bits_10() + case "png_12": + self.set_png_bits_12() + case "png_16": + self.set_png_bits_16() + match default_parameters.layer_type: + case "none": + self.set_layer_type_none() + case "by_source": + self.set_layer_type_source() + self._wavelengths_range = SensorCamera.WavelengthsRange( + wavelengths_range=self._mode_photometric.wavelengths_range, + default_parameters=default_parameters.wavelength_range, + stable_ctr=stable_ctr, + ) + if isinstance(default_parameters.color_mode, MonoChromaticParameters): + self.set_mode_monochromatic(default_parameters.color_mode.sensitivity) + elif isinstance(default_parameters.color_mode, ColorParameters): + self._mode = SensorCamera.Photometric.Color( + mode_color=self._mode_photometric.color_mode_color, + default_parameters=default_parameters.color_mode, + stable_ctr=True, + ) + elif default_parameters is None: + self._wavelengths_range = SensorCamera.WavelengthsRange( + wavelengths_range=self._mode_photometric.wavelengths_range, + default_parameters=None, + stable_ctr=stable_ctr, + ) - def set_acquisition_integration(self, value: float = 0.01) -> SensorCamera.Photometric: - """Set the acquisition integration value. + @property + def acquisition_integration(self) -> float: + """Value of the acquisition integration. + + By default, ``0.01``. + + Returns + ------- + float + Acquisition integration value (s). + """ + return self._mode_photometric.acquisition_integration + + @acquisition_integration.setter + def acquisition_integration(self, value: float): + """Value of the acquisition integration. Parameters ---------- value : float Acquisition integration value (s). By default, ``0.01``. + """ + self._mode_photometric.acquisition_integration = value + + @property + def acquisition_lag_time(self) -> float: + """Value of the acquisition lag time. + + By default, ``0.0``. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric - Photometric mode. + float + Acquisition lag time value (s). """ - self._mode_photometric.acquisition_integration = value - return self + return self._mode_photometric.acquisition_lag_time - def set_acquisition_lag_time(self, value: float = 0.0) -> SensorCamera.Photometric: - """Set the acquisition lag time value. + @acquisition_lag_time.setter + def acquisition_lag_time(self, value: float): + """Value of the acquisition lag time. Parameters ---------- @@ -1421,41 +1729,55 @@ def set_acquisition_lag_time(self, value: float = 0.0) -> SensorCamera.Photometr Photometric mode. """ self._mode_photometric.acquisition_lag_time = value - return self - def set_transmittance_file_uri(self, uri: str) -> SensorCamera.Photometric: - """Set the transmittance file. + @property + def transmittance_file_uri(self) -> str: + """Location of the transmittance file. + + Returns + ------- + str + Amount of light of the source that passes through the lens and reaches the sensor. + """ + return self._mode_photometric.transmittance_file_uri + + @transmittance_file_uri.setter + def transmittance_file_uri(self, uri: Union[str, Path]): + """Location of the transmittance file. Parameters ---------- - uri : str + uri : Union[str, Path] Amount of light of the source that passes through the lens and reaches the sensor. The transmittance is expressed in a .spectrum file. + """ + self._mode_photometric.transmittance_file_uri = str(Path(uri)) + + @property + def gamma_correction(self) -> float: + """Value used to apply the gamma correction. + + By default, ``2.2``. Returns ------- - ansys.speos.core.sensor.SensorCamera.Photometric - Photometric mode. + float + Gamma Correction value """ - self._mode_photometric.transmittance_file_uri = uri - return self + return self._mode_photometric.gamma_correction - def set_gamma_correction(self, value: float = 2.2) -> SensorCamera.Photometric: - """Set the gamma correction. + @gamma_correction.setter + def gamma_correction(self, value: float): + """Value used to apply the gamma correction. + + By default, ``2.2``. Parameters ---------- value : float - Compensation of the curve before the display on the screen. - By default, ``2.2``. - - Returns - ------- - ansys.speos.core.sensor.SensorCamera.Photometric - Photometric mode. + Gamma Correction value """ self._mode_photometric.gamma_correction = value - return self def set_png_bits_08(self) -> SensorCamera.Photometric: """Choose 08-bits for png. @@ -1519,14 +1841,16 @@ def set_wavelengths_range(self) -> BaseSensor.WavelengthsRange: ) return self._wavelengths_range - def set_mode_monochromatic(self, spectrum_file_uri: str) -> SensorCamera.Photometric: + def set_mode_monochromatic( + self, spectrum_file_uri: Union[str, Path] + ) -> SensorCamera.Photometric: """Set the monochromatic mode. Results will be available in grey scale. Parameters ---------- - spectrum_file_uri : str + spectrum_file_uri : Union[str, Path] Spectrum file uri. Returns @@ -1535,7 +1859,9 @@ def set_mode_monochromatic(self, spectrum_file_uri: str) -> SensorCamera.Photome Photometric mode. """ self._mode = None - self._mode_photometric.color_mode_monochromatic.spectrum_file_uri = spectrum_file_uri + self._mode_photometric.color_mode_monochromatic.spectrum_file_uri = str( + Path(spectrum_file_uri) + ) return self def set_mode_color(self) -> SensorCamera.Photometric.Color: @@ -1552,13 +1878,14 @@ def set_mode_color(self) -> SensorCamera.Photometric.Color: # Happens in case of project created via load of speos file self._mode = SensorCamera.Photometric.Color( mode_color=self._mode_photometric.color_mode_color, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._mode, SensorCamera.Photometric.Color): # if the _mode is not Color then we create a new type. self._mode = SensorCamera.Photometric.Color( mode_color=self._mode_photometric.color_mode_color, + default_parameters=None, stable_ctr=True, ) elif self._mode._mode_color is not self._mode_photometric.color_mode_color: @@ -1566,22 +1893,29 @@ def set_mode_color(self) -> SensorCamera.Photometric.Color: self._mode._mode_color = self._mode_photometric.color_mode_color return self._mode - def set_trajectory_file_uri(self, uri: str) -> SensorCamera.Photometric: - """Set the trajectory file. + @property + def trajectory_file_uri(self) -> str: + """Location of the trajectory file. + + Returns + ------- + str + Trajectory file, used to define the position and orientations of the Camera sensor + in time. + """ + return self._camera_props.trajectory_file_uri + + @trajectory_file_uri.setter + def trajectory_file_uri(self, uri: Union[str, Path]): + """Location of the trajectory file. Parameters ---------- - uri : str + uri : Union[str, Path] Trajectory file, used to define the position and orientations of the Camera sensor in time. - - Returns - ------- - ansys.speos.core.sensor.SensorCamera.Photometric - Photometric mode. """ - self._camera_props.trajectory_file_uri = uri - return self + self._camera_props.trajectory_file_uri = str(Path(uri)) def set_layer_type_none(self) -> SensorCamera.Photometric: """Set no layer separation: includes the simulation's results in one layer. @@ -1612,7 +1946,7 @@ def __init__( description: str = "", metadata: Optional[Mapping[str, str]] = None, sensor_instance: Optional[ProtoScene.SensorInstance] = None, - default_values: bool = True, + default_parameters: Union[None, CameraSensorParameters] = None, ) -> None: if metadata is None: metadata = {} @@ -1627,12 +1961,27 @@ def __init__( # Attribute gathering more complex camera mode self._type = None - if default_values: - # Default values template - self.set_focal_length().set_imager_distance().set_f_number().set_horz_pixel() - self.set_vert_pixel().set_width().set_height().set_mode_photometric() - # Default values properties - self.set_axis_system() + if sensor_instance is None: + if not default_parameters: + default_parameters = CameraSensorParameters() + if isinstance(default_parameters.sensor_type_parameters, PhotometricCameraParameters): + self._type = SensorCamera.Photometric( + mode_photometric=self._sensor_template.camera_sensor_template.sensor_mode_photometric, + camera_props=self._sensor_instance.camera_properties, + default_parameters=default_parameters.sensor_type_parameters, + stable_ctr=True, + ) + else: + self.set_mode_geometric() + self.imager_distance = default_parameters.imager_distance + self.focal_length = default_parameters.focal_length + self.f_number = default_parameters.f_number + self.horz_pixel = default_parameters.horz_pixel + self.vert_pixel = default_parameters.vert_pixel + self.width = default_parameters.width + self.height = default_parameters.height + self.axis_system = default_parameters.axis_system + self.lxp_path_number = default_parameters.lxp_path_number @property def visual_data(self) -> _VisualData: @@ -1734,25 +2083,48 @@ def photometric(self) -> Union[SensorCamera.Photometric, None]: """ return self._type - def set_focal_length(self, value: float = 5.0) -> SensorCamera: - """Set the focal length. + @property + def focal_length(self) -> float: + """Focal length of the optical system. + + By default, ``5.0``. + + Returns + ------- + float + Distance between the center of the optical system and the focus. (mm) + """ + return self._sensor_template.camera_sensor_template.focal_length + + @focal_length.setter + def focal_length(self, value: float) -> SensorCamera: + """Focal length of the optical system. Parameters ---------- value : float Distance between the center of the optical system and the focus. (mm) By default, ``5.0``. + """ + self._sensor_template.camera_sensor_template.focal_length = value + + @property + def imager_distance(self) -> SensorCamera: + """Imager distance. + + By default, ``10``. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + float + Imager distance (mm). The imager is located at the focal point. + The Imager distance has no impact on the result. """ - self._sensor_template.camera_sensor_template.focal_length = value - return self + return self._sensor_template.camera_sensor_template.imager_distance - def set_imager_distance(self, value: float = 10) -> SensorCamera: - """Set the imager distance. + @imager_distance.setter + def imager_distance(self, value: float): + """Imager distance. Parameters ---------- @@ -1760,17 +2132,26 @@ def set_imager_distance(self, value: float = 10) -> SensorCamera: Imager distance (mm). The imager is located at the focal point. The Imager distance has no impact on the result. By default, ``10``. + """ + self._sensor_template.camera_sensor_template.imager_distance = value + + @property + def f_number(self) -> float: + """F number of the optical system. + + By default, ``20``. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + float + F-number represents the aperture of the front lens. + F number has no impact on the result. """ - self._sensor_template.camera_sensor_template.imager_distance = value - return self + return self._sensor_template.camera_sensor_template.f_number - def set_f_number(self, value: float = 20) -> SensorCamera: - """Set the f number. + @f_number.setter + def f_number(self, value: float = 20): + """F number of the optical system. Parameters ---------- @@ -1778,99 +2159,156 @@ def set_f_number(self, value: float = 20) -> SensorCamera: F-number represents the aperture of the front lens. F number has no impact on the result. By default, ``20``. + """ + self._sensor_template.camera_sensor_template.f_number = value + + @property + def distortion_file_uri(self) -> str: + """Location of the distortion file. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + str + Optical aberration that deforms and bends straight lines. The distortion is expressed in + a .OPTDistortion file. """ - self._sensor_template.camera_sensor_template.f_number = value - return self + return self._sensor_template.camera_sensor_template.distortion_file_uri - def set_distortion_file_uri(self, uri: str) -> SensorCamera: - """Set the distortion file. + @distortion_file_uri.setter + def distortion_file_uri(self, uri: Union[str, Path]): + """Location of the distortion file. Parameters ---------- - uri : str + uri : Union[str, Path] Optical aberration that deforms and bends straight lines. The distortion is expressed in a .OPTDistortion file. + """ + self._sensor_template.camera_sensor_template.distortion_file_uri = str(Path(uri)) + + @property + def horz_pixel(self) -> int: + """Horizontal pixels number corresponding to the camera resolution. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + int + The horizontal pixels number corresponding to the camera resolution. """ - self._sensor_template.camera_sensor_template.distortion_file_uri = uri - return self + return self._sensor_template.camera_sensor_template.horz_pixel - def set_horz_pixel(self, value: int = 640) -> SensorCamera: - """Set the horizontal pixels number corresponding to the camera resolution. + @horz_pixel.setter + def horz_pixel(self, value: int): + """Horizontal pixels number corresponding to the camera resolution. Parameters ---------- value : int The horizontal pixels number corresponding to the camera resolution. By default, ``640``. + """ + self._sensor_template.camera_sensor_template.horz_pixel = value + + @property + def vert_pixel(self) -> int: + """Vertical pixels number corresponding to the camera resolution. + + By default, ``480``. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + int + The vertical pixels number corresponding to the camera resolution. """ - self._sensor_template.camera_sensor_template.horz_pixel = value - return self + return self._sensor_template.camera_sensor_template.vert_pixel - def set_vert_pixel(self, value: int = 480) -> SensorCamera: - """Set the vertical pixels number corresponding to the camera resolution. + @vert_pixel.setter + def vert_pixel(self, value: int): + """Vertical pixels number corresponding to the camera resolution. Parameters ---------- value : int The vertical pixels number corresponding to the camera resolution. By default, ``480``. + """ + self._sensor_template.camera_sensor_template.vert_pixel = value + + @property + def width(self) -> float: + """Width of the imager. + + By default, ``5.0``. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + float + Sensor's width (mm). """ - self._sensor_template.camera_sensor_template.vert_pixel = value - return self + return self._sensor_template.camera_sensor_template.width - def set_width(self, value: float = 5.0) -> SensorCamera: - """Set the width of the sensor. + @width.setter + def width(self, value: float): + """Width of the imager. Parameters ---------- value : float Sensor's width (mm). By default, ``5.0``. + """ + self._sensor_template.camera_sensor_template.width = value + + @property + def height(self) -> float: + """Height of the imager. + + By default, ``5.0`` Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + float + Sensor's height (mm). + `. """ - self._sensor_template.camera_sensor_template.width = value - return self + return self._sensor_template.camera_sensor_template.height - def set_height(self, value: float = 5.0) -> SensorCamera: - """Set the height of the sensor. + @height.setter + def height(self, value: float): + """Height of the imager. Parameters ---------- value : float Sensor's height (mm). By default, ``5.0``. + """ + self._sensor_template.camera_sensor_template.height = value + + @property + def axis_system(self) -> list[float]: + """The position of the sensor. + + By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. Returns ------- - ansys.speos.core.sensor.SensorCamera - Camera feature + list[float] + Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. """ - self._sensor_template.camera_sensor_template.height = value - return self + return self._sensor_instance.camera_properties.axis_system + + @axis_system.setter + def axis_system(self, axis_system: list[float]): + """Position of the sensor. + + Parameters + ---------- + axis_system : list[float] + Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. + By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. + """ + self._sensor_instance.camera_properties.axis_system[:] = axis_system def set_mode_geometric(self) -> SensorCamera: """Set mode geometric for the camera sensor. @@ -1904,7 +2342,7 @@ def set_mode_photometric(self) -> SensorCamera.Photometric: self._type = SensorCamera.Photometric( mode_photometric=self._sensor_template.camera_sensor_template.sensor_mode_photometric, camera_props=self._sensor_instance.camera_properties, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, SensorCamera.Photometric): @@ -1912,6 +2350,7 @@ def set_mode_photometric(self) -> SensorCamera.Photometric: self._type = SensorCamera.Photometric( mode_photometric=self._sensor_template.camera_sensor_template.sensor_mode_photometric, camera_props=self._sensor_instance.camera_properties, + default_parameters=PhotometricCameraParameters(), stable_ctr=True, ) elif ( @@ -1924,25 +2363,6 @@ def set_mode_photometric(self) -> SensorCamera.Photometric: ) return self._type - def set_axis_system(self, axis_system: Optional[List[float]] = None) -> SensorCamera: - """Set the position of the sensor. - - Parameters - ---------- - axis_system : Optional[List[float]] - Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. - By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. - - Returns - ------- - ansys.speos.core.sensor.SensorCamera - Camera Sensor feature - """ - if axis_system is None: - axis_system = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] - self._sensor_instance.camera_properties.axis_system[:] = axis_system - return self - def commit(self) -> SensorCamera: """Save feature: send the local data to the speos server database. @@ -1999,7 +2419,7 @@ class SensorIrradiance(BaseSensor): sensor_instance : ansys.api.speos.scene.v2.scene_pb2.Scene.SensorInstance, optional Sensor instance to provide if the feature does not has to be created from scratch By default, ``None``, means that the feature is created from scratch by default. - default_values : bool + default_parameters : bool Uses default values when True. By default, ``True``. """ @@ -2011,7 +2431,7 @@ def __init__( description: str = "", metadata: Optional[Mapping[str, str]] = None, sensor_instance: Optional[ProtoScene.SensorInstance] = None, - default_values: bool = True, + default_parameters: Union[None, IrradianceSensorParameters] = None, ) -> None: if metadata is None: metadata = {} @@ -2030,18 +2450,92 @@ def __init__( # Attribute gathering more complex layer type self._layer_type = None - # Attribute to keep track of sensor dimensions object - self._sensor_dimensions = self.Dimensions( - sensor_dimensions=self._sensor_template.irradiance_sensor_template.dimensions, - default_values=default_values, - stable_ctr=True, - ) - - if default_values: + if sensor_instance is None: + if default_parameters is None: + default_parameters = IrradianceSensorParameters() # Default values template - self.set_type_photometric().set_illuminance_type_planar() + self._sensor_dimensions = self.Dimensions( + sensor_dimensions=self._sensor_template.irradiance_sensor_template.dimensions, + default_parameters=default_parameters.dimensions, + stable_ctr=True, + ) + + if isinstance(default_parameters.sensor_type, ColorimetricParameters): + self._type = BaseSensor.Colorimetric( + sensor_type_colorimetric=self._sensor_template.irradiance_sensor_template.sensor_type_colorimetric, + default_parameters=default_parameters.sensor_type, + stable_ctr=True, + ) + elif isinstance(default_parameters.sensor_type, SpectralParameters): + self._type = BaseSensor.Spectral( + sensor_type_spectral=self._sensor_template.irradiance_sensor_template.sensor_type_spectral, + default_parameters=default_parameters.sensor_type, + stable_ctr=True, + ) + elif default_parameters.sensor_type == "radiometric": + self.set_type_radiometric() + elif default_parameters.sensor_type == "photometric": + self.set_type_photometric() + + match default_parameters.integration_type: + case "planar": + self.set_illuminance_type_planar() + self.integration_direction = default_parameters.integration_direction + case "radial": + self.set_illuminance_type_radial() + case "hemispherical": + self.set_illuminance_type_hemispherical() + case "cylindrical": + self.set_illuminance_type_cylindrical() + case "semi_cylindrical": + self.set_illuminance_type_semi_cylindrical() + self.integration_direction = default_parameters.integration_direction + + match default_parameters.rayfile_type: + case "none": + self.set_ray_file_type_none() + case "classic": + self.set_ray_file_type_classic() + case "polarization": + self.set_ray_file_type_polarization() + case "tm25": + self.set_ray_file_type_tm25() + case "tm25_no_polarization": + self.set_ray_file_type_tm25_no_polarization() + + if default_parameters.layer_type == "none": + self.set_layer_type_none() + elif default_parameters.layer_type == "by_source": + self.set_layer_type_source() + elif default_parameters.layer_type == "by_polarization": + self.set_layer_type_polarization() + elif isinstance(default_parameters.layer_type, LayerByFaceParameters): + self._layer_type = BaseSensor.LayerTypeFace( + layer_type_face=self._sensor_instance.irradiance_properties.layer_type_face, + default_parameters=default_parameters.layer_type, + stable_ctr=True, + ) + elif isinstance(default_parameters.layer_type, LayerBySequenceParameters): + self._layer_type = BaseSensor.LayerTypeSequence( + layer_type_sequence=self._sensor_instance.irradiance_properties.layer_type_sequence, + default_parameters=default_parameters.layer_type, + stable_ctr=True, + ) + elif isinstance(default_parameters.layer_type, LayerByIncidenceAngleParameters): + self._layer_type = BaseSensor.LayerTypeIncidenceAngle( + layer_type_incidence_angle=self._sensor_instance.irradiance_properties.layer_type_incidence_angle, + default_parameters=default_parameters.layer_type, + stable_ctr=True, + ) # Default values properties - self.set_axis_system().set_ray_file_type_none().set_layer_type_none() + self.axis_system = default_parameters.axis_system + self.output_face_geometries = default_parameters.outpath_face_geometry + else: + self._sensor_dimensions = self.Dimensions( + sensor_dimensions=self._sensor_template.irradiance_sensor_template.dimensions, + default_parameters=None, + stable_ctr=True, + ) @property def visual_data(self) -> _VisualData: @@ -2229,13 +2723,14 @@ def set_type_colorimetric(self) -> BaseSensor.Colorimetric: # Happens in case of project created via load of speos file self._type = BaseSensor.Colorimetric( sensor_type_colorimetric=self._sensor_template.irradiance_sensor_template.sensor_type_colorimetric, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, BaseSensor.Colorimetric): # if the _type is not Colorimetric then we create a new type. self._type = BaseSensor.Colorimetric( sensor_type_colorimetric=self._sensor_template.irradiance_sensor_template.sensor_type_colorimetric, + default_parameters=ColorimetricParameters(), stable_ctr=True, ) elif ( @@ -2279,13 +2774,14 @@ def set_type_spectral(self) -> BaseSensor.Spectral: # Happens in case of project created via load of speos file self._type = BaseSensor.Spectral( sensor_type_spectral=self._sensor_template.irradiance_sensor_template.sensor_type_spectral, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, BaseSensor.Spectral): # if the _type is not Spectral then we create a new type. self._type = BaseSensor.Spectral( sensor_type_spectral=self._sensor_template.irradiance_sensor_template.sensor_type_spectral, + default_parameters=SpectralParameters(), stable_ctr=True, ) elif ( @@ -2298,14 +2794,57 @@ def set_type_spectral(self) -> BaseSensor.Spectral: ) return self._type - def set_illuminance_type_planar( - self, integration_direction: Optional[List[float]] = None - ) -> SensorIrradiance: + @property + def integration_direction(self): + """Integration direction of irradiance Sensor. + + Sensor global integration direction [x,y,z], optional (default direction is Z axis of + axis_system). + + Note: Contrary to any visualization of integration directions within Speos Software or its + documentation the integration direction must be set in the anti-rays direction to integrate + their signal. + Integration direction is only settable for sensor template with IlluminanceTypePlanar or + IlluminanceTypeSemiCylindrical as illuminance_type + + Returns + ------- + list[float] + Sensor global integration direction [x,y,z] + """ + return self._sensor_instance.irradiance_properties.integration_direction + + @integration_direction.setter + def integration_direction(self, value: list[float]): + """Set integration direction. + + Parameters + ---------- + value : list[float] + Sensor global integration direction [x,y,z] + """ + if not value: + self._sensor_instance.irradiance_properties.ClearField("integration_direction") + else: + if self._sensor_template.irradiance_sensor_template.HasField( + "illuminance_type_semi_cylindrical" + ) or self._sensor_template.irradiance_sensor_template.HasField( + "illuminance_type_planar" + ): + self._sensor_instance.irradiance_properties.integration_direction[:] = value + else: + msg = ( + "Integration direction is only settable for sensor template with" + "IlluminanceTypePlanar or IlluminanceTypeSemiCylindrical as illuminance_type." + ) + raise TypeError(msg) + + def set_illuminance_type_planar(self) -> SensorIrradiance: """Set illuminance type planar. Parameters ---------- - integration_direction : List[float], optional + integration_direction : list[float], optional Sensor global integration direction [x,y,z]. The integration direction must be set in the anti-rays direction to integrate their signal. @@ -2323,12 +2862,7 @@ def set_illuminance_type_planar( their signal. """ self._sensor_template.irradiance_sensor_template.illuminance_type_planar.SetInParent() - if not integration_direction: - self._sensor_instance.irradiance_properties.ClearField("integration_direction") - else: - self._sensor_instance.irradiance_properties.integration_direction[:] = ( - integration_direction - ) + self._sensor_instance.irradiance_properties.ClearField("integration_direction") return self def set_illuminance_type_radial(self) -> SensorIrradiance: @@ -2364,49 +2898,42 @@ def set_illuminance_type_cylindrical(self) -> SensorIrradiance: self._sensor_template.irradiance_sensor_template.illuminance_type_cylindrical.SetInParent() return self - def set_illuminance_type_semi_cylindrical( - self, integration_direction: Optional[List[float]] = None - ) -> SensorIrradiance: + def set_illuminance_type_semi_cylindrical(self) -> SensorIrradiance: """Set illuminance type semi cylindrical. - Parameters - ---------- - integration_direction : List[float], optional - Sensor global integration direction [x,y,z]. - By default, ``None``. None means that the Z axis of axis_system is taken. - Returns ------- ansys.speos.core.sensor.SensorIrradiance Irradiance sensor. """ self._sensor_template.irradiance_sensor_template.illuminance_type_semi_cylindrical.SetInParent() - if not integration_direction: - self._sensor_instance.irradiance_properties.ClearField("integration_direction") - else: - self._sensor_instance.irradiance_properties.integration_direction[:] = ( - integration_direction - ) + self._sensor_instance.irradiance_properties.ClearField("integration_direction") return self - def set_axis_system(self, axis_system: Optional[List[float]] = None) -> SensorIrradiance: - """Set position of the sensor. + @property + def axis_system(self) -> list[float]: + """Position of the sensor. + + By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. + + Returns + ------- + list[float] + Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. + """ + return self._sensor_instance.irradiance_properties.axis_system + + @axis_system.setter + def axis_system(self, axis_system: list[float]): + """Position of the sensor. Parameters ---------- - axis_system : Optional[List[float]] + axis_system : list[float] Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. - - Returns - ------- - ansys.speos.core.sensor.SensorIrradiance - Irradiance sensor. """ - if axis_system is None: - axis_system = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] self._sensor_instance.irradiance_properties.axis_system[:] = axis_system - return self def set_ray_file_type_none(self) -> SensorIrradiance: """Set no ray file generation. @@ -2514,13 +3041,14 @@ def set_layer_type_face(self) -> BaseSensor.LayerTypeFace: # Happens in case of project created via load of speos file self._layer_type = BaseSensor.LayerTypeFace( layer_type_face=self._sensor_instance.irradiance_properties.layer_type_face, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._layer_type, BaseSensor.LayerTypeFace): # if the _layer_type is not LayerTypeFace then we create a new type. self._layer_type = BaseSensor.LayerTypeFace( layer_type_face=self._sensor_instance.irradiance_properties.layer_type_face, + default_parameters=LayerByFaceParameters(), stable_ctr=True, ) elif ( @@ -2547,13 +3075,14 @@ def set_layer_type_sequence(self) -> BaseSensor.LayerTypeSequence: # Happens in case of project created via load of speos file self._layer_type = BaseSensor.LayerTypeSequence( layer_type_sequence=self._sensor_instance.irradiance_properties.layer_type_sequence, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._layer_type, BaseSensor.LayerTypeSequence): # if the _type is not LayerTypeSequence then we create a new type. self._layer_type = BaseSensor.LayerTypeSequence( layer_type_sequence=self._sensor_instance.irradiance_properties.layer_type_sequence, + default_parameters=LayerBySequenceParameters(), stable_ctr=True, ) elif ( @@ -2594,13 +3123,14 @@ def set_layer_type_incidence_angle( # Happens in case of project created via load of speos file self._layer_type = BaseSensor.LayerTypeIncidenceAngle( layer_type_incidence_angle=self._sensor_instance.irradiance_properties.layer_type_incidence_angle, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._layer_type, BaseSensor.LayerTypeIncidenceAngle): # if the _layer_type is not LayerTypeIncidenceAngle then we create a new type. self._layer_type = BaseSensor.LayerTypeIncidenceAngle( layer_type_incidence_angle=self._sensor_instance.irradiance_properties.layer_type_incidence_angle, + default_parameters=LayerByIncidenceAngleParameters(), stable_ctr=True, ) elif ( @@ -2613,14 +3143,34 @@ def set_layer_type_incidence_angle( ) return self._layer_type - def set_output_face_geometries( - self, geometries: Optional[List[GeoRef]] = None + @property + def output_face_geometries(self) -> SensorIrradiance: + """Select output faces for inverse simulation optimization. + + Parameters + ---------- + geometries : list[ansys.speos.core.geo_ref.GeoRef] + list of geometries that will be considered as output faces. + By default, ``[]``, ie no output faces. + + Returns + ------- + ansys.speos.core.sensor.SensorIrradiance + Irradiance sensor. + """ + if self._sensor_instance.irradiance_properties.HasField("output_face_geometries"): + return self._sensor_instance.irradiance_properties.output_face_geometries.geo_paths + + @output_face_geometries.setter + def output_face_geometries( + self, + geometries: Optional[list[Union[GeoRef, body.Body, face.Face, part.Part.SubPart]]] = None, ) -> SensorIrradiance: """Select output faces for inverse simulation optimization. Parameters ---------- - geometries : List[ansys.speos.core.geo_ref.GeoRef] + geometries : list[ansys.speos.core.geo_ref.GeoRef] List of geometries that will be considered as output faces. By default, ``[]``, ie no output faces. @@ -2632,10 +3182,18 @@ def set_output_face_geometries( if not geometries: self._sensor_instance.irradiance_properties.ClearField("output_face_geometries") else: + geo_paths = [] + for gr in geometries: + if isinstance(gr, GeoRef): + geo_paths.append(gr) + elif isinstance(gr, (face.Face, body.Body, part.Part.SubPart)): + geo_paths.append(gr.geo_path) + else: + msg = f"Type {type(gr)} is not supported as output faces geometry input." + raise TypeError(msg) self._sensor_instance.irradiance_properties.output_face_geometries.geo_paths[:] = [ - gr.to_native_link() for gr in geometries + gp.to_native_link() for gp in geo_paths ] - return self class SensorRadiance(BaseSensor): @@ -2660,7 +3218,7 @@ class SensorRadiance(BaseSensor): sensor_instance : ansys.api.speos.scene.v2.scene_pb2.Scene.SensorInstance, optional Sensor instance to provide if the feature does not has to be created from scratch By default, ``None``, means that the feature is created from scratch by default. - default_values : bool + default_parameters : bool Uses default values when True. By default, ``True``. """ @@ -2672,7 +3230,7 @@ def __init__( description: str = "", metadata: Optional[Mapping[str, str]] = None, sensor_instance: Optional[ProtoScene.SensorInstance] = None, - default_values: bool = True, + default_parameters: Union[None, RadianceSensorParameters] = None, ) -> None: if metadata is None: metadata = {} @@ -2694,15 +3252,61 @@ def __init__( # Attribute to keep track of sensor dimensions object self._sensor_dimensions = self.Dimensions( sensor_dimensions=self._sensor_template.radiance_sensor_template.dimensions, - default_values=default_values, + default_parameters=None, stable_ctr=True, ) - - if default_values: + if sensor_instance is None: + if default_parameters is None: + default_parameters = RadianceSensorParameters() # Default values template - self.set_focal().set_integration_angle().set_type_photometric() - # Default values properties - self.set_axis_system().set_layer_type_none() + self.focal = default_parameters.focal_length + self.integration_angle = default_parameters.integration_angle + self.axis_system = default_parameters.axis_system + self.observer_point = default_parameters.observer + self._sensor_dimensions = self.Dimensions( + sensor_dimensions=self._sensor_template.radiance_sensor_template.dimensions, + default_parameters=default_parameters.dimensions, + stable_ctr=True, + ) + if isinstance(default_parameters.sensor_type, ColorimetricParameters): + self._type = BaseSensor.Colorimetric( + sensor_type_colorimetric=self._sensor_template.radiance_sensor_template.sensor_type_colorimetric, + default_parameters=default_parameters.sensor_type, + stable_ctr=True, + ) + elif isinstance(default_parameters.sensor_type, SpectralParameters): + self._type = BaseSensor.Spectral( + sensor_type_spectral=self._sensor_template.radiance_sensor_template.sensor_type_spectral, + default_parameters=default_parameters.sensor_type, + stable_ctr=True, + ) + elif default_parameters.sensor_type == "radiometric": + self.set_type_radiometric() + elif default_parameters.sensor_type == "photometric": + self.set_type_photometric() + + if default_parameters.layer_type == "none": + self.set_layer_type_none() + elif default_parameters.layer_type == "by_source": + self.set_layer_type_source() + elif isinstance(default_parameters.layer_type, LayerByFaceParameters): + self._layer_type = BaseSensor.LayerTypeFace( + layer_type_face=self._sensor_instance.radiance_properties.layer_type_face, + default_parameters=default_parameters.layer_type, + stable_ctr=True, + ) + elif isinstance(default_parameters.layer_type, LayerBySequenceParameters): + self._layer_type = BaseSensor.LayerTypeSequence( + layer_type_sequence=self._sensor_instance.radiance_properties.layer_type_sequence, + default_parameters=default_parameters.layer_type, + stable_ctr=True, + ) + else: + self._sensor_dimensions = self.Dimensions( + sensor_dimensions=self._sensor_template.radiance_sensor_template.dimensions, + default_parameters=None, + stable_ctr=True, + ) @property def visual_data(self) -> _VisualData: @@ -2888,13 +3492,14 @@ def set_type_colorimetric(self) -> BaseSensor.Colorimetric: # Happens in case of project created via load of speos file self._type = BaseSensor.Colorimetric( sensor_type_colorimetric=self._sensor_template.radiance_sensor_template.sensor_type_colorimetric, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, BaseSensor.Colorimetric): # if the _type is not Colorimetric then we create a new type. self._type = BaseSensor.Colorimetric( sensor_type_colorimetric=self._sensor_template.radiance_sensor_template.sensor_type_colorimetric, + default_parameters=ColorimetricParameters(), stable_ctr=True, ) elif ( @@ -2938,13 +3543,14 @@ def set_type_spectral(self) -> BaseSensor.Spectral: # Happens in case of project created via load of speos file self._type = BaseSensor.Spectral( sensor_type_spectral=self._sensor_template.radiance_sensor_template.sensor_type_spectral, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, BaseSensor.Spectral): # if the _type is not Spectral then we create a new type. self._type = BaseSensor.Spectral( sensor_type_spectral=self._sensor_template.radiance_sensor_template.sensor_type_spectral, + default_parameters=SpectralParameters(), stable_ctr=True, ) elif ( @@ -2957,81 +3563,115 @@ def set_type_spectral(self) -> BaseSensor.Spectral: ) return self._type - def set_focal(self, value: float = 250) -> SensorRadiance: - """Set the focal value. + @property + def focal(self) -> float: + """Focal value of the Radiance Sensor. + + By default, ``250``. + + Returns + ------- + float + Focal length of the sensor + """ + return self._sensor_template.radiance_sensor_template.focal + + @focal.setter + def focal(self, value: float): + """Focal value. Parameters ---------- value : float Focal (mm). By default, ``250``. + """ + self._sensor_template.radiance_sensor_template.focal = value + + @property + def integration_angle(self) -> float: + """Integration angle. + + By default, ``5``. Returns ------- - ansys.speos.core.sensor.SensorRadiance - Radiance sensor. + float + integration angle of the Radiance Sensor """ - self._sensor_template.radiance_sensor_template.focal = value - return self + return self._sensor_template.radiance_sensor_template.integration_angle - def set_integration_angle(self, value: float = 5) -> SensorRadiance: - """Set the integration angle. + @integration_angle.setter + def integration_angle(self, value: float) -> SensorRadiance: + """Integration angle. Parameters ---------- value : float integration angle (degree) By default, ``5``. + """ + self._sensor_template.radiance_sensor_template.integration_angle = value + + @property + def axis_system(self) -> list[float]: + """Position of the sensor. + + By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. Returns ------- - ansys.speos.core.sensor.SensorRadiance - Radiance sensor. + list[float] + Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. """ - self._sensor_template.radiance_sensor_template.integration_angle = value - return self + return self._sensor_instance.radiance_properties.axis_system - def set_axis_system(self, axis_system: Optional[List[float]] = None) -> SensorRadiance: - """Set position of the sensor. + @axis_system.setter + def axis_system(self, axis_system: list[float]): + """Position of the sensor. Parameters ---------- - axis_system : Optional[List[float]] + axis_system : list[float] Position of the sensor [Ox Oy Oz Xx Xy Xz Yx Yy Yz Zx Zy Zz]. By default, ``[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]``. + """ + self._sensor_instance.radiance_properties.axis_system[:] = axis_system + + @property + def observer_point(self) -> SensorRadiance: + """The position of the observer point. + + This is optional, because the focal length is used by default. + Choosing to set an observer point will make the focal length ignored. + + By default, ``None``. None means that the focal length is used. Returns ------- - ansys.speos.core.sensor.SensorRadiance - Radiance sensor. + Union[None, list[float]] + Position of the observer point [Ox Oy Oz], None means that the + focal length is used. """ - if axis_system is None: - axis_system = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] - self._sensor_instance.radiance_properties.axis_system[:] = axis_system - return self + return self._sensor_instance.radiance_properties.observer_point - def set_observer_point(self, value: Optional[List[float]] = None) -> SensorRadiance: - """Set the position of the observer point. + @observer_point.setter + def observer_point(self, value: list[float]): + """Position of the observer point. This is optional, because the focal length is used by default. Choosing to set an observer point will make the focal length ignored. Parameters ---------- - value : List[float], optional + value : list[float] Position of the observer point [Ox Oy Oz]. By default, ``None``. None means that the focal length is used. - - Returns - ------- - ansys.speos.core.sensor.SensorRadiance - Radiance sensor. """ if not value: self._sensor_instance.radiance_properties.ClearField("observer_point") else: self._sensor_instance.radiance_properties.observer_point[:] = value - return self def set_layer_type_none(self) -> SensorRadiance: """Define layer separation type as None. @@ -3073,13 +3713,14 @@ def set_layer_type_face(self) -> BaseSensor.LayerTypeFace: # Happens in case of project created via load of speos file self._layer_type = BaseSensor.LayerTypeFace( layer_type_face=self._sensor_instance.radiance_properties.layer_type_face, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._layer_type, BaseSensor.LayerTypeFace): # if the _layer_type is not LayerTypeFace then we create a new type. self._layer_type = BaseSensor.LayerTypeFace( layer_type_face=self._sensor_instance.radiance_properties.layer_type_face, + default_parameters=LayerByFaceParameters(), stable_ctr=True, ) elif ( @@ -3106,13 +3747,14 @@ def set_layer_type_sequence(self) -> BaseSensor.LayerTypeSequence: # Happens in case of project created via load of speos file self._layer_type = BaseSensor.LayerTypeSequence( layer_type_sequence=self._sensor_instance.radiance_properties.layer_type_sequence, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._layer_type, BaseSensor.LayerTypeSequence): # if the _layer_type is not LayerTypeSequence then we create a new type. self._layer_type = BaseSensor.LayerTypeSequence( layer_type_sequence=self._sensor_instance.radiance_properties.layer_type_sequence, + default_parameters=LayerBySequenceParameters(), stable_ctr=True, ) elif ( @@ -3149,7 +3791,7 @@ class Sensor3DIrradiance(BaseSensor): sensor_instance : ansys.api.speos.scene.v2.scene_pb2.Scene.SensorInstance, optional Sensor instance to provide if the feature does not has to be created from scratch By default, ``None``, means that the feature is created from scratch by default. - default_values : bool + default_parameters : bool Uses default values when True. By default, ``True``. """ @@ -3161,7 +3803,7 @@ def __init__( description: str = "", metadata: Optional[Mapping[str, str]] = None, sensor_instance: Optional[ProtoScene.SensorInstance] = None, - default_values: bool = True, + default_parameters: Union[None, Irradiance3DSensorParameters] = None, ) -> None: if metadata is None: metadata = {} @@ -3180,11 +3822,45 @@ def __init__( # Attribute gathering more complex layer type self._layer_type = None - if default_values: - # Default values template - self.set_type_photometric().set_integration_planar() - # Default values properties - self.set_ray_file_type_none().set_layer_type_none() + if sensor_instance is None: + if default_parameters is None: + default_parameters = Irradiance3DSensorParameters() + + if isinstance(default_parameters.sensor_type, ColorimetricParameters): + self._type = Sensor3DIrradiance.Colorimetric( + sensor_type_colorimetric=self._sensor_template.irradiance_3d.type_colorimetric, + default_parameters=default_parameters.sensor_type, + stable_ctr=True, + ) + elif default_parameters.sensor_type == "radiometric": + self._type = Sensor3DIrradiance.Radiometric( + sensor_type_radiometric=self._sensor_template.irradiance_3d.type_radiometric, + default_parameters=default_parameters, + stable_ctr=True, + ) + elif default_parameters.sensor_type == "photometric": + self._type = Sensor3DIrradiance.Photometric( + sensor_type_photometric=self._sensor_template.irradiance_3d.type_photometric, + default_parameters=default_parameters, + stable_ctr=True, + ) + if default_parameters.geometries: + self.geometries = default_parameters.geometries + if default_parameters.layer_type == "none": + self.set_layer_type_none() + elif default_parameters.layer_type == "by_source": + self.set_layer_type_source() + match default_parameters.rayfile_type: + case "none": + self.set_ray_file_type_none() + case "classic": + self.set_ray_file_type_classic() + case "polarization": + self.set_ray_file_type_polarization() + case "tm25": + self.set_ray_file_type_tm25() + case "tm25_no_polarization": + self.set_ray_file_type_tm25_no_polarization() class Radiometric: """Class computing the radiant intensity (in W.sr-1). @@ -3195,7 +3871,7 @@ class Radiometric: ---------- illuminance_type : ansys.api.speos.sensor.v1.sensor_pb2.TypeRadiometric SensorTypeColorimetric protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -3209,22 +3885,31 @@ class Radiometric: def __init__( self, sensor_type_radiometric: sensor_pb2.TypeRadiometric, - default_values: bool = True, + default_parameters: Union[None, Irradiance3DSensorParameters] = None, stable_ctr: bool = True, ) -> None: if not stable_ctr: raise RuntimeError("Radiometric class instantiated outside of class scope") self._sensor_type_radiometric = sensor_type_radiometric - - self._integration_type = Sensor3DIrradiance.Measures( - illuminance_type=self._sensor_type_radiometric.integration_type_planar, - default_values=default_values, - stable_ctr=stable_ctr, - ) - - if default_values: - self.set_integration_planar() + self._integration_type = None + if default_parameters: + match default_parameters.integration_type: + case "planar": + self.set_integration_planar() + case "radial": + self.set_integration_radial() + self._integration_type = Sensor3DIrradiance.Measures( + illuminance_type=self._sensor_type_radiometric.integration_type_planar, + default_parameters=default_parameters.measures, + stable_ctr=stable_ctr, + ) + else: + self._integration_type = Sensor3DIrradiance.Measures( + illuminance_type=self._sensor_type_radiometric.integration_type_planar, + default_parameters=None, + stable_ctr=stable_ctr, + ) def set_integration_planar(self) -> Sensor3DIrradiance.Measures: """Set integration planar. @@ -3238,7 +3923,7 @@ def set_integration_planar(self) -> Sensor3DIrradiance.Measures: if not isinstance(self._integration_type, Sensor3DIrradiance.Measures): self._integration_type = Sensor3DIrradiance.Measures( illuminance_type=self._sensor_type_radiometric.integration_type_planar, - default_values=True, + default_parameters=MeasuresParameters(), stable_ctr=True, ) elif ( @@ -3265,7 +3950,7 @@ class Photometric: ---------- illuminance_type : ansys.api.speos.sensor.v1.sensor_pb2.TypePhotometric SensorTypeColorimetric protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -3279,22 +3964,31 @@ class Photometric: def __init__( self, sensor_type_photometric: sensor_pb2.TypePhotometric, - default_values: bool = True, + default_parameters: Union[None, Irradiance3DSensorParameters] = None, stable_ctr: bool = True, ) -> None: if not stable_ctr: - raise RuntimeError("Radiometric class instantiated outside of class scope") + raise RuntimeError("Photometric class instantiated outside of class scope") self._sensor_type_photometric = sensor_type_photometric - - self._integration_type = Sensor3DIrradiance.Measures( - illuminance_type=self._sensor_type_photometric.integration_type_planar, - default_values=default_values, - stable_ctr=stable_ctr, - ) - - if default_values: - self.set_integration_planar() + self._integration_type = None + if default_parameters: + match default_parameters.integration_type: + case "planar": + self.set_integration_planar() + case "radial": + self.set_integration_radial() + self._integration_type = Sensor3DIrradiance.Measures( + illuminance_type=self._sensor_type_photometric.integration_type_planar, + default_parameters=default_parameters.measures, + stable_ctr=stable_ctr, + ) + else: + self._integration_type = Sensor3DIrradiance.Measures( + illuminance_type=self._sensor_type_photometric.integration_type_planar, + default_parameters=None, + stable_ctr=stable_ctr, + ) def set_integration_planar(self) -> Sensor3DIrradiance.Measures: """Set integration planar. @@ -3308,7 +4002,7 @@ def set_integration_planar(self) -> Sensor3DIrradiance.Measures: if not isinstance(self._integration_type, Sensor3DIrradiance.Measures): self._integration_type = Sensor3DIrradiance.Measures( illuminance_type=self._sensor_type_photometric.integration_type_planar, - default_values=True, + default_parameters=MeasuresParameters(), stable_ctr=True, ) elif ( @@ -3337,7 +4031,7 @@ class Measures: ---------- illuminance_type : ansys.api.speos.sensor.v1.sensor_pb2.IntegrationTypePlanar SensorTypeColorimetric protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -3351,19 +4045,19 @@ class Measures: def __init__( self, illuminance_type: sensor_pb2.IntegrationTypePlanar, - default_values: bool = True, + default_parameters: Union[None, MeasuresParameters] = None, stable_ctr: bool = False, ): if not stable_ctr: - msg = "WavelengthsRange class instantiated outside of class scope" + msg = "Measures class instantiated outside of class scope" raise RuntimeError(msg) self._illuminance_type = illuminance_type - if default_values: + if default_parameters: # Default values - self.reflection = True - self.transmission = True - self.absorption = True + self.reflection = default_parameters.reflection + self.transmission = default_parameters.transmission + self.absorption = default_parameters.absorption @property def reflection(self) -> bool: @@ -3406,7 +4100,7 @@ def transmission(self) -> bool: @transmission.setter def transmission(self, value: bool) -> None: - """Set transmission. + """Transmission. Parameters ---------- @@ -3458,7 +4152,7 @@ class Colorimetric: ---------- illuminance_type : ansys.api.speos.sensor.v1.sensor_pb2.TypeColorimetric SensorTypeColorimetric protobuf object to modify. - default_values : bool + default_parameters : bool Uses default values when True. stable_ctr : bool Variable to indicate if usage is inside class scope @@ -3472,7 +4166,7 @@ class Colorimetric: def __init__( self, sensor_type_colorimetric: sensor_pb2.TypeColorimetric, - default_values: bool = True, + default_parameters: Union[None, ColorimetricParameters] = None, stable_ctr: bool = False, ) -> None: if not stable_ctr: @@ -3481,15 +4175,20 @@ def __init__( self._sensor_type_colorimetric = sensor_type_colorimetric # Attribute to keep track of wavelength range object - self._wavelengths_range = BaseSensor.WavelengthsRange( - wavelengths_range=self._sensor_type_colorimetric, - default_values=default_values, - stable_ctr=stable_ctr, - ) - if default_values: + if default_parameters: # Default values - self.set_wavelengths_range() + self._wavelengths_range = BaseSensor.WavelengthsRange( + wavelengths_range=self._sensor_type_colorimetric, + default_parameters=default_parameters.wavelength_range, + stable_ctr=stable_ctr, + ) + else: + self._wavelengths_range = BaseSensor.WavelengthsRange( + wavelengths_range=self._sensor_type_colorimetric, + default_parameters=default_parameters, + stable_ctr=stable_ctr, + ) def set_wavelengths_range(self) -> BaseSensor.WavelengthsRange: """Set the range of wavelengths. @@ -3582,13 +4281,14 @@ def set_type_photometric(self) -> Sensor3DIrradiance.Photometric: # Happens in case of project created via load of speos file self._type = Sensor3DIrradiance.Photometric( self._sensor_template.irradiance_3d.type_photometric, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, Sensor3DIrradiance.Photometric): # if the _type is not Colorimetric then we create a new type. self._type = Sensor3DIrradiance.Photometric( self._sensor_template.irradiance_3d.type_photometric, + default_parameters=Irradiance3DSensorParameters(), stable_ctr=True, ) elif ( @@ -3615,13 +4315,14 @@ def set_type_radiometric(self) -> Sensor3DIrradiance.Radiometric: # Happens in case of project created via load of speos file self._type = Sensor3DIrradiance.Radiometric( sensor_type_radiometric=self._sensor_template.irradiance_3d.type_radiometric, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, Sensor3DIrradiance.Radiometric): # if the _type is not Colorimetric then we create a new type. self._type = Sensor3DIrradiance.Radiometric( sensor_type_radiometric=self._sensor_template.irradiance_3d.type_radiometric, + default_parameters=Irradiance3DSensorParameters(), stable_ctr=True, ) elif ( @@ -3649,13 +4350,14 @@ def set_type_colorimetric(self) -> Sensor3DIrradiance.Colorimetric: # Happens in case of project created via load of speos file self._type = Sensor3DIrradiance.Colorimetric( sensor_type_colorimetric=self._sensor_template.irradiance_3d.type_colorimetric, - default_values=False, + default_parameters=None, stable_ctr=True, ) elif not isinstance(self._type, BaseSensor.Colorimetric): # if the _type is not Colorimetric then we create a new type. self._type = Sensor3DIrradiance.Colorimetric( sensor_type_colorimetric=self._sensor_template.irradiance_3d.type_colorimetric, + default_parameters=ColorimetricParameters(), stable_ctr=True, ) elif ( @@ -3760,20 +4462,37 @@ def set_layer_type_source(self) -> Sensor3DIrradiance: self._layer_type = None return self - def set_geometries(self, geometries: [List[GeoRef]]) -> Sensor3DIrradiance: + @property + def geometries(self) -> list[str]: + """Geometry faces/bodies to be defined with 3D irradiance sensor. + + Returns + ------- + list[str] + List of geometries that will be considered as Sensor + """ + return self._sensor_instance.irradiance_3d_properties.geometries.geo_paths + + @geometries.setter + def geometries( + self, geometries: list[Union[GeoRef, body.Body, face.Face, part.Part.SubPart]] + ) -> Sensor3DIrradiance: """Select geometry faces to be defined with 3D irradiance sensor. Parameters ---------- - geometries : List[ansys.speos.core.geo_ref.GeoRef] - List of geometries that will be considered as output faces. - - Returns - ------- - ansys.speos.core.sensor.Sensor3DIrradiance - 3D Irradiance sensor + geometries : list[Union[GeoRef, body.Body, face.Face, part.Part.SubPart]] + List of geometries that will be considered as Sensor """ + geo_paths = [] + for gr in geometries: + if isinstance(gr, GeoRef): + geo_paths.append(gr) + elif isinstance(gr, (face.Face, body.Body, part.Part.SubPart)): + geo_paths.append(gr.geo_path) + else: + msg = f"Type {type(gr)} is not supported as 3D Irradiance Sensor geometry input." + raise TypeError(msg) self._sensor_instance.irradiance_3d_properties.geometries.geo_paths[:] = [ - gr.to_native_link() for gr in geometries + gp.to_native_link() for gp in geo_paths ] - return self diff --git a/tests/core/test_project.py b/tests/core/test_project.py index b43e83fb3..e086084eb 100644 --- a/tests/core/test_project.py +++ b/tests/core/test_project.py @@ -362,7 +362,7 @@ def test_from_file(speos: Speos): assert type(feat_ssrs[0]) is SensorIrradiance # And that we can modify it (and that other values are not overridden by default values) - feat_ssrs[0].set_type_colorimetric().set_wavelengths_range().set_end(value=800) + feat_ssrs[0].set_type_colorimetric().set_wavelengths_range().end = 800 feat_ssrs[0].commit() ssr_link = speos.client[p.scene_link.get().sensors[0].sensor_guid] ssr_data = ssr_link.get() @@ -530,7 +530,7 @@ def test_preview_visual_data(speos: Speos): p5 = Project(speos=speos, path=str(Path(test_path) / "Prism.speos" / "Prism.speos")) ssr_3d = p5.create_sensor(name="Sensor3D", feature_type=Sensor3DIrradiance) body = p5.find(name="PrismBody", name_regex=True, feature_type=Body)[0] - ssr_3d.set_geometries([body.geo_path]) + ssr_3d.geometries = [body.geo_path] ssr_3d.commit() p5.preview() # test loading 3d irradiance sensor diff --git a/tests/core/test_sensor.py b/tests/core/test_sensor.py index 470471430..1c2a21964 100644 --- a/tests/core/test_sensor.py +++ b/tests/core/test_sensor.py @@ -29,6 +29,17 @@ import pytest from ansys.speos.core import Body, GeoRef, Project, Speos, sensor +from ansys.speos.core.generic.constants import ( + ORIGIN, + BalanceModeUserWhiteParameters, + CameraSensorParameters, + ColorimetricParameters, + IrradianceSensorParameters, + LayerBySequenceParameters, + RadianceSensorParameters, + SpectralParameters, + WavelengthsRangeParameters, +) from ansys.speos.core.sensor import ( Sensor3DIrradiance, SensorCamera, @@ -44,45 +55,65 @@ def test_create_camera_sensor(speos: Speos): """Test creation of camera sensor.""" p = Project(speos=speos) + sensor_parameters = CameraSensorParameters() # Default value sensor1 = p.create_sensor(name="Camera.1", feature_type=SensorCamera) assert isinstance(sensor1, SensorCamera) - sensor1.set_mode_photometric().set_mode_color().set_red_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum") + sensor1.set_mode_photometric().set_mode_color().red_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum" ) - sensor1.set_mode_photometric().set_mode_color().set_green_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum") + sensor1.set_mode_photometric().set_mode_color().green_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" ) - sensor1.set_mode_photometric().set_mode_color().set_blue_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum") + sensor1.set_mode_photometric().set_mode_color().blue_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" ) + sensor1.commit() assert sensor1.sensor_template_link is not None assert sensor1.sensor_template_link.get().HasField("camera_sensor_template") camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template - assert camera_sensor_template.focal_length == 5.0 - assert camera_sensor_template.imager_distance == 10 + assert camera_sensor_template.focal_length == sensor_parameters.focal_length + assert camera_sensor_template.imager_distance == sensor_parameters.imager_distance assert camera_sensor_template.distortion_file_uri == "" - assert camera_sensor_template.f_number == 20 - assert camera_sensor_template.horz_pixel == 640 - assert camera_sensor_template.vert_pixel == 480 - assert camera_sensor_template.width == 5.0 - assert camera_sensor_template.height == 5.0 + assert camera_sensor_template.f_number == sensor_parameters.f_number + assert camera_sensor_template.horz_pixel == sensor_parameters.horz_pixel + assert camera_sensor_template.vert_pixel == sensor_parameters.vert_pixel + assert camera_sensor_template.width == sensor_parameters.width + assert camera_sensor_template.height == sensor_parameters.height assert camera_sensor_template.HasField("sensor_mode_photometric") mode_photometric = camera_sensor_template.sensor_mode_photometric - assert mode_photometric.acquisition_integration == 0.01 - assert mode_photometric.acquisition_lag_time == 0.0 - assert mode_photometric.transmittance_file_uri == "" + assert ( + mode_photometric.acquisition_integration + == sensor_parameters.sensor_type_parameters.acquisition_integration_time + ) + assert ( + mode_photometric.acquisition_lag_time + == sensor_parameters.sensor_type_parameters.acquisition_lag_time + ) + assert ( + mode_photometric.transmittance_file_uri + == sensor_parameters.sensor_type_parameters.transmittance_file_uri + ) assert math.isclose( a=mode_photometric.gamma_correction, - b=2.2, + b=sensor_parameters.sensor_type_parameters.gamma_correction, rel_tol=1.192092896e-07, ) assert mode_photometric.png_bits == camera_sensor_pb2.EnumSensorCameraPNGBits.PNG_16 assert mode_photometric.HasField("wavelengths_range") - assert mode_photometric.wavelengths_range.w_start == 400 - assert mode_photometric.wavelengths_range.w_end == 700 - assert mode_photometric.wavelengths_range.w_sampling == 13 + assert ( + mode_photometric.wavelengths_range.w_start + == sensor_parameters.sensor_type_parameters.wavelength_range.start + ) + assert ( + mode_photometric.wavelengths_range.w_end + == sensor_parameters.sensor_type_parameters.wavelength_range.end + ) + assert ( + mode_photometric.wavelengths_range.w_sampling + == sensor_parameters.sensor_type_parameters.wavelength_range.sampling + ) assert mode_photometric.HasField("color_mode_color") assert mode_photometric.color_mode_color.red_spectrum_file_uri.endswith( "CameraSensitivityRed.spectrum" @@ -94,72 +125,73 @@ def test_create_camera_sensor(speos: Speos): "CameraSensitivityBlue.spectrum" ) assert mode_photometric.color_mode_color.HasField("balance_mode_none") - assert sensor1._sensor_instance.camera_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] - assert sensor1._sensor_instance.camera_properties.trajectory_file_uri == "" + assert sensor1._sensor_instance.camera_properties.axis_system == sensor_parameters.axis_system + assert ( + sensor1._sensor_instance.camera_properties.trajectory_file_uri + == sensor_parameters.trajectory_fil_uri + ) + assert ( + sensor1.set_mode_photometric().trajectory_file_uri == sensor_parameters.trajectory_fil_uri + ) assert sensor1._sensor_instance.camera_properties.HasField("layer_type_none") # focal_length - sensor1.set_focal_length(value=5.5) + sensor1.focal_length = 5.5 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.focal_length == 5.5 + assert sensor1.focal_length == 5.5 # imager_distance - sensor1.set_imager_distance(value=10.5) + sensor1.imager_distance = 10.5 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.imager_distance == 10.5 + assert sensor1.imager_distance == 10.5 # f_number - sensor1.set_f_number(value=20.5) + sensor1.f_number = 20.5 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.f_number == 20.5 + assert sensor1.f_number == 20.5 # distortion_file_uri - sensor1.set_distortion_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraDistortion_130deg.OPTDistortion") + sensor1.distortion_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraDistortion_130deg.OPTDistortion" ) sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.distortion_file_uri != "" + assert sensor1.distortion_file_uri != "" # horz_pixel - sensor1.set_horz_pixel(value=680) + sensor1.horz_pixel = 680 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.horz_pixel == 680 + assert sensor1.horz_pixel == 680 # vert_pixel - sensor1.set_vert_pixel(value=500) + sensor1.vert_pixel = 500 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.vert_pixel == 500 + assert sensor1.vert_pixel == 500 # width - sensor1.set_width(value=5.5) + sensor1.width = 5.5 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.width == 5.5 + assert sensor1.width == 5.5 # height - sensor1.set_height(value=5.3) + sensor1.height = 5.3 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.height == 5.3 + assert sensor1.height == 5.3 # sensor_mode_geometric sensor1.set_mode_geometric() @@ -169,47 +201,52 @@ def test_create_camera_sensor(speos: Speos): # sensor_mode_photometric sensor1.set_mode_photometric() - sensor1.set_mode_photometric().set_mode_color().set_red_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum") + color = sensor1.photometric.set_mode_color() + color.red_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum" ) - sensor1.set_mode_photometric().set_mode_color().set_green_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum") + color.green_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" ) - sensor1.set_mode_photometric().set_mode_color().set_blue_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum") + color.blue_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" ) sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.HasField("sensor_mode_photometric") # acquisition_integration - sensor1.set_mode_photometric().set_acquisition_integration(value=0.03) + sensor1.photometric.acquisition_integration = 0.03 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.sensor_mode_photometric.acquisition_integration == 0.03 + assert sensor1.photometric.acquisition_integration == 0.03 # acquisition_lag_time - sensor1.set_mode_photometric().set_acquisition_lag_time(value=0.1) + sensor1.photometric.acquisition_lag_time = 0.1 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.sensor_mode_photometric.acquisition_lag_time == 0.1 + assert sensor1.photometric.acquisition_lag_time == 0.1 # transmittance_file_uri - sensor1.set_mode_photometric().set_transmittance_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraTransmittance.spectrum") + sensor1.photometric.transmittance_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraTransmittance.spectrum" ) sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.sensor_mode_photometric.transmittance_file_uri != "" + assert sensor1.photometric.transmittance_file_uri != "" # gamma_correction - sensor1.set_mode_photometric().set_gamma_correction(value=2.5) + sensor1.photometric.gamma_correction = 2.5 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.sensor_mode_photometric.gamma_correction == 2.5 + assert sensor1.photometric.gamma_correction == 2.5 # png_bits - sensor1.set_mode_photometric().set_png_bits_08() + sensor1.photometric.set_png_bits_08() sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert ( @@ -251,18 +288,16 @@ def test_create_camera_sensor(speos: Speos): assert mode_photometric.color_mode_monochromatic.spectrum_file_uri != "" # color_mode_color - sensor1.set_mode_photometric().set_mode_color() - # red_spectrum_file_uri - sensor1.set_mode_photometric().set_mode_color().set_red_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum") + sensor1.set_mode_photometric() + color = sensor1.photometric.set_mode_color() + color.red_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum" ) - # green_spectrum_file_uri - sensor1.set_mode_photometric().set_mode_color().set_green_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum") + color.green_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" ) - # blue_spectrum_file_uri - sensor1.set_mode_photometric().set_mode_color().set_blue_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum") + color.blue_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" ) sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template @@ -278,6 +313,9 @@ def test_create_camera_sensor(speos: Speos): assert mode_photometric.color_mode_color.blue_spectrum_file_uri.endswith( "CameraSensitivityBlue.spectrum" ) + assert color.red_spectrum_file_uri.endswith("CameraSensitivityRed.spectrum") + assert color.green_spectrum_file_uri.endswith("CameraSensitivityGreen.spectrum") + assert color.blue_spectrum_file_uri.endswith("CameraSensitivityBlue.spectrum") # balance_mode_greyworld sensor1.set_mode_photometric().set_mode_color().set_balance_mode_grey_world() @@ -292,27 +330,48 @@ def test_create_camera_sensor(speos: Speos): camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template mode_photometric = camera_sensor_template.sensor_mode_photometric assert mode_photometric.color_mode_color.HasField("balance_mode_userwhite") - assert mode_photometric.color_mode_color.balance_mode_userwhite.red_gain == 1 - assert mode_photometric.color_mode_color.balance_mode_userwhite.green_gain == 1 - assert mode_photometric.color_mode_color.balance_mode_userwhite.blue_gain == 1 + default_userwhites = BalanceModeUserWhiteParameters() + assert ( + mode_photometric.color_mode_color.balance_mode_userwhite.red_gain + == default_userwhites.red_gain + ) + assert ( + mode_photometric.color_mode_color.balance_mode_userwhite.green_gain + == default_userwhites.green_gain + ) + assert ( + mode_photometric.color_mode_color.balance_mode_userwhite.blue_gain + == default_userwhites.blue_gain + ) - sensor1.set_mode_photometric().set_mode_color().set_balance_mode_user_white().set_red_gain( - value=2 - ).set_green_gain(value=3).set_blue_gain(value=4) + balance_mode_user_white = ( + sensor1.set_mode_photometric().set_mode_color().set_balance_mode_user_white() + ) + balance_mode_user_white.red_gain = 2 + balance_mode_user_white.green_gain = 3 + balance_mode_user_white.blue_gain = 4 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template mode_photometric = camera_sensor_template.sensor_mode_photometric assert mode_photometric.color_mode_color.balance_mode_userwhite.red_gain == 2 assert mode_photometric.color_mode_color.balance_mode_userwhite.green_gain == 3 assert mode_photometric.color_mode_color.balance_mode_userwhite.blue_gain == 4 + assert balance_mode_user_white.red_gain == 2 + assert balance_mode_user_white.green_gain == 3 + assert balance_mode_user_white.blue_gain == 4 # balance_mode_display - sensor1.set_mode_photometric().set_mode_color().set_balance_mode_display_primaries().set_red_display_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum") - ).set_green_display_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum") - ).set_blue_display_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum") + display_primaries = ( + sensor1.set_mode_photometric().set_mode_color().set_balance_mode_display_primaries() + ) + display_primaries.red_display_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum" + ) + display_primaries.green_display_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" + ) + display_primaries.blue_display_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" ) sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template @@ -327,6 +386,15 @@ def test_create_camera_sensor(speos: Speos): assert mode_photometric.color_mode_color.balance_mode_display.blue_display_file_uri.endswith( "CameraSensitivityBlue.spectrum" ) + assert display_primaries.red_display_file_uri == str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum" + ) + assert display_primaries.green_display_file_uri == str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" + ) + assert display_primaries.blue_display_file_uri == str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" + ) # balance_mode_none sensor1.set_mode_photometric().set_mode_color().set_balance_mode_none() @@ -336,20 +404,24 @@ def test_create_camera_sensor(speos: Speos): assert mode_photometric.color_mode_color.HasField("balance_mode_none") # wavelengths_range - sensor1.set_mode_photometric().set_wavelengths_range().set_start(value=430).set_end( - value=750 - ).set_sampling(value=15) + wavelengths_range = sensor1.photometric.set_wavelengths_range() + wavelengths_range.start = 430 + wavelengths_range.end = 750 + wavelengths_range.sampling = 15 sensor1.commit() camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template mode_photometric = camera_sensor_template.sensor_mode_photometric assert mode_photometric.wavelengths_range.w_start == 430 assert mode_photometric.wavelengths_range.w_end == 750 assert mode_photometric.wavelengths_range.w_sampling == 15 + assert wavelengths_range.start == 430 + assert wavelengths_range.end == 750 + assert wavelengths_range.sampling == 15 # Properties # axis_system - sensor1.set_axis_system(axis_system=[10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + sensor1.axis_system = [10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1] sensor1.commit() assert sensor1._sensor_instance.camera_properties.axis_system == [ 10, @@ -365,7 +437,20 @@ def test_create_camera_sensor(speos: Speos): 0, 1, ] - + assert sensor1.axis_system == [ + 10, + 50, + 20, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + ] # Properties for camera photometric # layer_type_source @@ -379,10 +464,12 @@ def test_create_camera_sensor(speos: Speos): assert sensor1._sensor_instance.camera_properties.HasField("layer_type_none") # test distrotion v1,v2,v3 - sensor1.set_f_number().set_imager_distance().set_focal_length() + sensor1.focal_length = 5.0 + sensor1.imager_distance = 10.0 + sensor1.f_number = 20.0 sensor1.commit() - sensor1.set_distortion_file_uri( - str(Path(test_path) / "CameraInputFiles" / "distortionV{}.OPTDistortion".format(2)) + sensor1.distortion_file_uri = str( + Path(test_path) / "CameraInputFiles" / "distortionV{}.OPTDistortion".format(2) ) camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.f_number == 20.0 @@ -393,10 +480,12 @@ def test_create_camera_sensor(speos: Speos): assert camera_sensor_template.f_number == 0 assert camera_sensor_template.imager_distance == 0 assert camera_sensor_template.focal_length == 0 - sensor1.set_distortion_file_uri( - str(Path(test_path) / "CameraInputFiles" / "distortionV{}.OPTDistortion".format(1)) + sensor1.distortion_file_uri = str( + Path(test_path) / "CameraInputFiles" / "distortionV{}.OPTDistortion".format(1) ) - sensor1.set_f_number().set_imager_distance().set_focal_length() + sensor1.focal_length = 5.0 + sensor1.imager_distance = 10.0 + sensor1.f_number = 20.0 camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.f_number == 0 assert camera_sensor_template.imager_distance == 0 @@ -406,8 +495,8 @@ def test_create_camera_sensor(speos: Speos): assert camera_sensor_template.f_number == 20.0 assert camera_sensor_template.imager_distance == 10.0 assert camera_sensor_template.focal_length == 5.0 - sensor1.set_distortion_file_uri( - str(Path(test_path) / "CameraInputFiles" / "distortionV{}.OPTDistortion".format(4)) + sensor1.distortion_file_uri = str( + Path(test_path) / "CameraInputFiles" / "distortionV{}.OPTDistortion".format(4) ) camera_sensor_template = sensor1.sensor_template_link.get().camera_sensor_template assert camera_sensor_template.f_number == 20.0 @@ -442,7 +531,7 @@ def test_create_irradiance_sensor(speos: Speos): [0, 1, 2] ).set_normals([0, 0, 1, 0, 0, 1, 0, 0, 1]) root_part.commit() - + sensor_parameter = IrradianceSensorParameters() # Default value sensor1 = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) sensor1.commit() @@ -452,32 +541,19 @@ def test_create_irradiance_sensor(speos: Speos): assert sensor_template.HasField("sensor_type_photometric") assert sensor_template.HasField("illuminance_type_planar") assert sensor_template.HasField("dimensions") - assert sensor_template.dimensions.x_start == -50.0 - assert sensor_template.dimensions.x_end == 50.0 - assert sensor_template.dimensions.x_sampling == 100 - assert sensor_template.dimensions.y_start == -50.0 - assert sensor_template.dimensions.y_end == 50.0 - assert sensor_template.dimensions.y_sampling == 100 + assert sensor_template.dimensions.x_start == sensor_parameter.dimensions.x_start + assert sensor_template.dimensions.x_end == sensor_parameter.dimensions.x_end + assert sensor_template.dimensions.x_sampling == sensor_parameter.dimensions.x_sampling + assert sensor_template.dimensions.y_start == sensor_parameter.dimensions.y_start + assert sensor_template.dimensions.y_end == sensor_parameter.dimensions.y_end + assert sensor_template.dimensions.y_sampling == sensor_parameter.dimensions.y_sampling assert sensor1._sensor_instance.HasField("irradiance_properties") irra_properties = sensor1._sensor_instance.irradiance_properties - assert irra_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] + assert irra_properties.axis_system == sensor_parameter.axis_system assert irra_properties.HasField("layer_type_none") assert irra_properties.ray_file_type == sensor1._sensor_instance.EnumRayFileType.RayFileNone assert irra_properties.integration_direction == [] - + color_parameters = ColorimetricParameters() # sensor_type_colorimetric # default wavelengths range sensor1.set_type_colorimetric() @@ -485,25 +561,38 @@ def test_create_irradiance_sensor(speos: Speos): sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.HasField("sensor_type_colorimetric") assert sensor_template.sensor_type_colorimetric.HasField("wavelengths_range") - assert sensor_template.sensor_type_colorimetric.wavelengths_range.w_start == 400 - assert sensor_template.sensor_type_colorimetric.wavelengths_range.w_end == 700 - assert sensor_template.sensor_type_colorimetric.wavelengths_range.w_sampling == 13 + assert ( + sensor_template.sensor_type_colorimetric.wavelengths_range.w_start + == color_parameters.wavelength_range.start + ) + assert ( + sensor_template.sensor_type_colorimetric.wavelengths_range.w_end + == color_parameters.wavelength_range.end + ) + assert ( + sensor_template.sensor_type_colorimetric.wavelengths_range.w_sampling + == color_parameters.wavelength_range.sampling + ) # chosen wavelengths range - sensor1.set_type_colorimetric().set_wavelengths_range().set_start(value=450).set_end( - value=800 - ).set_sampling(value=15) + wavelengths_range = sensor1.set_type_colorimetric().set_wavelengths_range() + wavelengths_range.start = 450 + wavelengths_range.end = 800 + wavelengths_range.sampling = 15 sensor1.commit() sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.sensor_type_colorimetric.wavelengths_range.w_start == 450 assert sensor_template.sensor_type_colorimetric.wavelengths_range.w_end == 800 assert sensor_template.sensor_type_colorimetric.wavelengths_range.w_sampling == 15 - + assert wavelengths_range.start == 450 + assert wavelengths_range.end == 800 + assert wavelengths_range.sampling == 15 # sensor_type_radiometric sensor1.set_type_radiometric() sensor1.commit() sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.HasField("sensor_type_radiometric") + spectral_parameters = SpectralParameters() # sensor_type_spectral # default wavelengths range sensor1.set_type_spectral() @@ -511,18 +600,31 @@ def test_create_irradiance_sensor(speos: Speos): sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.HasField("sensor_type_spectral") assert sensor_template.sensor_type_spectral.HasField("wavelengths_range") - assert sensor_template.sensor_type_spectral.wavelengths_range.w_start == 400 - assert sensor_template.sensor_type_spectral.wavelengths_range.w_end == 700 - assert sensor_template.sensor_type_spectral.wavelengths_range.w_sampling == 13 + assert ( + sensor_template.sensor_type_spectral.wavelengths_range.w_start + == spectral_parameters.wavelength_range.start + ) + assert ( + sensor_template.sensor_type_spectral.wavelengths_range.w_end + == spectral_parameters.wavelength_range.end + ) + assert ( + sensor_template.sensor_type_spectral.wavelengths_range.w_sampling + == spectral_parameters.wavelength_range.sampling + ) # chosen wavelengths range - sensor1.set_type_spectral().set_wavelengths_range().set_start(value=450).set_end( - value=800 - ).set_sampling(value=15) + wavelengths_range = sensor1.set_type_spectral().set_wavelengths_range() + wavelengths_range.start = 450 + wavelengths_range.end = 800 + wavelengths_range.sampling = 15 sensor1.commit() sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.sensor_type_spectral.wavelengths_range.w_start == 450 assert sensor_template.sensor_type_spectral.wavelengths_range.w_end == 800 assert sensor_template.sensor_type_spectral.wavelengths_range.w_sampling == 15 + assert wavelengths_range.start == 450 + assert wavelengths_range.end == 800 + assert wavelengths_range.sampling == 15 # sensor_type_photometric sensor1.set_type_photometric() @@ -555,18 +657,24 @@ def test_create_irradiance_sensor(speos: Speos): # assert sensor_template.HasField("illuminance_type_semi_cylindrical") # illuminance_type_planar - sensor1.set_illuminance_type_planar(integration_direction=[0, 0, -1]) + sensor1.set_illuminance_type_planar() + sensor1.integration_direction = [0, 0, -1] sensor1.commit() sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.HasField("illuminance_type_planar") + assert sensor1.integration_direction == [0, 0, -1] - sensor1.set_illuminance_type_planar(integration_direction=None) # cancel integration direction + sensor1.integration_direction = None # cancel integration direction assert irra_properties.integration_direction == [] + assert sensor1.integration_direction == [] # dimensions - sensor1.set_dimensions().set_x_start(value=-10).set_x_end(value=10).set_x_sampling( - value=60 - ).set_y_start(value=-20).set_y_end(value=20).set_y_sampling(value=120) + sensor1.dimensions.x_start = -10 + sensor1.dimensions.x_end = 10 + sensor1.dimensions.x_sampling = 60 + sensor1.dimensions.y_start = -20 + sensor1.dimensions.y_end = 20 + sensor1.dimensions.y_sampling = 120 sensor1.commit() sensor_template = sensor1.sensor_template_link.get().irradiance_sensor_template assert sensor_template.HasField("dimensions") @@ -579,7 +687,7 @@ def test_create_irradiance_sensor(speos: Speos): # properties # axis_system - sensor1.set_axis_system([10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + sensor1.axis_system = [10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1] sensor1.commit() assert irra_properties.axis_system == [ 10, @@ -595,7 +703,7 @@ def test_create_irradiance_sensor(speos: Speos): 0, 1, ] - + assert sensor1.axis_system == [10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1] # ray_file_type sensor1.set_ray_file_type_classic() sensor1.commit() @@ -629,20 +737,20 @@ def test_create_irradiance_sensor(speos: Speos): assert irra_properties.HasField("layer_type_source") # layer_type_face - sensor1.set_layer_type_face().set_sca_filtering_mode_intersected_one_time().set_layers( - values=[ - sensor.BaseSensor.FaceLayer( - name="Layer.1", geometries=[GeoRef.from_native_link("TheBodyB")] - ), - sensor.BaseSensor.FaceLayer( - name="Layer.2", - geometries=[ - GeoRef.from_native_link("TheBodyC/TheFaceC1"), - GeoRef.from_native_link("TheBodyC/TheFaceC2"), - ], - ), - ] + layer1 = sensor.BaseSensor.FaceLayer( + name="Layer.1", geometries=[GeoRef.from_native_link("TheBodyB")] ) + layer1.geometry = [body_b] + layer2 = sensor.BaseSensor.FaceLayer( + name="Layer.2", + geometries=[ + GeoRef.from_native_link("TheBodyC/TheFaceC1"), + GeoRef.from_native_link("TheBodyC/TheFaceC2"), + ], + ) + layer_face = sensor1.set_layer_type_face() + layer_face.set_sca_filtering_mode_intersected_one_time() + layer_face.layers = [layer1, layer2] sensor1.commit() assert irra_properties.HasField("layer_type_face") assert ( @@ -657,8 +765,11 @@ def test_create_irradiance_sensor(speos: Speos): "TheBodyC/TheFaceC1", "TheBodyC/TheFaceC2", ] - - sensor1.set_layer_type_face().set_sca_filtering_mode_last_impact() + assert layer1.name == "Layer.1" + assert layer2.name == "Layer.2" + for geo_path in layer1.geometry: + assert isinstance(geo_path, GeoRef) + layer_face.set_sca_filtering_mode_last_impact() sensor1.commit() assert ( irra_properties.layer_type_face.sca_filtering_mode @@ -666,11 +777,12 @@ def test_create_irradiance_sensor(speos: Speos): ) # layer_type_sequence - sensor1.set_layer_type_sequence().set_maximum_nb_of_sequence( - value=5 - ).set_define_sequence_per_faces() + layer_by_sequence = sensor1.set_layer_type_sequence() + layer_by_sequence.maximum_nb_of_sequence = 5 + layer_by_sequence.set_define_sequence_per_faces() sensor1.commit() assert irra_properties.HasField("layer_type_sequence") + assert layer_by_sequence.maximum_nb_of_sequence == 5 assert irra_properties.layer_type_sequence.maximum_nb_of_sequence == 5 assert ( irra_properties.layer_type_sequence.define_sequence_per @@ -691,9 +803,10 @@ def test_create_irradiance_sensor(speos: Speos): assert irra_properties.HasField("layer_type_polarization") # layer_type_incidence_angle - sensor1.set_layer_type_incidence_angle().set_sampling(value=8) + sensor1.set_layer_type_incidence_angle().sampling = 8 sensor1.commit() assert irra_properties.HasField("layer_type_incidence_angle") + assert sensor1.set_layer_type_incidence_angle().sampling == 8 assert irra_properties.layer_type_incidence_angle.sampling == 8 # layer_type_none @@ -702,15 +815,13 @@ def test_create_irradiance_sensor(speos: Speos): assert irra_properties.HasField("layer_type_none") # output_face_geometries - sensor1.set_output_face_geometries( - geometries=[ - GeoRef.from_native_link(geopath="TheBodyB/TheFaceB1"), - GeoRef.from_native_link(geopath="TheBodyB/TheFaceB2"), - ] - ) + sensor1.output_face_geometries = [ + GeoRef.from_native_link(geopath="TheBodyB/TheFaceB1"), + body_b, + ] assert irra_properties.output_face_geometries.geo_paths == [ "TheBodyB/TheFaceB1", - "TheBodyB/TheFaceB2", + "TheBodyB", ] # output_face_geometries @@ -735,126 +846,131 @@ def test_create_radiance_sensor(speos: Speos): [0, 1, 2] ).set_normals([0, 0, 1, 0, 0, 1, 0, 0, 1]) root_part.commit() - + sensor_parameter = RadianceSensorParameters() # Default value sensor1 = p.create_sensor(name="Radiance.1", feature_type=SensorRadiance) sensor1.commit() assert sensor1.sensor_template_link is not None assert sensor1.sensor_template_link.get().HasField("radiance_sensor_template") assert sensor1.sensor_template_link.get().name == "Radiance.1" - assert sensor1.sensor_template_link.get().radiance_sensor_template.HasField( - "sensor_type_photometric" - ) - assert sensor1.sensor_template_link.get().radiance_sensor_template.focal == 250 - assert sensor1.sensor_template_link.get().radiance_sensor_template.integration_angle == 5 - assert sensor1.sensor_template_link.get().radiance_sensor_template.HasField("dimensions") - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.x_start == -50.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.x_end == 50.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.x_sampling == 100 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.y_start == -50.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.y_end == 50.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.y_sampling == 100 + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.HasField("sensor_type_photometric") + assert template.focal == sensor_parameter.focal_length + assert sensor1.focal == sensor_parameter.focal_length + assert template.integration_angle == sensor_parameter.integration_angle + assert sensor1.integration_angle == sensor_parameter.integration_angle + assert template.HasField("dimensions") + assert template.dimensions.x_start == sensor_parameter.dimensions.x_start + assert template.dimensions.x_end == sensor_parameter.dimensions.x_end + assert template.dimensions.x_sampling == sensor_parameter.dimensions.x_sampling + assert sensor1.set_dimensions().x_sampling == sensor_parameter.dimensions.x_sampling + assert template.dimensions.y_start == sensor_parameter.dimensions.y_start + assert template.dimensions.y_end == sensor_parameter.dimensions.y_end + assert template.dimensions.y_sampling == sensor_parameter.dimensions.y_sampling + assert sensor1.set_dimensions().y_sampling == sensor_parameter.dimensions.y_sampling assert sensor1._sensor_instance.HasField("radiance_properties") radiance_properties = sensor1._sensor_instance.radiance_properties - assert radiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] + assert radiance_properties.axis_system == sensor_parameter.axis_system assert radiance_properties.HasField("layer_type_none") assert radiance_properties.observer_point == [] # sensor_type_radiometric sensor1.set_type_radiometric() sensor1.commit() - assert sensor1.sensor_template_link.get().radiance_sensor_template.HasField( - "sensor_type_radiometric" - ) + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.HasField("sensor_type_radiometric") - # sensor_type_spectral + # sensor_type_colorimetric + color_parameters = SpectralParameters() # default wavelengths range - sensor1.set_type_spectral() + sensor1.set_type_colorimetric() sensor1.commit() - assert sensor1.sensor_template_link.get().radiance_sensor_template.HasField( - "sensor_type_spectral" - ) + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.HasField("sensor_type_colorimetric") + assert template.sensor_type_colorimetric.HasField("wavelengths_range") assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.HasField( - "wavelengths_range" - ) + template.sensor_type_colorimetric.wavelengths_range.w_start + == color_parameters.wavelength_range.start ) assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.wavelengths_range.w_start - == 400 + template.sensor_type_colorimetric.wavelengths_range.w_end + == color_parameters.wavelength_range.end ) assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.wavelengths_range.w_end - == 700 + template.sensor_type_colorimetric.wavelengths_range.w_sampling + == color_parameters.wavelength_range.sampling ) - assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.wavelengths_range.w_sampling - == 13 - ) - # chosen wavelengths range - sensor1.set_type_spectral().set_wavelengths_range().set_start(value=450).set_end( - value=800 - ).set_sampling(value=15) + + # sensor_type_spectral + spectral_parameters = SpectralParameters() + # default wavelengths range + sensor1.set_type_spectral() sensor1.commit() + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.HasField("sensor_type_spectral") + assert template.sensor_type_spectral.HasField("wavelengths_range") assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.wavelengths_range.w_start - == 450 + template.sensor_type_spectral.wavelengths_range.w_start + == spectral_parameters.wavelength_range.start ) assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.wavelengths_range.w_end - == 800 + template.sensor_type_spectral.wavelengths_range.w_end + == spectral_parameters.wavelength_range.end ) assert ( - sensor1.sensor_template_link.get().radiance_sensor_template.sensor_type_spectral.wavelengths_range.w_sampling - == 15 + template.sensor_type_spectral.wavelengths_range.w_sampling + == spectral_parameters.wavelength_range.sampling ) + # chosen wavelengths range + wavelengths_range = sensor1.set_type_spectral().set_wavelengths_range() + wavelengths_range.start = 450 + wavelengths_range.end = 800 + wavelengths_range.sampling = 15 + sensor1.commit() + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.sensor_type_spectral.wavelengths_range.w_start == 450 + assert template.sensor_type_spectral.wavelengths_range.w_end == 800 + assert template.sensor_type_spectral.wavelengths_range.w_sampling == 15 + # sensor_type_photometric sensor1.set_type_photometric() sensor1.commit() - assert sensor1.sensor_template_link.get().radiance_sensor_template.HasField( - "sensor_type_photometric" - ) + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.HasField("sensor_type_photometric") # focal - sensor1.set_focal(value=150.5) + sensor1.focal = 150.5 sensor1.commit() - assert sensor1.sensor_template_link.get().radiance_sensor_template.focal == 150.5 + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.focal == 150.5 # integration_angle - sensor1.set_integration_angle(value=4.5) + sensor1.integration_angle = 4.5 sensor1.commit() - assert sensor1.sensor_template_link.get().radiance_sensor_template.integration_angle == 4.5 + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.integration_angle == 4.5 # dimensions - sensor1.set_dimensions().set_x_start(value=-10).set_x_end(value=10).set_x_sampling( - value=60 - ).set_y_start(value=-20).set_y_end(value=20).set_y_sampling(value=120) - sensor1.commit() - assert sensor1.sensor_template_link.get().radiance_sensor_template.HasField("dimensions") - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.x_start == -10.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.x_end == 10.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.x_sampling == 60 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.y_start == -20.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.y_end == 20.0 - assert sensor1.sensor_template_link.get().radiance_sensor_template.dimensions.y_sampling == 120 + sensor1.dimensions.x_start = -10 + sensor1.dimensions.x_end = 10 + sensor1.dimensions.x_sampling = 60 + sensor1.dimensions.y_start = -20 + sensor1.dimensions.y_end = 20 + sensor1.dimensions.y_sampling = 120 + sensor1.commit() + template = sensor1.sensor_template_link.get().radiance_sensor_template + assert template.HasField("dimensions") + assert template.dimensions.x_start == -10.0 + assert template.dimensions.x_end == 10.0 + assert template.dimensions.x_sampling == 60 + assert template.dimensions.y_start == -20.0 + assert template.dimensions.y_end == 20.0 + assert template.dimensions.y_sampling == 120 # properties # axis_system - sensor1.set_axis_system([10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + sensor1.axis_system = [10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1] sensor1.commit() assert radiance_properties.axis_system == [ 10, @@ -870,9 +986,15 @@ def test_create_radiance_sensor(speos: Speos): 0, 1, ] + assert sensor1.axis_system == [10, 50, 20, 1, 0, 0, 0, 1, 0, 0, 0, 1] # observer_point - sensor1.set_observer_point([20, 30, 50]) + sensor1.observer_point = [20, 30, 50] + assert sensor1.observer_point == [ + 20, + 30, + 50, + ] sensor1.commit() assert radiance_properties.observer_point == [ 20, @@ -880,8 +1002,7 @@ def test_create_radiance_sensor(speos: Speos): 50, ] - # cancel observer point chosen previously - sensor1.set_observer_point(value=None) + sensor1.observer_point = None # cancel observer point chosen previously sensor1.commit() assert radiance_properties.observer_point == [] @@ -891,20 +1012,18 @@ def test_create_radiance_sensor(speos: Speos): assert radiance_properties.HasField("layer_type_source") # layer_type_face - sensor1.set_layer_type_face().set_sca_filtering_mode_intersected_one_time().set_layers( - values=[ - sensor.BaseSensor.FaceLayer( - name="Layer.1", geometries=[GeoRef.from_native_link("TheBodyB")] - ), - sensor.BaseSensor.FaceLayer( - name="Layer.2", - geometries=[ - GeoRef.from_native_link("TheBodyC/TheFaceC1"), - GeoRef.from_native_link("TheBodyC/TheFaceC2"), - ], - ), - ] - ) + sensor1.set_layer_type_face().set_sca_filtering_mode_intersected_one_time().layers = [ + sensor.BaseSensor.FaceLayer( + name="Layer.1", geometries=[GeoRef.from_native_link("TheBodyB")] + ), + sensor.BaseSensor.FaceLayer( + name="Layer.2", + geometries=[ + GeoRef.from_native_link("TheBodyC/TheFaceC1"), + GeoRef.from_native_link("TheBodyC/TheFaceC2"), + ], + ), + ] sensor1.commit() assert radiance_properties.HasField("layer_type_face") assert ( @@ -929,9 +1048,8 @@ def test_create_radiance_sensor(speos: Speos): ) # layer_type_sequence - sensor1.set_layer_type_sequence().set_maximum_nb_of_sequence( - value=5 - ).set_define_sequence_per_faces() + sensor1.set_layer_type_sequence().maximum_nb_of_sequence = 5 + sensor1.set_layer_type_sequence().set_define_sequence_per_faces() sensor1.commit() assert radiance_properties.HasField("layer_type_sequence") assert radiance_properties.layer_type_sequence.maximum_nb_of_sequence == 5 @@ -973,7 +1091,8 @@ def test_create_3d_irradiance_sensor(speos: Speos): ) body = p.find(name="PrismBody", name_regex=True, feature_type=Body)[0] sensor_3d = p.create_sensor(name="3d", feature_type=Sensor3DIrradiance) - sensor_3d.set_geometries([body.geo_path]) + sensor_3d.geometries = [body.geo_path] + sensor_3d.geometries = [body] sensor_3d.commit() # when creating 3D irradiance, default properties: @@ -981,7 +1100,6 @@ def test_create_3d_irradiance_sensor(speos: Speos): # planar integration # layer type none # measure reflection, transmission, absorption - backend_photometric_info = sensor_3d.sensor_template_link.get() assert sensor_3d.sensor_template_link is not None assert backend_photometric_info.name == "3d" @@ -1053,15 +1171,17 @@ def test_create_3d_irradiance_sensor(speos: Speos): # when change type into colorimetric, default properties: # colorimetric + color_parameters = ColorimetricParameters() # wavelength start 400 with end 700 # layer type none sensor_3d.set_type_colorimetric() sensor_3d.commit() assert sensor_3d.sensor_template_link.get().irradiance_3d.HasField("type_colorimetric") colorimetric_info = sensor_3d.sensor_template_link.get().irradiance_3d.type_colorimetric - assert colorimetric_info.wavelength_start == 400 - assert colorimetric_info.wavelength_end == 700 - sensor_3d.set_type_colorimetric().set_wavelengths_range().set_start(500) + assert colorimetric_info.wavelength_start == color_parameters.wavelength_range.start + assert colorimetric_info.wavelength_end == color_parameters.wavelength_range.end + wavelengths_range = sensor_3d.set_type_colorimetric().set_wavelengths_range() + wavelengths_range.start = 500 sensor_3d.commit() colorimetric_info = sensor_3d.sensor_template_link.get().irradiance_3d.type_colorimetric assert sensor_3d.get(key="wavelength_start") == 500 @@ -1121,7 +1241,7 @@ def test_commit_sensor(speos: Speos): assert p.scene_link.get().sensors[0] == sensor1._sensor_instance # Change only in local not committed - sensor1.set_axis_system([10, 10, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + sensor1.axis_system = [10, 10, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1] assert p.scene_link.get().sensors[0] != sensor1._sensor_instance sensor1.delete() @@ -1133,42 +1253,21 @@ def test_reset_sensor(speos: Speos): # Create + commit sensor1 = p.create_sensor(name="Sensor.1", feature_type=SensorIrradiance) + sensor_parameter = IrradianceSensorParameters() sensor1.commit() - assert sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start == -50 # local assert ( - sensor1.sensor_template_link.get().irradiance_sensor_template.dimensions.x_start == -50 + sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start + == sensor_parameter.dimensions.x_start + ) # local + assert ( + sensor1.sensor_template_link.get().irradiance_sensor_template.dimensions.x_start + == sensor_parameter.dimensions.x_start ) # server - assert sensor1._sensor_instance.irradiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] # local - assert p.scene_link.get().sensors[0].irradiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] # server + assert sensor1._sensor_instance.irradiance_properties.axis_system == ORIGIN # local + assert p.scene_link.get().sensors[0].irradiance_properties.axis_system == ORIGIN # server - sensor1.set_dimensions().set_x_start(0) - sensor1.set_axis_system([1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + sensor1.dimensions.x_start = 0 + sensor1.axis_system = [1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1] assert sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start == 0 # local assert ( sensor1.sensor_template_link.get().irradiance_sensor_template.dimensions.x_start == -50 @@ -1187,55 +1286,20 @@ def test_reset_sensor(speos: Speos): 0, 1, ] # local - assert p.scene_link.get().sensors[0].irradiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] # server + assert p.scene_link.get().sensors[0].irradiance_properties.axis_system == ORIGIN # server # Ask for reset sensor1.reset() - assert sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start == -50 # local assert ( - sensor1.sensor_template_link.get().irradiance_sensor_template.dimensions.x_start == -50 + sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start + == sensor_parameter.dimensions.x_start + ) # local + assert ( + sensor1.sensor_template_link.get().irradiance_sensor_template.dimensions.x_start + == sensor_parameter.dimensions.x_start ) # server - assert sensor1._sensor_instance.irradiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] # local - assert p.scene_link.get().sensors[0].irradiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] # server + assert sensor1._sensor_instance.irradiance_properties.axis_system == ORIGIN # local + assert p.scene_link.get().sensors[0].irradiance_properties.axis_system == ORIGIN # server sensor1.delete() @@ -1244,7 +1308,8 @@ def test_reset_sensor(speos: Speos): def test_irradiance_modify_after_reset(speos: Speos): """Test reset of irradiance sensor, and then modify.""" p = Project(speos=speos) - + wl = WavelengthsRangeParameters() + sensor_parameter = IrradianceSensorParameters() # Create + commit sensor1 = p.create_sensor(name="Sensor.1", feature_type=SensorIrradiance) sensor1.set_type_spectral() @@ -1263,34 +1328,24 @@ def test_irradiance_modify_after_reset(speos: Speos): # Intermediate class for type : spectral assert ( sensor1._sensor_template.irradiance_sensor_template.sensor_type_spectral.wavelengths_range.w_start - == 400 + == wl.start ) - sensor1.set_type_spectral().set_wavelengths_range().set_start(value=500) + sensor1.set_type_spectral().set_wavelengths_range().start = 500 assert ( sensor1._sensor_template.irradiance_sensor_template.sensor_type_spectral.wavelengths_range.w_start == 500 ) # Intermediate class for dimensions - assert sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start == -50 - sensor1.set_dimensions().set_x_start(-100) + assert ( + sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start + == sensor_parameter.dimensions.x_start + ) + sensor1.set_dimensions().x_start = -100 assert sensor1._sensor_template.irradiance_sensor_template.dimensions.x_start == -100 # Props - assert sensor1._sensor_instance.irradiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] - sensor1.set_axis_system([50, 20, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + assert sensor1._sensor_instance.irradiance_properties.axis_system == ORIGIN + sensor1.axis_system = [50, 20, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1] assert sensor1._sensor_instance.irradiance_properties.axis_system == [ 50, 20, @@ -1306,11 +1361,12 @@ def test_irradiance_modify_after_reset(speos: Speos): 1, ] # Intermediate class for layer type + layer_parameters = LayerBySequenceParameters() assert ( sensor1._sensor_instance.irradiance_properties.layer_type_sequence.maximum_nb_of_sequence - == 10 + == layer_parameters.maximum_nb_of_sequence ) - sensor1.set_layer_type_sequence().set_maximum_nb_of_sequence(value=15) + sensor1.set_layer_type_sequence().maximum_nb_of_sequence = 15 assert ( sensor1._sensor_instance.irradiance_properties.layer_type_sequence.maximum_nb_of_sequence == 15 @@ -1323,7 +1379,8 @@ def test_irradiance_modify_after_reset(speos: Speos): def test_radiance_modify_after_reset(speos: Speos): """Test reset of radiance sensor, and then modify.""" p = Project(speos=speos) - + sensor_parameter = RadianceSensorParameters() + wl = WavelengthsRangeParameters() # Create + commit sensor1 = p.create_sensor(name="Sensor.1", feature_type=SensorRadiance) assert isinstance(sensor1, SensorRadiance) @@ -1336,40 +1393,64 @@ def test_radiance_modify_after_reset(speos: Speos): # Modify after a reset # Template - assert sensor1._sensor_template.radiance_sensor_template.focal == 250 - sensor1.set_focal(value=100) + assert sensor1._sensor_template.radiance_sensor_template.focal == sensor_parameter.focal_length + sensor1.focal = 100 assert sensor1._sensor_template.radiance_sensor_template.focal == 100 # Intermediate class for type : colorimetric assert ( sensor1._sensor_template.radiance_sensor_template.sensor_type_colorimetric.wavelengths_range.w_start - == 400 + == wl.start ) - sensor1.set_type_colorimetric().set_wavelengths_range().set_start(value=500) + sensor1.set_type_colorimetric().set_wavelengths_range().start = 500 + assert ( + sensor1._sensor_template.radiance_sensor_template.sensor_type_colorimetric.wavelengths_range.w_start + == 500 + ) + assert ( + sensor1._sensor_template.radiance_sensor_template.sensor_type_colorimetric.wavelengths_range.w_end + == wl.end + ) + sensor1.set_type_colorimetric().set_wavelengths_range().start = 500 assert ( sensor1._sensor_template.radiance_sensor_template.sensor_type_colorimetric.wavelengths_range.w_start == 500 ) # Intermediate class for dimensions - assert sensor1._sensor_template.radiance_sensor_template.dimensions.x_start == -50 - sensor1.set_dimensions().set_x_start(-100) + assert ( + sensor1._sensor_template.radiance_sensor_template.dimensions.x_start + == sensor_parameter.dimensions.x_start + ) + sensor1.set_dimensions().x_start = -100 assert sensor1._sensor_template.radiance_sensor_template.dimensions.x_start == -100 + assert sensor1.set_dimensions().x_start == -100 - # Props - assert sensor1._sensor_instance.radiance_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] - sensor1.set_axis_system([50, 20, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + assert ( + sensor1._sensor_template.radiance_sensor_template.dimensions.x_end + == sensor_parameter.dimensions.x_end + ) + sensor1.set_dimensions().x_end = 100 + assert sensor1._sensor_template.radiance_sensor_template.dimensions.x_end == 100 + assert sensor1.set_dimensions().x_end == 100 + + assert ( + sensor1._sensor_template.radiance_sensor_template.dimensions.y_start + == sensor_parameter.dimensions.y_start + ) + sensor1.set_dimensions().y_start = -100 + assert sensor1._sensor_template.radiance_sensor_template.dimensions.y_start == -100 + assert sensor1.set_dimensions().y_start == -100 + + assert ( + sensor1._sensor_template.radiance_sensor_template.dimensions.y_end + == sensor_parameter.dimensions.y_end + ) + sensor1.set_dimensions().y_end = 100 + assert sensor1._sensor_template.radiance_sensor_template.dimensions.y_end == 100 + assert sensor1.set_dimensions().y_end == 100 + + ## Props + assert sensor1._sensor_instance.radiance_properties.axis_system == ORIGIN + sensor1.axis_system = [50, 20, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1] assert sensor1._sensor_instance.radiance_properties.axis_system == [ 50, 20, @@ -1385,11 +1466,12 @@ def test_radiance_modify_after_reset(speos: Speos): 1, ] # Intermediate class for layer type + layer_parameters = LayerBySequenceParameters() assert ( sensor1._sensor_instance.radiance_properties.layer_type_sequence.maximum_nb_of_sequence - == 10 + == layer_parameters.maximum_nb_of_sequence ) - sensor1.set_layer_type_sequence().set_maximum_nb_of_sequence(value=15) + sensor1.set_layer_type_sequence().maximum_nb_of_sequence = 15 assert ( sensor1._sensor_instance.radiance_properties.layer_type_sequence.maximum_nb_of_sequence == 15 @@ -1402,19 +1484,20 @@ def test_radiance_modify_after_reset(speos: Speos): def test_camera_modify_after_reset(speos: Speos): """Test reset of camera sensor, and then modify.""" p = Project(speos=speos) - + sensor_parameter = CameraSensorParameters() # Create + commit sensor1 = p.create_sensor(name="Sensor.1", feature_type=SensorCamera) assert isinstance(sensor1, SensorCamera) - sensor1.set_mode_photometric().set_mode_color().set_balance_mode_user_white() - sensor1.set_mode_photometric().set_mode_color().set_red_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum") + color = sensor1.set_mode_photometric().set_mode_color() + color.set_balance_mode_user_white() + color.red_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityRed.spectrum" ) - sensor1.set_mode_photometric().set_mode_color().set_green_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum") + color.green_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityGreen.spectrum" ) - sensor1.set_mode_photometric().set_mode_color().set_blue_spectrum_file_uri( - uri=str(Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum") + color.blue_spectrum_file_uri = str( + Path(test_path) / "CameraInputFiles" / "CameraSensitivityBlue.spectrum" ) sensor1.set_mode_photometric().set_layer_type_source() sensor1.commit() @@ -1424,48 +1507,48 @@ def test_camera_modify_after_reset(speos: Speos): # Modify after a reset # Template - assert sensor1._sensor_template.camera_sensor_template.focal_length == 5 - sensor1.set_focal_length(value=40) + assert ( + sensor1._sensor_template.camera_sensor_template.focal_length + == sensor_parameter.focal_length + ) + sensor1.focal_length = 40 assert sensor1._sensor_template.camera_sensor_template.focal_length == 40 # Intermediate class for mode : photometric + wavelengths assert ( sensor1._sensor_template.camera_sensor_template.sensor_mode_photometric.wavelengths_range.w_start - == 400 + == sensor_parameter.sensor_type_parameters.wavelength_range.start ) - sensor1.set_mode_photometric().set_wavelengths_range().set_start(value=500) + sensor1.set_mode_photometric().set_wavelengths_range().start = 500 assert ( sensor1._sensor_template.camera_sensor_template.sensor_mode_photometric.wavelengths_range.w_start == 500 ) + assert ( + sensor1._sensor_template.camera_sensor_template.sensor_mode_photometric.wavelengths_range.w_end + == sensor_parameter.sensor_type_parameters.wavelength_range.end + ) + sensor1.set_mode_photometric().set_wavelengths_range().end = 800 + assert ( + sensor1._sensor_template.camera_sensor_template.sensor_mode_photometric.wavelengths_range.w_end + == 800 + ) # Intermediate class for color mode + balance mode + user_white = BalanceModeUserWhiteParameters() assert ( sensor1._sensor_template.camera_sensor_template.sensor_mode_photometric.color_mode_color.balance_mode_userwhite.blue_gain - == 1 - ) - sensor1.set_mode_photometric().set_mode_color().set_balance_mode_user_white().set_blue_gain( - value=0.5 + == user_white.blue_gain ) + color = sensor1.set_mode_photometric().set_mode_color() + white_mode = color.set_balance_mode_user_white() + white_mode.blue_gain = 0.5 assert ( sensor1._sensor_template.camera_sensor_template.sensor_mode_photometric.color_mode_color.balance_mode_userwhite.blue_gain == 0.5 ) # Props - assert sensor1._sensor_instance.camera_properties.axis_system == [ - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 1, - ] - sensor1.set_axis_system([50, 20, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + assert sensor1._sensor_instance.camera_properties.axis_system == sensor_parameter.axis_system + sensor1.axis_system = [50, 20, 10, 1, 0, 0, 0, 1, 0, 0, 0, 1] assert sensor1._sensor_instance.camera_properties.axis_system == [ 50, 20, diff --git a/tests/core/test_simulation.py b/tests/core/test_simulation.py index 775233c81..dce315b20 100644 --- a/tests/core/test_simulation.py +++ b/tests/core/test_simulation.py @@ -386,11 +386,11 @@ def test_commit(speos: Speos): opt_prop.commit() ssr = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) - ssr.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr.commit() ssr2 = p.create_sensor(name="Irradiance.2", feature_type=SensorIrradiance) - ssr2.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr2.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr2.commit() src = p.create_source(name="Luminaire.1", feature_type=SourceLuminaire) @@ -440,11 +440,11 @@ def test_reset(speos: Speos): opt_prop.commit() ssr = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) - ssr.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr.commit() ssr2 = p.create_sensor(name="Irradiance.2", feature_type=SensorIrradiance) - ssr2.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr2.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr2.commit() src = p.create_source(name="Luminaire.1", feature_type=SourceLuminaire) @@ -495,11 +495,11 @@ def test_direct_modify_after_reset(speos: Speos): opt_prop.commit() ssr = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) - ssr.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr.commit() ssr2 = p.create_sensor(name="Irradiance.2", feature_type=SensorIrradiance) - ssr2.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr2.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr2.commit() src = p.create_source(name="Luminaire.1", feature_type=SourceLuminaire) @@ -566,11 +566,13 @@ def test_inverse_modify_after_reset(speos: Speos): opt_prop.commit() ssr = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) - ssr.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]).set_type_colorimetric() + ssr.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] + ssr.set_type_colorimetric() ssr.commit() ssr2 = p.create_sensor(name="Irradiance.2", feature_type=SensorIrradiance) - ssr2.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]).set_type_colorimetric() + ssr2.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] + ssr2.set_type_colorimetric() ssr2.commit() src = p.create_source(name="Luminaire.1", feature_type=SourceLuminaire) @@ -643,11 +645,13 @@ def test_interactive_modify_after_reset(speos: Speos): opt_prop.commit() ssr = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) - ssr.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]).set_type_colorimetric() + ssr.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] + ssr.set_type_colorimetric() ssr.commit() ssr2 = p.create_sensor(name="Irradiance.2", feature_type=SensorIrradiance) - ssr2.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]).set_type_colorimetric() + ssr2.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] + ssr2.set_type_colorimetric() ssr2.commit() src = p.create_source(name="Luminaire.1", feature_type=SourceLuminaire) @@ -699,7 +703,7 @@ def test_delete(speos: Speos): opt_prop.commit() ssr = p.create_sensor(name="Irradiance.1", feature_type=SensorIrradiance) - ssr.set_axis_system(axis_system=[0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1]) + ssr.axis_system = [0, 0, -20, 1, 0, 0, 0, 1, 0, 0, 0, 1] ssr.commit() src = p.create_source(name="Luminaire.1", feature_type=SourceLuminaire) @@ -1039,7 +1043,9 @@ def test_export_vtp(speos: Speos): ) sim = p5.find(name=".*", name_regex=True, feature_type=SimulationDirect)[0] sensor_irra = p5.find(name=".*", name_regex=True, feature_type=SensorIrradiance)[0] - sensor_irra.set_dimensions().set_x_sampling(10).set_y_sampling(10) + dim = sensor_irra.set_dimensions() + dim.x_sampling = 10 + dim.y_sampling = 10 sensor_irra.set_type_photometric() sensor_irra.commit() speos_results, vtp_results = sim.compute_CPU(export_vtp=True) @@ -1092,7 +1098,9 @@ def test_export_vtp(speos: Speos): ) sim = p6.find(name=".*", name_regex=True, feature_type=SimulationDirect)[0] sensor_irra = p6.find(name=".*", name_regex=True, feature_type=SensorIrradiance)[0] - sensor_irra.set_dimensions().set_x_sampling(10).set_y_sampling(10) + dim = sensor_irra.set_dimensions() + dim.x_sampling = 10 + dim.y_sampling = 10 sensor_irra.set_type_radiometric() sensor_irra.commit() speos_results, vtp_results = sim.compute_CPU(export_vtp=True) @@ -1109,7 +1117,9 @@ def test_export_vtp(speos: Speos): ) sim = p7.find(name=".*", name_regex=True, feature_type=SimulationDirect)[0] sensor_irra = p7.find(name=".*", name_regex=True, feature_type=SensorIrradiance)[0] - sensor_irra.set_dimensions().set_x_sampling(10).set_y_sampling(10) + dim = sensor_irra.set_dimensions() + dim.x_sampling = 10 + dim.y_sampling = 10 sensor_irra.set_type_colorimetric() sensor_irra.commit() @@ -1131,7 +1141,9 @@ def test_export_vtp(speos: Speos): ) sim = p8.find(name=".*", name_regex=True, feature_type=SimulationDirect)[0] sensor_irra = p8.find(name=".*", name_regex=True, feature_type=SensorIrradiance)[0] - sensor_irra.set_dimensions().set_x_sampling(10).set_y_sampling(10) + dim = sensor_irra.set_dimensions() + dim.x_sampling = 10 + dim.y_sampling = 10 sensor_irra.set_type_spectral() sensor_irra.commit() speos_results, vtp_results = sim.compute_CPU(export_vtp=True)