Gazebo Rendering

API Reference

9.0.0~pre2
BaseLidarVisual.hh
Go to the documentation of this file.
1/*
2 * Copyright (C) 2020 Open Source Robotics Foundation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16*/
17#ifndef GZ_RENDERING_BASELIDARVISUAL_HH_
18#define GZ_RENDERING_BASELIDARVISUAL_HH_
19
20#include <vector>
21
22#include "gz/rendering/LidarVisual.hh"
23#include "gz/rendering/base/BaseObject.hh"
24#include "gz/rendering/base/BaseRenderTypes.hh"
25#include "gz/rendering/Scene.hh"
26
27namespace gz
28{
29 namespace rendering
30 {
31 inline namespace GZ_RENDERING_VERSION_NAMESPACE {
33 template <class T>
34 class BaseLidarVisual :
35 public virtual LidarVisual,
36 public virtual T
37 {
38 // Documentation inherited
39 protected: BaseLidarVisual();
40
41 // Documentation inherited
42 public: virtual ~BaseLidarVisual();
43
44 // Documentation inherited
45 public: virtual void PreRender() override;
46
47 // Documentation inherited
48 public: virtual void Destroy() override;
49
50 // Documentation inherited
51 public: virtual void ClearPoints() override;
52
53 // Documentation inherited
54 public: virtual void SetPoints(
55 const std::vector<double> &_points) override;
56
57 // Documentation inherited
58 public: virtual void SetPoints(const std::vector<double> &_points,
59 const std::vector<gz::math::Color> &_colors)
60 override;
61
62 // Documentation inherited
63 public: virtual void Update() override;
64
65 // Documentation inherited
66 public: virtual void Init() override;
67
68 // Documentation inherited
69 public: virtual void SetMinVerticalAngle(
70 double _minVerticalAngle) override;
71
72 // Documentation inherited
73 public: virtual double MinVerticalAngle() const override;
74
75 // Documentation inherited
76 public: virtual void SetMaxVerticalAngle(
77 double _maxVerticalAngle) override;
78
79 // Documentation inherited
80 public: virtual double MaxVerticalAngle() const override;
81
82 // Documentation inherited
83 public: virtual void SetMinHorizontalAngle(
84 double _minHorizontalAngle) override;
85
86 // Documentation inherited
87 public: virtual double MinHorizontalAngle() const override;
88
89 // Documentation inherited
90 public: virtual void SetMaxHorizontalAngle(
91 double _maxHorizontalAngle) override;
92
93 // Documentation inherited
94 public: virtual double MaxHorizontalAngle() const override;
95
96 // Documentation inherited
97 public: virtual void SetVerticalRayCount(
98 unsigned int _verticalRayCount) override;
99
100 // Documentation inherited
101 public: virtual unsigned int VerticalRayCount() const override;
102
103 // Documentation inherited
104 public: virtual void SetHorizontalRayCount(
105 unsigned int _horizontalRayCount) override;
106
107 // Documentation inherited
108 public: virtual unsigned int HorizontalRayCount() const override;
109
110 // Documentation inherited
111 public: virtual void SetMinRange(double _minRange) override;
112
113 // Documentation inherited
114 public: virtual double MinRange() const override;
115
116 // Documentation inherited
117 public: virtual void SetMaxRange(double _maxRange) override;
118
119 // Documentation inherited
120 public: virtual double MaxRange() const override;
121
122 // Documentation inherited
123 public: virtual void SetOffset(
124 const gz::math::Pose3d _offset) override;
125
126 // Documentation inherited
127 public: virtual gz::math::Pose3d Offset() const override;
128
129 // Documentation inherited
130 public: virtual unsigned int PointCount() const override;
131
132 // Documentation inherited
133 public: virtual std::vector<double> Points() const override;
134
135 // Documentation inherited
136 public: virtual void SetType(const LidarVisualType _type) override;
137
138 // Documentation inherited
139 public: virtual LidarVisualType Type() const override;
140
141 // Documentation inherited
142 public: virtual void SetSize(double _size) override;
143
144 // Documentation inherited
145 public: virtual double Size() const override;
146
148 public: virtual void CreateMaterials();
149
150 // Documentation inherited
151 public: virtual void SetDisplayNonHitting(bool _display) override;
152
153 // Documentation inherited
154 public: virtual bool DisplayNonHitting() const override;
155
157 protected: double minVerticalAngle = 0;
158
160 protected: double maxVerticalAngle = 0;
161
163 protected: unsigned int verticalCount = 1u;
164
166 protected: double verticalAngleStep = 0;
167
169 protected: double minHorizontalAngle = 0;
170
172 protected: double maxHorizontalAngle = 0;
173
175 protected: unsigned int horizontalCount = 1u;
176
178 protected: double horizontalAngleStep = 0;
179
181 protected: double minRange = 0;
182
184 protected: double maxRange = 0;
185
187 protected: bool displayNonHitting = true;
188
190 protected: gz::math::Pose3d offset = gz::math::Pose3d::Zero;
191
193 protected: LidarVisualType lidarVisualType =
194 LidarVisualType::LVT_TRIANGLE_STRIPS;
195
197 protected: double size = 1.0;
198 };
199
201 // BaseLidarVisual
203 template <class T>
207
209 template <class T>
213
215 template <class T>
216 void BaseLidarVisual<T>::PreRender()
217 {
218 T::PreRender();
219 }
220
222 template <class T>
223 void BaseLidarVisual<T>::Destroy()
224 {
225 T::Destroy();
226 }
227
229 template <class T>
230 void BaseLidarVisual<T>::ClearPoints()
231 {
232 // no op
233 }
234
236 template <class T>
237 unsigned int BaseLidarVisual<T>::PointCount() const
238 {
239 return 0u;
240 }
241
243 template <class T>
249
251 template <class T>
252 void BaseLidarVisual<T>::Update()
253 {
254 // no op
255 }
256
258 template <class T>
259 void BaseLidarVisual<T>::SetPoints(const std::vector<double> &)
260 {
261 // no op
262 }
263
265 template <class T>
266 void BaseLidarVisual<T>::SetPoints(const std::vector<double> &,
267 const std::vector<gz::math::Color> &)
268 {
269 // no op
270 }
271
273 template <class T>
274 void BaseLidarVisual<T>::Init()
275 {
276 T::Init();
277 this->CreateMaterials();
278 }
279
281 template <class T>
282 void BaseLidarVisual<T>::SetMinVerticalAngle(
283 double _minVerticalAngle)
284 {
285 this->minVerticalAngle = _minVerticalAngle;
286 }
287
289 template <class T>
290 double BaseLidarVisual<T>::MinVerticalAngle() const
291 {
292 return this->minVerticalAngle;
293 }
294
296 template <class T>
297 void BaseLidarVisual<T>::SetMaxVerticalAngle(
298 double _maxVerticalAngle)
299 {
300 this->maxVerticalAngle = _maxVerticalAngle;
301 }
302
304 template <class T>
305 double BaseLidarVisual<T>::MaxVerticalAngle() const
306 {
307 return this->maxVerticalAngle;
308 }
309
311 template <class T>
312 void BaseLidarVisual<T>::SetVerticalRayCount(
313 unsigned int _verticalRayCount)
314 {
315 if (_verticalRayCount == 0)
316 {
317 gzwarn << "Cannot have zero vertical rays. Setting value to 1."
318 << std::endl;
319 this->verticalCount = 1;
320 }
321 else
322 {
323 this->verticalCount = _verticalRayCount;
324 }
325 }
326
328 template <class T>
329 unsigned int BaseLidarVisual<T>::VerticalRayCount() const
330 {
331 return this->verticalCount;
332 }
333
335 template <class T>
336 void BaseLidarVisual<T>::SetMinHorizontalAngle(
337 double _minHorizontalAngle)
338 {
339 this->minHorizontalAngle = _minHorizontalAngle;
340 }
341
343 template <class T>
344 double BaseLidarVisual<T>::MinHorizontalAngle() const
345 {
346 return this->minHorizontalAngle;
347 }
348
350 template <class T>
351 void BaseLidarVisual<T>::SetMaxHorizontalAngle(
352 double _maxHorizontalAngle)
353 {
354 this->maxHorizontalAngle = _maxHorizontalAngle;
355 }
356
358 template <class T>
359 double BaseLidarVisual<T>::MaxHorizontalAngle() const
360 {
361 return this->maxHorizontalAngle;
362 }
363
365 template <class T>
366 void BaseLidarVisual<T>::SetHorizontalRayCount(
367 unsigned int _horizontalRayCount)
368 {
369 if (_horizontalRayCount == 0)
370 {
371 gzwarn << "Cannot have zero horizontal rays. Setting value to 1."
372 << std::endl;
373 this->horizontalCount = 1u;
374 }
375 else
376 {
377 this->horizontalCount = _horizontalRayCount;
378 }
379 }
380
382 template <class T>
383 unsigned int BaseLidarVisual<T>::HorizontalRayCount() const
384 {
385 return this->horizontalCount;
386 }
387
389 template <class T>
390 void BaseLidarVisual<T>::SetMinRange(double _minRange)
391 {
392 this->minRange = _minRange;
393 }
394
396 template <class T>
397 double BaseLidarVisual<T>::MinRange() const
398 {
399 return this->minRange;
400 }
401
403 template <class T>
404 void BaseLidarVisual<T>::SetMaxRange(double _maxRange)
405 {
406 this->maxRange = _maxRange;
407 }
408
410 template <class T>
411 double BaseLidarVisual<T>::MaxRange() const
412 {
413 return this->maxRange;
414 }
415
417 template <class T>
418 void BaseLidarVisual<T>::SetOffset(const gz::math::Pose3d _offset)
419 {
420 this->offset = _offset;
421 }
422
424 template <class T>
425 gz::math::Pose3d BaseLidarVisual<T>::Offset() const
426 {
427 return this->offset;
428 }
429
431 template <class T>
432 void BaseLidarVisual<T>::SetType(const LidarVisualType _type)
433 {
434 this->lidarVisualType = _type;
435 }
436
438 template <class T>
439 LidarVisualType BaseLidarVisual<T>::Type() const
440 {
441 return this->lidarVisualType;
442 }
443
445 template <class T>
446 void BaseLidarVisual<T>::SetSize(double _size)
447 {
448 this->size = _size;
449 }
450
452 template <class T>
453 double BaseLidarVisual<T>::Size() const
454 {
455 return this->size;
456 }
457
459 template <class T>
460 void BaseLidarVisual<T>::SetDisplayNonHitting(bool _display)
461 {
462 this->displayNonHitting = _display;
463 }
464
466 template <class T>
467 bool BaseLidarVisual<T>::DisplayNonHitting() const
468 {
469 return this->displayNonHitting;
470 }
471
473 template <class T>
474 void BaseLidarVisual<T>::CreateMaterials()
475 {
476 MaterialPtr mtl;
477
478 if (!this->Scene()->MaterialRegistered("Lidar/BlueStrips"))
479 {
480 mtl = this->Scene()->CreateMaterial("Lidar/BlueStrips");
481 mtl->SetAmbient(0.0, 0.0, 1.0);
482 mtl->SetDiffuse(0.0, 0.0, 1.0);
483 mtl->SetEmissive(0.0, 0.0, 1.0);
484 mtl->SetTransparency(0.4);
485 mtl->SetCastShadows(false);
486 mtl->SetReceiveShadows(false);
487 mtl->SetLightingEnabled(false);
488 mtl->SetMetalness(0.0f);
489 mtl->SetReflectivity(0.0);
490 }
491
492 if (!this->Scene()->MaterialRegistered("Lidar/LightBlueStrips"))
493 {
494 mtl = this->Scene()->CreateMaterial("Lidar/LightBlueStrips");
495 mtl->SetAmbient(0.0, 0.0, 1.0);
496 mtl->SetDiffuse(0.0, 0.0, 1.0);
497 mtl->SetEmissive(0.0, 0.0, 1.0);
498 mtl->SetTransparency(0.8);
499 mtl->SetCastShadows(false);
500 mtl->SetReceiveShadows(false);
501 mtl->SetLightingEnabled(false);
502 mtl->SetMetalness(0.0f);
503 mtl->SetReflectivity(0.0);
504 }
505
506 if (!this->Scene()->MaterialRegistered("Lidar/TransBlack"))
507 {
508 mtl = this->Scene()->CreateMaterial("Lidar/TransBlack");
509 mtl->SetAmbient(0.0, 0.0, 0.0);
510 mtl->SetDiffuse(0.0, 0.0, 0.0);
511 mtl->SetEmissive(0.0, 0.0, 0.0);
512 mtl->SetTransparency(0.4);
513 mtl->SetCastShadows(false);
514 mtl->SetReceiveShadows(false);
515 mtl->SetLightingEnabled(false);
516 mtl->SetMetalness(0.5f);
517 mtl->SetReflectivity(0.2);
518 }
519
520 if (!this->Scene()->MaterialRegistered("Lidar/BlueRay"))
521 {
522 mtl = this->Scene()->CreateMaterial("Lidar/BlueRay");
523 mtl->SetAmbient(0.0, 0.0, 1.0);
524 mtl->SetDiffuse(0.0, 0.0, 1.0);
525 mtl->SetEmissive(0.0, 0.0, 1.0);
526 mtl->SetSpecular(0.0, 0.0, 1.0);
527 mtl->SetTransparency(0.0);
528 mtl->SetCastShadows(false);
529 mtl->SetReceiveShadows(false);
530 mtl->SetLightingEnabled(false);
531 mtl->SetMetalness(0.1f);
532 mtl->SetReflectivity(0.2);
533 }
534 return;
535 }
536 }
537 }
538}
539#endif