footbot_distance_scanner_rotzonly_sensor.cpp
Go to the documentation of this file.
1 
8 #include <argos3/core/simulator/entity/composable_entity.h>
9 #include <argos3/core/simulator/entity/controllable_entity.h>
10 #include <argos3/core/simulator/simulator.h>
11 #include <argos3/core/simulator/space/space.h>
12 
13 namespace argos {
14 
15  /****************************************/
16  /****************************************/
17 
18  static const Real FOOTBOT_RADIUS = 0.085036758f;
19 
20  static const Real SHORT_RANGE_MIN_DISTANCE = 0.0f;
21  static const Real SHORT_RANGE_RAY_START = FOOTBOT_RADIUS;
22  static const Real SHORT_RANGE_RAY_END = FOOTBOT_RADIUS + 0.26f;
23 
24  static const Real LONG_RANGE_MIN_DISTANCE = 0.12f;
25  static const Real LONG_RANGE_RAY_START = FOOTBOT_RADIUS;
26  static const Real LONG_RANGE_RAY_END = FOOTBOT_RADIUS + 1.42f;
27 
28  static const Real SENSOR_ELEVATION = 0.123199866f;
29 
30  /****************************************/
31  /****************************************/
32 
34  m_pcRNG(NULL),
35  m_bAddNoise(false),
36  m_cSpace(CSimulator::GetInstance().GetSpace()),
37  m_bShowRays(false) {}
38 
39  /****************************************/
40  /****************************************/
41 
43  try {
45  /* Show rays? */
46  GetNodeAttributeOrDefault(t_tree, "show_rays", m_bShowRays, m_bShowRays);
47  /* Noise range */
48  GetNodeAttributeOrDefault(t_tree, "noise_range", m_cNoiseRange, m_cNoiseRange);
49  if(m_cNoiseRange.GetSpan() > 0.0f) {
50  m_bAddNoise = true;
51  m_pcRNG = CRandom::CreateRNG("argos");
52  }
53  }
54  catch(CARGoSException& ex) {
55  THROW_ARGOSEXCEPTION_NESTED("Initialization error in foot-bot distance scanner rot_z_only sensor.", ex);
56  }
57  }
58 
59  /****************************************/
60  /****************************************/
61 
63  m_pcEmbodiedEntity = &(c_entity.GetComponent<CEmbodiedEntity>("body"));
64  m_pcControllableEntity = &(c_entity.GetComponent<CControllableEntity>("controller"));
65  m_pcDistScanEntity = &(c_entity.GetComponent<CFootBotDistanceScannerEquippedEntity>("distance_scanner"));
66  m_pcDistScanEntity->Enable();
67  }
68 
69  /****************************************/
70  /****************************************/
71 
73  /* Clear the maps */
74  m_tReadingsMap.clear();
75  m_tShortReadingsMap.clear();
76  m_tLongReadingsMap.clear();
77  /* Perform calculations only if the sensor is on */
78  if(m_pcDistScanEntity->GetMode() != CFootBotDistanceScannerEquippedEntity::MODE_OFF) {
79  /* Update the readings wrt to device mode */
81  /* Sensor blocked in a position */
82  /* Recalculate the rays */
83  CalculateRaysNotRotating();
84  /* Save the rotation for next time */
85  m_cLastDistScanRotation = m_pcDistScanEntity->GetRotation();
86  /* Update the values */
87  UpdateNotRotating();
88  }
89  else {
90  /* Rotating sensor */
91  /* Recalculate the rays */
92  CalculateRaysRotating();
93  /* Update the values */
94  UpdateRotating();
95  /* Save the rotation for next time */
96  m_cLastDistScanRotation = m_pcDistScanEntity->GetRotation();
97  }
98  }
99  }
100 
101  /****************************************/
102  /****************************************/
103 
105  /* Clear the maps */
106  m_tReadingsMap.clear();
107  m_tShortReadingsMap.clear();
108  m_tLongReadingsMap.clear();
109  /* Zero the last rotation */
110  m_cLastDistScanRotation = CRadians::ZERO;
111  }
112 
113  /****************************************/
114  /****************************************/
115 
116  void CFootBotDistanceScannerRotZOnlySensor::UpdateNotRotating() {
117  /* Short range [0] */
118  CRadians cAngle = m_cLastDistScanRotation;
119  cAngle.SignedNormalize();
120  Real fReading = CalculateReadingForRay(m_cShortRangeRays0[0], SHORT_RANGE_MIN_DISTANCE);
121  m_tShortReadingsMap[cAngle] = fReading;
122  m_tReadingsMap[cAngle] = fReading;
123  /* Long range [1] */
124  cAngle += CRadians::PI_OVER_TWO;
125  cAngle.SignedNormalize();
126  fReading = CalculateReadingForRay(m_cLongRangeRays1[0], LONG_RANGE_MIN_DISTANCE);
127  m_tLongReadingsMap[cAngle] = fReading;
128  m_tReadingsMap[cAngle] = fReading;
129  /* Short range [2] */
130  cAngle += CRadians::PI_OVER_TWO;
131  cAngle.SignedNormalize();
132  fReading = CalculateReadingForRay(m_cShortRangeRays2[0], SHORT_RANGE_MIN_DISTANCE);
133  m_tShortReadingsMap[cAngle] = fReading;
134  m_tReadingsMap[cAngle] = fReading;
135  /* Long range [3] */
136  cAngle += CRadians::PI_OVER_TWO;
137  cAngle.SignedNormalize();
138  fReading = CalculateReadingForRay(m_cLongRangeRays3[0], LONG_RANGE_MIN_DISTANCE);
139  m_tLongReadingsMap[cAngle] = fReading;
140  m_tReadingsMap[cAngle] = fReading;
141  }
142 
143  /****************************************/
144  /****************************************/
145 
146 #define ADD_READING(RAYS,MAP,INDEX,MINDIST) \
147  cAngle += cInterSensorSpan; \
148  cAngle.SignedNormalize(); \
149  fReading = CalculateReadingForRay(RAYS[INDEX],MINDIST); \
150  MAP[cAngle] = fReading; \
151  m_tReadingsMap[cAngle] = fReading;
152 
153 #define ADD_READINGS(RAYS,MAP,MINDIST) \
154  ADD_READING(RAYS,MAP,1,MINDIST) \
155  ADD_READING(RAYS,MAP,2,MINDIST) \
156  ADD_READING(RAYS,MAP,3,MINDIST) \
157  ADD_READING(RAYS,MAP,4,MINDIST) \
158  ADD_READING(RAYS,MAP,5,MINDIST)
159 
160  void CFootBotDistanceScannerRotZOnlySensor::UpdateRotating() {
161  CRadians cInterSensorSpan = (m_pcDistScanEntity->GetRotation() - m_cLastDistScanRotation).UnsignedNormalize() / 6.0f;
162  CRadians cStartAngle = m_cLastDistScanRotation;
163  /* Short range [0] */
164  CRadians cAngle = cStartAngle;
165  cAngle.SignedNormalize();
166  Real fReading = CalculateReadingForRay(m_cShortRangeRays0[0], SHORT_RANGE_MIN_DISTANCE);
167  m_tShortReadingsMap[cAngle] = fReading;
168  m_tReadingsMap[cAngle] = fReading;
169  ADD_READINGS(m_cShortRangeRays0, m_tShortReadingsMap, SHORT_RANGE_MIN_DISTANCE);
170  /* Short range [2] */
171  cAngle = cStartAngle + CRadians::PI;
172  cAngle.SignedNormalize();
173  fReading = CalculateReadingForRay(m_cShortRangeRays2[0], SHORT_RANGE_MIN_DISTANCE);
174  m_tShortReadingsMap[cAngle] = fReading;
175  m_tReadingsMap[cAngle] = fReading;
176  ADD_READINGS(m_cShortRangeRays2, m_tShortReadingsMap, SHORT_RANGE_MIN_DISTANCE);
177  /* Long range [1] */
178  cAngle = cStartAngle + CRadians::PI_OVER_TWO;
179  cAngle.SignedNormalize();
180  fReading = CalculateReadingForRay(m_cLongRangeRays1[0], LONG_RANGE_MIN_DISTANCE);
181  m_tLongReadingsMap[cAngle] = fReading;
182  m_tReadingsMap[cAngle] = fReading;
183  ADD_READINGS(m_cLongRangeRays1, m_tLongReadingsMap, LONG_RANGE_MIN_DISTANCE);
184  /* Long range [3] */
185  cAngle = cStartAngle + CRadians::PI_OVER_TWO + CRadians::PI;
186  cAngle.SignedNormalize();
187  fReading = CalculateReadingForRay(m_cLongRangeRays3[0], LONG_RANGE_MIN_DISTANCE);
188  m_tLongReadingsMap[cAngle] = fReading;
189  m_tReadingsMap[cAngle] = fReading;
190  ADD_READINGS(m_cLongRangeRays3, m_tLongReadingsMap, LONG_RANGE_MIN_DISTANCE);
191  }
192 
193  /****************************************/
194  /****************************************/
195 
196  Real CFootBotDistanceScannerRotZOnlySensor::CalculateReadingForRay(const CRay3& c_ray,
197  Real f_min_distance) {
198  /* Get the closest intersection */
199  SEmbodiedEntityIntersectionItem sIntersection;
201  c_ray,
202  *m_pcEmbodiedEntity)) {
203  if(m_bShowRays) m_pcControllableEntity->AddIntersectionPoint(c_ray, sIntersection.TOnRay);
204  /* There is an intersection! */
205  Real fDistance = c_ray.GetDistance(sIntersection.TOnRay);
206  if(fDistance > f_min_distance) {
207  /* The distance is returned in meters, but the reading must be in cm */
208  if(m_bShowRays) m_pcControllableEntity->AddCheckedRay(true, c_ray);
209  return fDistance * 100.0f;
210  }
211  else {
212  /* The detected intersection was too close */
213  if(m_bShowRays) m_pcControllableEntity->AddCheckedRay(true, c_ray);
214  return -1.0f;
215  }
216  }
217  else {
218  /* No intersection */
219  if(m_bShowRays) m_pcControllableEntity->AddCheckedRay(false, c_ray);
220  return -2.0f;
221  }
222  }
223 
224  /****************************************/
225  /****************************************/
226 
227 /* Highly reuse the vectors to speed up the computation */
228 #define CALCULATE_SHORT_RANGE_RAY(ANGLE,INDEX) \
229  m_cDirection.RotateZ(ANGLE); \
230  m_cOriginRayStart = m_cDirection; \
231  m_cOriginRayEnd = m_cDirection; \
232  m_cOriginRayStart *= SHORT_RANGE_RAY_START; \
233  m_cOriginRayEnd *= SHORT_RANGE_RAY_END; \
234  m_cRayStart = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
235  m_cRayStart += m_cOriginRayStart; \
236  m_cRayStart.SetZ(m_cRayStart.GetZ() + SENSOR_ELEVATION); \
237  m_cRayEnd = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
238  m_cRayEnd += m_cOriginRayEnd; \
239  m_cRayEnd.SetZ(m_cRayEnd.GetZ() + SENSOR_ELEVATION); \
240  m_cShortRangeRays0[INDEX].Set(m_cRayStart, m_cRayEnd); \
241  m_cRayStart = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
242  m_cRayStart -= m_cOriginRayStart; \
243  m_cRayStart.SetZ(m_cRayStart.GetZ() + SENSOR_ELEVATION); \
244  m_cRayEnd = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
245  m_cRayEnd -= m_cOriginRayEnd; \
246  m_cRayEnd.SetZ(m_cRayEnd.GetZ() + SENSOR_ELEVATION); \
247  m_cShortRangeRays2[INDEX].Set(m_cRayStart, m_cRayEnd); \
248  \
249 /* Highly reuse the vectors to speed up the computation */
250 #define CALCULATE_LONG_RANGE_RAY(ANGLE,INDEX) \
251  m_cDirection.RotateZ(ANGLE); \
252  m_cOriginRayStart = m_cDirection; \
253  m_cOriginRayEnd = m_cDirection; \
254  m_cOriginRayStart *= LONG_RANGE_RAY_START; \
255  m_cOriginRayEnd *= LONG_RANGE_RAY_END; \
256  m_cRayStart = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
257  m_cRayStart += m_cOriginRayStart; \
258  m_cRayStart.SetZ(m_cRayStart.GetZ() + SENSOR_ELEVATION); \
259  m_cRayEnd = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
260  m_cRayEnd += m_cOriginRayEnd; \
261  m_cRayEnd.SetZ(m_cRayEnd.GetZ() + SENSOR_ELEVATION); \
262  m_cLongRangeRays1[INDEX].Set(m_cRayStart, m_cRayEnd); \
263  m_cRayStart = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
264  m_cRayStart -= m_cOriginRayStart; \
265  m_cRayStart.SetZ(m_cRayStart.GetZ() + SENSOR_ELEVATION); \
266  m_cRayEnd = m_pcEmbodiedEntity->GetOriginAnchor().Position; \
267  m_cRayEnd -= m_cOriginRayEnd; \
268  m_cRayEnd.SetZ(m_cRayEnd.GetZ() + SENSOR_ELEVATION); \
269  m_cLongRangeRays3[INDEX].Set(m_cRayStart, m_cRayEnd);
270 
271  /****************************************/
272  /****************************************/
273 
274  void CFootBotDistanceScannerRotZOnlySensor::CalculateRaysNotRotating() {
275  /* We make the assumption that the foot-bot is rotated only around Z */
276  /* Get the foot-bot orientation */
277  CRadians cTmp1, cTmp2, cOrientationZ;
278  m_pcEmbodiedEntity->GetOriginAnchor().Orientation.ToEulerAngles(cOrientationZ, cTmp1, cTmp2);
279  /* Sum the distance scanner orientation */
280  cOrientationZ += m_pcDistScanEntity->GetRotation();
281  /* Calculate the 2D vector representing this rotation */
282  CVector2 cAbsoluteOrientation(1.0, cOrientationZ);
283  /* The short range sensors are oriented along the foot-bot local X */
284  m_cDirection = CVector3::X;
285  CALCULATE_SHORT_RANGE_RAY(cAbsoluteOrientation, 0);
286  /* The short range sensors are oriented along the foot-bot local Y */
287  m_cDirection = CVector3::Y;
288  CALCULATE_LONG_RANGE_RAY(cAbsoluteOrientation, 0);
289  }
290 
291  /****************************************/
292  /****************************************/
293 
294  void CFootBotDistanceScannerRotZOnlySensor::CalculateRaysRotating() {
295  /* We make the assumption that the foot-bot is rotated only around Z */
296  /* Get the foot-bot orientation */
297  CRadians cTmp1, cTmp2, cOrientationZ;
298  m_pcEmbodiedEntity->GetOriginAnchor().Orientation.ToEulerAngles(cOrientationZ, cTmp1, cTmp2);
299  /* Sum the distance scanner orientation */
300  cOrientationZ += m_cLastDistScanRotation;
301  /* Calculate the 2D vector representing this rotation */
302  CVector2 cAbsoluteOrientation(1.0, cOrientationZ);
303  /* The sensor is rotating, so calculate the span between each successive ray */
304  CVector2 cInterSensorSpan(1.0f, (m_pcDistScanEntity->GetRotation() - m_cLastDistScanRotation).UnsignedNormalize() / 6.0f);
305  /* The short range sensors are oriented along the foot-bot local X */
306  m_cDirection = CVector3::X;
307  CALCULATE_SHORT_RANGE_RAY(cAbsoluteOrientation, 0);
308  CALCULATE_SHORT_RANGE_RAY(cInterSensorSpan, 1);
309  CALCULATE_SHORT_RANGE_RAY(cInterSensorSpan, 2);
310  CALCULATE_SHORT_RANGE_RAY(cInterSensorSpan, 3);
311  CALCULATE_SHORT_RANGE_RAY(cInterSensorSpan, 4);
312  CALCULATE_SHORT_RANGE_RAY(cInterSensorSpan, 5);
313  /* The long range sensors are oriented along the foot-bot local Y */
314  m_cDirection = CVector3::Y;
315  CALCULATE_LONG_RANGE_RAY(cAbsoluteOrientation, 0);
316  CALCULATE_LONG_RANGE_RAY(cInterSensorSpan, 1);
317  CALCULATE_LONG_RANGE_RAY(cInterSensorSpan, 2);
318  CALCULATE_LONG_RANGE_RAY(cInterSensorSpan, 3);
319  CALCULATE_LONG_RANGE_RAY(cInterSensorSpan, 4);
320  CALCULATE_LONG_RANGE_RAY(cInterSensorSpan, 5);
321  }
322 
323  /****************************************/
324  /****************************************/
325 
326  REGISTER_SENSOR(CFootBotDistanceScannerRotZOnlySensor,
327  "footbot_distance_scanner", "rot_z_only",
328  "Carlo Pinciroli [ilpincy@gmail.com]",
329  "1.0",
330  "The foot-bot distance scanner sensor (optimized for 2D).",
331  "This sensor accesses the foot-bot distance scanner sensor. For a complete\n"
332  "description of its usage, refer to the common interface.\n"
333  "In this implementation, the readings are calculated under the assumption that\n"
334  "the foot-bot is always parallel to the XY plane, i.e., it rotates only around\n"
335  "the Z axis. This implementation is faster than a 3D one and should be used\n"
336  "only when the assumption about the foot-bot rotation holds.\n\n"
337  "REQUIRED XML CONFIGURATION\n\n"
338  " <controllers>\n"
339  " ...\n"
340  " <my_controller ...>\n"
341  " ...\n"
342  " <sensors>\n"
343  " ...\n"
344  " <footbot_distance_scanner implementation=\"rot_z_only\" />\n"
345  " ...\n"
346  " </sensors>\n"
347  " ...\n"
348  " </my_controller>\n"
349  " ...\n"
350  " </controllers>\n\n"
351  "OPTIONAL XML CONFIGURATION\n\n"
352  "It is possible to draw the rays shot by the distance scanner in the OpenGL\n"
353  "visualization. This can be useful for sensor debugging but also to understand\n"
354  "what's wrong in your controller. In OpenGL, the rays are drawn in cyan when\n"
355  "they are not obstructed and in purple when they are. In case a ray is\n"
356  "obstructed, a black dot is drawn where the intersection occurred.\n"
357  "To turn this functionality on, add the attribute 'show_rays=\"true\"' in the\n"
358  "XML as in this example:\n\n"
359  " <controllers>\n"
360  " ...\n"
361  " <my_controller ...>\n"
362  " ...\n"
363  " <sensors>\n"
364  " ...\n"
365  " <footbot_distance_scanner implementation=\"rot_z_only\"\n"
366  " show_rays=\"true\" />\n"
367  " ...\n"
368  " </sensors>\n"
369  " ...\n"
370  " </my_controller>\n"
371  " ...\n"
372  " </controllers>\n",
373  "Usable"
374  );
375 
376 }
Basic class for an entity that contains other entities.
TReadingsMap m_tLongReadingsMap
Map storing the last received packets from the long distance sensors.
This entity is a link to a body in the physics engine.
T GetSpan() const
Definition: range.h:64
REGISTER_SENSOR(CEyeBotLightRotZOnlySensor, "eyebot_light", "rot_z_only", "Carlo Pinciroli [ilpincy@gmail.com]", "1.0", "The eye-bot light sensor (optimized for 2D).", "This sensor accesses a set of light sensors. The sensors all return a value\ "between 0 and 1, where 0 means nothing within range and 1 means the perceived\" "light saturates the sensor. Values between 0 and 1 depend on the distance of\" "the perceived light. Each reading R is calculated with R=(I/x)^2, where x is the\" "distance between a sensor and the light, and I is the reference intensity of the\" "perceived light. The reference intensity corresponds to the minimum distance at\" "which the light saturates a sensor. The reference intensity depends on the\" "individual light, and it is set with the \intensity\ attribute of the light\" "entity. In case multiple lights are present in the environment, each sensor\" "reading is calculated as the sum of the individual readings due to each light.\" "In other words, light wave interference is not taken into account. In\" "controllers, you must include the ci_light_sensor.h header.\\" "REQUIRED XML CONFIGURATION\\" "< controllers >\" " ...\" "< my_controller ... >\" " ...\" "< sensors >\" " ...\" "< eyebot_light implementation=\rot_z_only\/>\" " ...\" "</sensors >\" " ...\" "</my_controller >\" " ...\" "</controllers >\\" "OPTIONAL XML CONFIGURATION\\" "It is possible to draw the rays shot by the light sensor in the OpenGL\" "visualization. This can be useful for sensor debugging but also to understand\" "what 's wrong in your controller. In OpenGL, the rays are drawn in cyan when\" "they are not obstructed and in purple when they are. In case a ray is\" "obstructed, a black dot is drawn where the intersection occurred.\" "To turn this functionality on, add the attribute \show_rays\ as in this\" "example:\\" "< controllers >\" " ...\" "< my_controller ... >\" " ...\" "< sensors >\" " ...\" "< eyebot_light implementation=\rot_z_only\\" " show_rays=\true\/>\" " ...\" "</sensors >\" " ...\" "</my_controller >\" " ...\" "</controllers >\\" "It is possible to add uniform noise to the sensors, thus matching the\" "characteristics of a real robot better. This can be done with the attribute\" "\noise_level\, whose allowed range is in [-1, 1] and is added to the calculated\" "reading. The final sensor reading is always normalized in the [0-1] range.\\" "< controllers >\" " ...\" "< my_controller ... >\" " ...\" "< sensors >\" " ...\" "< eyebot_light implementation=\rot_z_only\\" " noise_level=\0.1\/>\" " ...\" "</sensors >\" " ...\" "</my_controller >\" " ...\" "</controllers >\\" "OPTIONAL XML CONFIGURATION\\" "None.\", "Usable")
void AddIntersectionPoint(const CRay3 &c_ray, Real f_t_on_ray)
Adds an intersection point to the list.
virtual void SetRobot(CComposableEntity &c_entity)
Sets the entity associated to this sensor.
#define THROW_ARGOSEXCEPTION_NESTED(message, nested)
This macro throws an ARGoS exception with the passed message and nesting the passed exception...
void ToEulerAngles(CRadians &c_z_angle, CRadians &c_y_angle, CRadians &c_x_angle) const
Definition: quaternion.h:172
const SAnchor & GetOriginAnchor() const
Returns a const reference to the origin anchor associated to this entity.
#define ADD_READINGS(RAYS, MAP, MINDIST)
virtual void Init(TConfigurationNode &t_node)
Initializes the sensor from the XML configuration tree.
Definition: ci_sensor.h:54
void GetNodeAttributeOrDefault(TConfigurationNode &t_node, const std::string &str_attribute, T &t_buffer, const T &t_default)
Returns the value of a node&#39;s attribute, or the passed default value.
static const CRadians ZERO
Set to zero radians.
Definition: angles.h:79
The core class of ARGOS.
Definition: simulator.h:62
#define CALCULATE_SHORT_RANGE_RAY(ANGLE, INDEX)
static const CVector3 Y
The y axis.
Definition: vector3.h:37
CRadians & SignedNormalize()
Normalizes the value in the range [-PI:PI].
Definition: angles.h:137
The exception that wraps all errors in ARGoS.
bool GetClosestEmbodiedEntityIntersectedByRay(SEmbodiedEntityIntersectionItem &s_item, const CRay3 &c_ray)
Returns the closest intersection with an embodied entity to the ray start.
ticpp::Element TConfigurationNode
The ARGoS configuration XML node.
static const CRadians PI_OVER_TWO
Set to PI / 2.
Definition: angles.h:59
TReadingsMap m_tReadingsMap
Map storing all the last received packets.
virtual void Init(TConfigurationNode &t_tree)
Initializes the sensor from the XML configuration tree.
TReadingsMap m_tShortReadingsMap
Map storing the last received packets from the short distance sensors.
CQuaternion Orientation
The orientation of the anchor wrt the global coordinate system.
Definition: physics_model.h:53
#define CALCULATE_LONG_RANGE_RAY(ANGLE, INDEX)
An entity that contains a pointer to the user-defined controller.
virtual void Update()
Updates the state of the entity associated to this sensor.
void Enable()
Enables the entity.
Definition: entity.h:265
It defines the basic type CRadians, used to store an angle value in radians.
Definition: angles.h:42
CEntity & GetComponent(const std::string &str_component)
Returns the component with the passed string label.
static const CRadians PI
The PI constant.
Definition: angles.h:49
static CRNG * CreateRNG(const std::string &str_category)
Creates a new RNG inside the given category.
Definition: rng.cpp:326
static const CVector3 X
The x axis.
Definition: vector3.h:34
The namespace containing all the ARGoS related code.
Definition: ci_actuator.h:12
void AddCheckedRay(bool b_obstructed, const CRay3 &c_ray)
Adds a ray to the list of checked rays.
virtual void Reset()
Resets the sensor to the state it had just after Init().
float Real
Collects all ARGoS code.
Definition: datatypes.h:39