parentalLinks.doxy

  for (sensors_ptr_set_t::iterator senIter = sensorsPtrSet.begin(); senIter != sensorsPtrSet.end(); senIter++) { // loop sensors
    sensor_ptr_t senPtr = senIter->second;
    cout << "exploring sensor: " << senPtr->id() << endl;
    senPtr->doSomething();
  }
  \endcode
  
  \subsection secUpwards Traversing upwards: links CHILD -> PARENT.
    
  Traversing upwards is a bit more tricky because \c weak_ptr needs to lock the operation of \c shared_ptr before accessing the object.
  We encapsulated the necessary code into a convenient function with the name of the pointer, 
  such that the only difference you see is the aparition of a couple of empty brackets. For example:
  \code
  senPtr->robotPtr()->state.x()
  \endcode
  is the state of the robot owning a particular sensor, accessed from that sensor.
  
  \subsection secDownCasting Downcasting to access derived class parameters. Links DERIVED_OBS -> DERIVED_PARENT.
  
  The observation class needs to access information in Sensor and Landmark that only exist in the derived versions. 
  For example, observing an AHP point from a Pin-hole camera requires knowledge about the sensor's intrinsic parameters. 
  But these parameters do not exist at the Abstract level.
  
  We add a couple of pointers to each derived observation class, especially dedicated to each particular parent. 
  These pointers are a downcast of the ones at the abstract level.
  
  The downcast is done at construction time of the object \c ObservationPinHoleAnchoredHomogeneousPoint, with something like this:
  \code
  // Some type definitions
  typedef weak_ptr<SensorPinHole> pinhole_ptr_t;
  typedef weak_ptr<LandmarkAnchoredHomogeneousPoint> ahp_ptr_t;
  // Members of the derived observation class 
  pinhole_ptr_t pinholePtr;
  ahp_ptr_t ahpPtr;
  // At construction time of the derived observation object 
  pinholePtr = dynamic_pointer_cast<SensorPinHole> (sensorPtr);
  ahpPtr = dynamic_pointer_cast<LandmarkAnchoredHomogeneousPoint> (landmarkPtr);
  \endcode
  
  With this downcast, we can now access the parameters of the sensor. For example, this ficticious function:
  \code
  vec3 p = ahpPtr->convertToEuclidean();
  vec2 u = ObsAHP.project(pinholePtr->intrinsic, p);
  \endcode
  converts the AHP into an Euclidean point, and projects it into the pin-hole sensor. 
  
  
  
  */