Helios++
Helios software for LiDAR simulations
PyScannerWrapper.h
1 #pragma once
2 
3 #ifdef PYTHON_BINDING
4 
5 #include <PyBeamDeflectorWrapper.h>
6 namespace pyhelios{ class PyDetectorWrapper;};
7 #include <PyIntegerList.h>
8 #include <PyNoiseSourceWrapper.h>
9 #include <PyRandomnessGeneratorWrapper.h>
10 #include <PyDoubleVector.h>
17 
18 #include <scanner/Scanner.h>
19 #include <maths/WaveMaths.h>
20 
21 namespace pyhelios{
22 
29 public:
30  // *** ATTRIBUTES *** //
31  // ******************** //
32  Scanner &scanner;
33 
34  // *** CONSTRUCTION / DESTRUCTION *** //
35  // ************************************ //
36  PyScannerWrapper(Scanner &scanner) : scanner(scanner) {}
37  virtual ~PyScannerWrapper() = default;
38 
39  // *** M E T H O D S *** //
40  // *********************** //
41  void initializeSequentialGenerators(){
43  }
44  void buildScanningPulseProcess(
45  int const parallelizationStrategy,
46  PulseTaskDropper &dropper,
47  std::shared_ptr<PulseThreadPoolInterface> pool
48  ){
50  parallelizationStrategy,
51  dropper,
52  pool
53  );
54  }
55  void applySettings(std::shared_ptr<ScannerSettings> settings){
56  scanner.applySettings(settings);
57  }
58  std::shared_ptr<ScannerSettings> retrieveCurrentSettings(){
59  return scanner.retrieveCurrentSettings();
60  }
61  void applySettingsFWF(FWFSettings settings){
62  scanner.applySettingsFWF(settings);
63  }
64  void doSimStep(
65  unsigned int legIndex,
66  double currentGpsTime
67  ){
68  scanner.doSimStep(legIndex, currentGpsTime);
69  }
70  std::string toString(){
71  return scanner.toString();
72  }
73  inline void calcRaysNumber(){scanner.calcRaysNumber();}
74  inline void calcRaysNumber(size_t const idx){scanner.calcRaysNumber(idx);}
75  inline void prepareDiscretization(){scanner.prepareDiscretization();}
76  inline void prepareDiscretization(size_t const idx)
77  {scanner.prepareDiscretization(idx);}
78  int calcTimePropagation(
79  std::vector<double> & timeWave, int const numBins
80  ){
82  timeWave,
83  numBins,
84  scanner.getFWFSettings(0).binSize_ns,
85  scanner.getPulseLength_ns(0),
86  7.0 // 3.5 too many ops., 7.0 just one op.
87  );
88  }
89  inline double calcFootprintArea(double const distance) const{
90  return scanner.calcFootprintArea(distance);
91  }
92  inline double calcFootprintArea(
93  double const distance, size_t const idx
94  )const{
95  return scanner.calcFootprintArea(distance, idx);
96  }
97  inline double calcFootprintRadius(double const distance){
98  return scanner.calcFootprintRadius(distance);
99  }
100  inline double calcFootprintRadius(double const distance, size_t const idx){
101  return scanner.calcFootprintRadius(distance, idx);
102  }
103  inline double calcAtmosphericAttenuation() const{
104  return scanner.calcAtmosphericAttenuation();
105  }
106  inline double calcAtmosphericAttenuation(size_t const idx) const{
107  return scanner.calcAtmosphericAttenuation(idx);
108  }
109  Rotation calcAbsoluteBeamAttitude() const{
110  return scanner.calcAbsoluteBeamAttitude();
111  }
112  inline bool checkMaxNOR(int nor) {return scanner.checkMaxNOR(nor);}
113 
114 
115  // *** SIM STEP UTILS *** //
116  // ************************ //
117  void handleSimStepNoise(
118  glm::dvec3 & absoluteBeamOrigin,
119  Rotation & absoluteBeamAttitude
120  ){
121  scanner.handleSimStepNoise(absoluteBeamOrigin, absoluteBeamAttitude);
122  }
123  inline void onLegComplete() {scanner.onLegComplete();}
124  void inline onSimulationFinished() {scanner.onSimulationFinished();}
125  void handleTrajectoryOutput(double const currentGpsTime){
126  scanner.handleTrajectoryOutput(currentGpsTime);
127  }
128  void trackOutputPath(std::string const &path){
129  scanner.trackOutputPath(path);
130  }
131 
132  // *** GETTERs and SETTERs *** //
133  // *************************** //
134  inline int getCurrentPulseNumber() const {
135  return scanner.getCurrentPulseNumber();
136  }
137  inline int getCurrentPulseNumber(size_t const idx) const {
138  return scanner.getCurrentPulseNumber(idx);
139  }
140  inline int getNumRays() const {
141  return scanner.getNumRays();
142  }
143  inline int getNumRays(size_t const idx) const{
144  return scanner.getNumRays(idx);
145  }
146  inline void setNumRays(int const numRays) {
147  scanner.setNumRays(numRays);
148  }
149  inline void setNumRays(int const numRays, size_t const idx){
150  scanner.setNumRays(numRays, idx);
151  }
152  inline int getPulseFreq_Hz() const {
153  return scanner.getPulseFreq_Hz();
154  }
155  void setPulseFreq_Hz(int const pulseFreq_Hz){
156  scanner.setPulseFreq_Hz(pulseFreq_Hz);
157  }
158  double getPulseLength_ns(size_t const idx){
159  return scanner.getPulseLength_ns(idx);
160  }
161  inline double getPulseLength_ns() const {
162  return scanner.getPulseLength_ns(0);
163  }
164  void setPulseLength_ns(
165  double const pulseLength_ns, size_t const idx
166  ){
167  scanner.setPulseLength_ns(pulseLength_ns, idx);
168  }
169  inline void setPulseLength_ns(double const pulseLength_ns){
170  scanner.setPulseLength_ns(pulseLength_ns, 0);
171  }
172  inline bool lastPulseWasHit() const {
173  return scanner.lastPulseWasHit();
174  }
175  inline bool getLastPulseWasHit(size_t const idx) const {
176  return scanner.lastPulseWasHit(idx);
177  }
178  void setLastPulseWasHit(bool const lastPulseWasHit){
179  scanner.setLastPulseWasHit(lastPulseWasHit);
180  }
181  void setLastPulseWasHit(bool const lastPulseWasHit, size_t const idx){
182  scanner.setLastPulseWasHit(lastPulseWasHit, idx);
183  }
184  double getBeamDivergence(size_t const idx) const{
185  return scanner.getBeamDivergence(idx);
186  }
187  inline double getBeamDivergence() const {
188  return scanner.getBeamDivergence(0);
189  }
190  void setBeamDivergence(
191  double const beamDivergence, size_t const idx
192  ){
193  scanner.setBeamDivergence(beamDivergence, idx);
194  }
195  inline void setBeamDivergence(double const beamDivergence){
196  scanner.setBeamDivergence(beamDivergence, 0);
197  }
198  double getAveragePower(size_t const idx) const{
199  return scanner.getAveragePower(idx);
200  }
201  inline double getAveragePower() const {
202  return scanner.getAveragePower(0);
203  }
204  void setAveragePower(
205  double const averagePower, size_t const idx
206  ){
207  scanner.setAveragePower(averagePower, idx);
208  }
209  inline void setAveragePower(double const averagePower){
210  scanner.setAveragePower(averagePower, 0);
211  }
212  double getBeamQuality(size_t const idx) const{
213  return scanner.getBeamQuality(idx);
214  }
215  inline double getBeamQuality() const {
216  return scanner.getBeamQuality(0);
217  }
218  void setBeamQuality(
219  double const beamQuality, size_t const idx
220  ){
221  scanner.setBeamQuality(beamQuality, idx);
222  }
223  inline void setBeamQuality(double const beamQuality){
224  scanner.setBeamQuality(beamQuality, 0);
225  }
226  double getEfficiency(size_t const idx) const{
227  return scanner.getEfficiency(idx);
228  }
229  inline double getEfficiency() const {
230  return scanner.getEfficiency(0);
231  }
232  void setEfficiency(double const efficiency, size_t const idx=0){
233  scanner.setEfficiency(efficiency, idx);
234  }
235  inline void setEfficiency(double const efficiency){
236  scanner.setEfficiency(efficiency, 0);
237  }
238  double getReceiverDiameter(size_t const idx) const{
239  return scanner.getReceiverDiameter(idx);
240  }
241  inline double getReceiverDiameter() const {
242  return scanner.getReceiverDiameter(0);
243  }
244  void setReceiverDiameter(
245  double const receiverDiameter, size_t const idx
246  ){
247  scanner.setReceiverDiameter(receiverDiameter, idx);
248  }
249  inline void setReceiverDiameter(double const receiverDiameter)
250  {setReceiverDiameter(receiverDiameter, 0);}
251  double getVisibility(size_t const idx) const{
252  return scanner.getVisibility(idx);
253  }
254  inline double getVisibility() const{return scanner.getVisibility(0);}
255  void setVisibility(double const visibility, size_t const idx){
256  scanner.setVisibility(visibility, idx);
257  }
258  inline void setVisibility(double const visibility)
259  {setVisibility(visibility, 0);}
260  double getWavelength(size_t const idx) const{
261  return scanner.getWavelength();
262  }
263  inline double getWavelength() const {
264  return scanner.getWavelength(0);
265  }
266  void setWavelength(double const wavelength, size_t const idx){
267  scanner.setWavelength(wavelength, idx);
268  }
269  inline void setWavelength(double const wavelength){
270  scanner.setWavelength(wavelength, 0);
271  }
272  double getAtmosphericExtinction(size_t const idx) const{
273  return scanner.getAtmosphericExtinction(idx);
274  }
275  inline double getAtmosphericExtinction() const{
276  return scanner.getAtmosphericExtinction(0);
277  }
278  void setAtmosphericExtinction(
279  double const atmosphericExtinction,
280  size_t const idx
281  ){
282  scanner.setAtmosphericExtinction(atmosphericExtinction, idx);
283  }
284  inline void setAtmosphericExtinction(double const atmosphericExtinction){
285  scanner.setAtmosphericExtinction(atmosphericExtinction, 0);
286  }
287  double getBeamWaistRadius(size_t const idx) const{
288  return scanner.getBeamWaistRadius(idx);
289  }
290  inline double getBeamWaistRadius() const {
291  return scanner.getBeamWaistRadius(0);
292  }
293  void setBeamWaistRadius(
294  double const beamWaistRadius, size_t const idx
295  ){
296  return scanner.setBeamWaistRadius(beamWaistRadius, idx);
297  }
298  inline void setBeamWaistRadius(double const beamWaistRadius){
299  scanner.setBeamWaistRadius(beamWaistRadius, 0);
300  }
301  inline int getMaxNOR(size_t const idx) const
302  {return scanner.getMaxNOR(idx);}
303  inline int getMaxNOR() const {return scanner.getMaxNOR(0);}
304  inline void setMaxNOR(int const maxNOR, size_t const idx)
305  {scanner.setMaxNOR(maxNOR, idx);}
306  inline void setMaxNOR(int const maxNOR) {scanner.setMaxNOR(maxNOR);}
307  glm::dvec3 getHeadRelativeEmitterPosition(
308  size_t const idx
309  ) const{
310  return scanner.getHeadRelativeEmitterPosition(idx);
311  }
312  void setHeadRelativeEmitterPosition(
313  glm::dvec3 const &pos, size_t const idx
314  ){
315  scanner.setHeadRelativeEmitterPosition(pos, idx);
316  }
317  Rotation getHeadRelativeEmitterAttitude(size_t const idx) const{
318  return scanner.getHeadRelativeEmitterAttitude(idx);
319  }
320  void setHeadRelativeEmitterAttitude(
321  Rotation const &attitude, size_t const idx
322  ){
323  scanner.setHeadRelativeEmitterAttitude(attitude, idx);
324  }
325  double getBt2(size_t const idx) const{
326  return scanner.getBt2(idx);
327  }
328  inline double getBt2() const {
329  return scanner.getBt2(0);
330  }
331  void setBt2(double const bt2, size_t const idx){
332  scanner.setBt2(bt2, idx);
333  }
334  inline void setBt2(double const bt2) {
335  scanner.setBt2(bt2, 0);
336  }
337  double getDr2(size_t const idx) const{
338  return scanner.getDr2(idx);
339  }
340  inline double getDr2() const {
341  return scanner.getDr2(0);
342  }
343  void setDr2(double const dr2, size_t const idx){
344  scanner.setDr2(dr2, idx);
345  }
346  inline void setDr2(double const dr2) {
347  scanner.setDr2(dr2, 0);
348  }
349  inline bool isActive() const {
350  return scanner.isActive();
351  }
352  inline void setActive(bool const active) {
353  scanner.setActive(active);
354  }
355  inline bool isWriteWaveform() const {
356  return scanner.isWriteWaveform();
357  }
358  inline void setWriteWaveform(bool const writeWaveform){
359  scanner.setWriteWaveform(writeWaveform);
360  }
361  inline bool isCalcEchowidth() const {
362  return scanner.isCalcEchowidth();
363  }
364  inline void setCalcEchowidth(bool const calcEchowidth){
365  scanner.setCalcEchowidth(calcEchowidth);
366  }
367  inline bool isFullWaveNoise() const {
368  return scanner.isFullWaveNoise();
369  }
370  inline void setFullWaveNoise(bool const fullWaveNoise){
371  scanner.setFullWaveNoise(fullWaveNoise);
372  }
373  inline bool isPlatformNoiseDisabled() {
374  return scanner.isPlatformNoiseDisabled();
375  }
376  inline void setPlatformNoiseDisabled(bool const platformNoiseDisabled){
377  scanner.setPlatformNoiseDisabled(platformNoiseDisabled);
378  }
379  inline bool isFixedIncidenceAngle() const {
380  return scanner.isFixedIncidenceAngle();
381  }
382  inline void setFixedIncidenceAngle(bool const fixedIncidenceAngle){
383  scanner.setFixedIncidenceAngle(fixedIncidenceAngle);
384  }
385  inline std::string getScannerId() const {
386  return scanner.getScannerId();
387  }
388  inline void setScannerId(std::string const &id) {
389  scanner.setScannerId(id);
390  }
391  std::string getDeviceId(size_t const idx) const{
392  return scanner.getDeviceId(idx);
393  }
394  inline std::string getDeviceId() const {
395  return scanner.getDeviceId(0);
396  }
397  void setDeviceId(std::string const deviceId, size_t const idx){
398  scanner.setDeviceId(deviceId, idx);
399  }
400  inline void setDeviceId(std::string const deviceId){
401  scanner.setDeviceId(deviceId, 0);
402  }
403  size_t getNumDevices(){
404  return scanner.getNumDevices();
405  }
406 
407  // *** PyScannerWrapper ADHOC *** //
408  // ******************************** //
409  ScannerHead & getScannerHead(){return *scanner.getScannerHead();}
410  ScannerHead & getScannerHead(size_t const idx)
411  {return *scanner.getScannerHead(idx);}
412  PyBeamDeflectorWrapper * getPyBeamDeflector()
413  {return new PyBeamDeflectorWrapper(scanner.getBeamDeflector());}
414  PyBeamDeflectorWrapper * getPyBeamDeflector(size_t const idx)
415  {return new PyBeamDeflectorWrapper(scanner.getBeamDeflector(idx));}
416  PyDetectorWrapper * getPyDetectorWrapper();
417  PyDetectorWrapper * getPyDetectorWrapper(size_t const idx);
418  PyIntegerList * getSupportedPulseFrequencies()
419  {return new PyIntegerList(scanner.getSupportedPulseFreqs_Hz());}
420  PyIntegerList * getSupportedPulseFrequencies(size_t const idx)
421  {return new PyIntegerList(scanner.getSupportedPulseFreqs_Hz(idx));}
422  Rotation & getRelativeAttitudeByReference(size_t const idx){
423  return scanner.getHeadRelativeEmitterAttitudeByRef(idx);
424  }
425  Rotation & getRelativeAttitudeByReference(){
426  return scanner.getHeadRelativeEmitterAttitudeByRef(0);
427  }
428  PythonDVec3 * getRelativePosition(size_t const idx){
429  return new PythonDVec3(
431  );
432  }
433  PythonDVec3 * getRelativePosition(){
434  return new PythonDVec3(scanner.getHeadRelativeEmitterPositionByRef(0));
435  }
436  PyNoiseSourceWrapper * getIntersectionHandlingNoiseSource(){
437  if(scanner.intersectionHandlingNoiseSource == nullptr) return nullptr;
438  return new PyNoiseSourceWrapper(
440  );
441  }
442  PyRandomnessGeneratorWrapper * getRandGen1(){
443  if(scanner.randGen1 == nullptr) return nullptr;
444  return new PyRandomnessGeneratorWrapper(*scanner.randGen1);
445  }
446  PyRandomnessGeneratorWrapper * getRandGen2(){
447  if(scanner.randGen2 == nullptr) return nullptr;
448  return new PyRandomnessGeneratorWrapper(*scanner.randGen2);
449  }
450  PyDoubleVector * getTimeWave(){
451  return new PyDoubleVector(scanner.getTimeWave());
452  }
453  FWFSettings getFWFSettings() {return scanner.getFWFSettings();}
454  void setFWFSettings(FWFSettings const &fwfSettings)
455  {scanner.setFWFSettings(fwfSettings);}
456  int getNumTimeBins() {return scanner.getNumTimeBins();}
457  void setNumTimeBins(int const numTimeBins)
458  {scanner.setNumTimeBins(numTimeBins);}
459  int getPeakIntensityIndex() {return scanner.getPeakIntensityIndex();}
460  void setPeakIntensityIndex(int const peakIntensityIndex)
461  {scanner.setPeakIntensityIndex(peakIntensityIndex);}
462  double getTrajectoryTimeInterval()
463  {return scanner.trajectoryTimeInterval_ns;}
464  void setTrajectoryTimeInterval(double const trajectoryTimeInterval_ns){
465  scanner.trajectoryTimeInterval_ns = trajectoryTimeInterval_ns;
466  }
467 
468 };
469 
470 }
471 
472 #endif
Full Waveform settings.
Definition: FWFSettings.h:12
double binSize_ns
Bin size for discretization (nanoseconds)
Definition: FWFSettings.h:20
Class implementing a task dropper to deal with pulse tasks.
Definition: PulseTaskDropper.h:27
Definition: Rotation.h:80
Definition: ScannerHead.h:13
Class representing a scanner asset.
Definition: Scanner.h:28
virtual void setAtmosphericExtinction(double const atmosphericExtinction, size_t const idx)=0
Set atmospheric extinction.
virtual double getWavelength(size_t const idx) const =0
Obtain wave length.
virtual std::shared_ptr< AbstractBeamDeflector > getBeamDeflector(size_t const idx)=0
Obtain the beam deflector of the scanning device.
void setCalcEchowidth(bool const calcEchowidth)
Set scanner echo width configuration.
Definition: Scanner.h:1102
virtual double getVisibility(size_t const idx) const =0
Get device visibility.
virtual void setHeadRelativeEmitterPosition(glm::dvec3 const &pos, size_t const idx=0)=0
Set the head's relative emitter position.
virtual void setBt2(double const bt2, size_t const idx)=0
Set .
void setPlatformNoiseDisabled(bool const platformNoiseDisabled)
Set platform noise disabled flag.
Definition: Scanner.h:1134
void buildScanningPulseProcess(int const parallelizationStrategy, PulseTaskDropper &dropper, std::shared_ptr< PulseThreadPoolInterface > pool)
Build the scanning pulse process to be used by the scanner during simulation.
Definition: Scanner.cpp:394
virtual double getAveragePower(size_t const idx) const =0
Obtain average power.
void setActive(bool const active)
Set scanner active status. True to make it active, false to make it inactive.
Definition: Scanner.h:1070
virtual glm::dvec3 & getHeadRelativeEmitterPositionByRef(size_t const idx=0)=0
Obtain the head's relative emitter position by reference (can be written)
std::shared_ptr< RandomnessGenerator< double > > randGen1
First randomness generator for single thread mode.
Definition: Scanner.h:162
virtual std::list< int > & getSupportedPulseFreqs_Hz(size_t const idx)=0
Obtain the list of supported pulse frequencies of the scanning device.
virtual void setMaxNOR(int const maxNOR, size_t const idx)=0
Set the maximum number of returns per pulse for the scanning device (0 means no maximum at all).
virtual void setFWFSettings(FWFSettings const &fwfSettings, size_t const idx)=0
Set the Full WaveForm settings of the scanning device.
virtual int getPeakIntensityIndex(size_t const idx) const =0
Obtain the index of the bin containing the intensity peak for the scanning device.
virtual void setNumTimeBins(int const numTimeBins, size_t const idx)=0
Set the number of bins defining the size of the time discretization for the scanning device.
void setScannerId(std::string const &id)
Set the identifier of the scanner.
Definition: Scanner.h:1163
bool isFullWaveNoise() const
Check if scanner is configured to add noise to full wave (true) or not (false)
Definition: Scanner.h:1112
virtual double getDr2(size_t const idx) const =0
Obtain .
virtual void setPeakIntensityIndex(int const pii, size_t const idx)=0
Set the index of the bin containing the intensity peak for the scanning device.
virtual void doSimStep(unsigned int legIndex, double const currentGpsTime)=0
Perform computations for current simulation step.
std::shared_ptr< RandomnessGenerator< double > > randGen2
Second randomness generator for single thread mode.
Definition: Scanner.h:166
bool isActive() const
Check if scanner is active (true) or not (false)
Definition: Scanner.h:1063
virtual FWFSettings & getFWFSettings(size_t const idx)=0
Obtain the Full WaveForm settings of the scanning device.
void handleTrajectoryOutput(double const currentGpsTime)
Handle trajectory output whatever it is to output file, to all trajectories vector or to cycle trajec...
Definition: Scanner.cpp:324
virtual void setPulseLength_ns(double const pulseLength_ns, size_t const idx)=0
Set the pulse length.
virtual glm::dvec3 getHeadRelativeEmitterPosition(size_t const idx=0) const =0
Obtain the head's relative emitter position.
virtual void setNumRays(int const numRays, size_t const idx)=0
Set the number of rays of the scanning device.
virtual std::string getDeviceId(size_t const idx) const =0
Obtain scanner device identifier.
void onSimulationFinished()
Exposes ScanningPulseProcess::onSimulationFinished method of the scanning pulse process defining this...
Definition: Scanner.h:536
virtual std::vector< double > & getTimeWave(size_t const idx)=0
Obtain the time discretization vector of the scanning device.
double calcFootprintRadius(double const distance, size_t const idx)
Compute the footprint radius .
Definition: Scanner.cpp:247
virtual double getBeamQuality(size_t const idx) const =0
Get beam quality.
virtual double getReceiverDiameter(size_t const idx) const =0
Get receiver diameter.
void setPulseFreq_Hz(int const pulseFreq_Hz)
Set the pulse frequency.
Definition: Scanner.cpp:253
virtual Rotation & getHeadRelativeEmitterAttitudeByRef(size_t const idx=0)=0
Obtain the head's relative emitter attitude by reference (can be written)
virtual double getBt2(size_t const idx) const =0
Obtain .
void setFixedIncidenceAngle(bool const fixedIncidenceAngle)
Set fixed incidence angle flag.
Definition: Scanner.h:1150
virtual void setDr2(double const dr2, size_t const idx)=0
Set .
virtual void applySettingsFWF(FWFSettings settings, size_t const idx)
Apply full wave form settings.
Definition: Scanner.cpp:226
bool isPlatformNoiseDisabled()
Check if platform noise is disabled (true) or not (false)
Definition: Scanner.h:1127
void handleSimStepNoise(glm::dvec3 &absoluteBeamOrigin, Rotation &absoluteBeamAttitude)
Handle position and attitude noise.
Definition: Scanner.cpp:287
virtual void setBeamDivergence(double const beamDivergence, size_t const idx)=0
Set beam divergence.
virtual void setLastPulseWasHit(bool const lastPulseWasHit, size_t const idx)=0
Specify if last pulse was hit (true) or not (false)
virtual void setDeviceId(std::string const deviceId, size_t const idx)=0
Set the scanner device identifier.
virtual double getBeamWaistRadius(size_t const idx) const =0
Obtain beam waist radius.
virtual double getEfficiency(size_t const idx) const =0
Obtain device efficiency.
virtual void setBeamQuality(double const beamQuality, size_t const idx)=0
Set beam quality.
void trackOutputPath(std::string const &path)
Track given output path in a thread safe way.
Definition: Scanner.cpp:369
std::string getScannerId() const
Obtain the identifier of the scanner.
Definition: Scanner.h:1157
virtual void setHeadRelativeEmitterAttitude(Rotation const &attitude, size_t const idx=0)=0
Obtain the head's relative emitter attitude.
virtual Rotation calcAbsoluteBeamAttitude(size_t const idx)=0
Compute the absolute beam attitude considering the mount relative attitude and the deflector relative...
virtual void setBeamWaistRadius(double const beamWaistRadius, size_t const idx)=0
Set beam waist radius.
virtual void setEfficiency(double const efficiency, size_t const idx=0)=0
Set device efficiency.
std::shared_ptr< UniformNoiseSource< double > > intersectionHandlingNoiseSource
Uniform noise source for single thread mode.
Definition: Scanner.h:171
virtual size_t getNumDevices() const =0
Obtain the number of scanning devices composing the scanner.
double trajectoryTimeInterval_ns
Time interval between record of trajectory points. When it is exactly 0, then no trajectory points wi...
Definition: Scanner.h:151
virtual std::shared_ptr< ScannerSettings > retrieveCurrentSettings(size_t const idx)
Retrieve current scanner settings and build a new ScannerSettings object with them.
Definition: Scanner.cpp:199
virtual void applySettings(std::shared_ptr< ScannerSettings > settings, size_t const idx)=0
Apply scanner settings.
virtual bool lastPulseWasHit(size_t const idx) const =0
Check if last pulse was hit (true) or not (false) for the scanning device.
bool isCalcEchowidth() const
Check if scanner is configured to compute echo width (true) or not (false)
Definition: Scanner.h:1095
virtual int getNumTimeBins(size_t const idx) const =0
Obtain the number of bins defining the size of the time discretization for the scanning device.
void setFullWaveNoise(bool const fullWaveNoise)
Set scanner full wave noise policy.
Definition: Scanner.h:1119
virtual double getBeamDivergence(size_t const idx) const =0
Obtain beam divergence.
virtual void setAveragePower(double const averagePower, size_t const idx)=0
Set average power.
virtual int getMaxNOR(size_t const idx) const =0
Obtain the maximum number of returns per pulse for the scanning device (0 means no maximum at all).
virtual void setWavelength(double const wavelength, size_t const idx)=0
Set wave length.
virtual double getAtmosphericExtinction(size_t const idx) const =0
Obtain atmospheric extinction.
virtual void prepareDiscretization(size_t const idx)=0
Prepare wave discretization.
virtual void setReceiverDiameter(double const receiverDiameter, size_t const idx)=0
Set receiver diameter.
void initializeSequentialGenerators()
Initialize randomness generators and noise sources that are necessary for sequential pulse computatio...
Definition: Scanner.cpp:376
bool isWriteWaveform() const
Check if scanner is configured to write wave form (true) or not (false)
Definition: Scanner.h:1079
virtual double getPulseLength_ns(size_t const idx) const =0
Get the pulse length.
virtual std::shared_ptr< ScannerHead > getScannerHead(size_t const idx)=0
Obtain the scanner head of the scanning device.
virtual void onLegComplete()
Exposes ScanningPulseProcess:onLegComplete method of the scanning pulse process defining this scanner...
Definition: Scanner.h:531
bool isFixedIncidenceAngle() const
Check if incidence angle is fixed (true) or not (false)
Definition: Scanner.h:1142
void setWriteWaveform(bool const writeWaveform)
Set scanner write wave form configuration.
Definition: Scanner.h:1086
std::string toString()
Build a string representation of the scanner.
Definition: Scanner.cpp:232
virtual double calcFootprintArea(double const distance, size_t const idx) const =0
Compute the footprint area .
int getPulseFreq_Hz() const
Obtain the pulse frequency.
Definition: Scanner.h:601
virtual int getNumRays(size_t const idx) const =0
Obtain the number of rays of the scanning device.
virtual Rotation getHeadRelativeEmitterAttitude(size_t const idx=0) const =0
Obtain the head's relative emitter attitude.
virtual bool checkMaxNOR(int const nor, size_t const idx)=0
Check if given number of return (nor) is inside expected boundaries. If scanner maxNOR is 0 or nor is...
virtual void calcRaysNumber(size_t const idx)=0
Compute the number of rays depending on beam sample quality for the scanning device.
virtual double calcAtmosphericAttenuation(size_t const idx) const =0
virtual int getCurrentPulseNumber(size_t const idx) const =0
Obtain the current pulse number of the scanning device.
virtual void setVisibility(double const visibility, size_t const idx)=0
Set device visibility.
static int calcPropagationTimeLegacy(std::vector< double > &timeWave, int const numBins, double const binSize, double const pulseLength, double const pulseLengthDivisor)
Compute propagation time, thus obtaining the intensity peak index and populating the time wave vector...
Definition: WaveMaths.cpp:6
Wrapper for AbstractBeamDeflector class.
Definition: PyBeamDeflectorWrapper.h:23
Wrapper for AbstractDetector class.
Definition: PyDetectorWrapper.h:22
Wrapper for std::vector<double> class.
Definition: PyDoubleVector.h:17
Wrapper for std::list<int> class.
Definition: PyIntegerList.h:18
Wrapper for NoiseSource abstract class.
Definition: PyNoiseSourceWrapper.h:16
Wrapper for RandomnessGenerator class.
Definition: PyRandomnessGeneratorWrapper.h:12
Wrapper for Scanner class.
Definition: PyScannerWrapper.h:28
Wrapper to communicate glm::dvec3 with python.
Definition: PythonDVec3.h:16