Tools/PotentialFields/FutureWorldModelGenerator.h

Go to the documentation of this file.

/**
* @file FutureWorldModelGenerator.h
* 
* Definition of class FutureWorldModelGenerator
*
* @author <a href="mailto:timlaue@informatik.uni-bremen.de">Tim Laue</a>
*/

#ifndef FUTUREWORLDMODELGENERATOR_H_
#define FUTUREWORLDMODELGENERATOR_H_


#include <string>
#include <vector>

class Potentialfield;
class Actionfield;
class PotentialfieldTransformation;
class Rotation;
class Action;
class PotentialFieldsObject;
class PfPose;
class Polygon;
class PfVec;


/**
* @class FutureWorldModelGenerator
*
* A class for computing a world model after excuting a specific action.
*/
class FutureWorldModelGenerator
{
private:
  /** Constructor */
  FutureWorldModelGenerator() {};

public:
  /** Returns a pointer to the class (which is a singleton)
  * @return The pointer
  */
  static FutureWorldModelGenerator* getFutureWorldModelGenerator()
  {
    static FutureWorldModelGenerator instance;
    return &instance;
  }

  /** Transforms the world state by applying an action
  * @param poseNow The original pose
  * @param poseThen The pose after the action
  * @param action The action
  * @param callingField The potential field calling this function
  * @param worldStateNow The state of all objects before the action
  * @param worldStateThen The state of all objects after the action
  * @param worldStateStatic All static objects (never move, cannot be moved)
  */
  void transformWorldState(const PfPose& poseNow, PfPose& poseThen,
                           Action& action, Actionfield* callingField,
                           std::vector<PotentialFieldsObject*>& worldStateNow, 
                           std::vector<PotentialFieldsObject*>& worldStateThen,
                           std::vector<PotentialFieldsObject*>& worldStateStatic);

private:
  /** Executes a transformation
  * @param pose The robot pose (may be changed by this function)
  * @param action The action to which the transformation is assigned
  * @param transformation The transformation to be executed
  * @param callingField The potential field using this class
  * @param dynamicWorldState All dynamic objects (may be changed by this function)
  * @param staticWorldState All static objects
  */
  void executeSingleTransformation(PfPose& pose, Action& action, 
                                   PotentialfieldTransformation* transformation,
                                   Actionfield* callingField,
                                   std::vector<PotentialFieldsObject*>& dynamicWorldState,
                                   std::vector<PotentialFieldsObject*>& staticWorldState);

  /** Checks a planned transformation for collisions
  * @param objectPose The pose of the object to be transformed
  * @param translation The planned translation
  * @param otherObjects All dynamic objects
  * @param otherStaticObjects All static objects
  * @param excludedObject The index (in otherObjects) of the object to be checked
  * @return A value [0.0 .. 1.0] indicated "how much" of the translation may be executed
  */
  double getMaxTranslationForObject(const PfPose& objectPose,
                                    const PfVec& translation,
                                    std::vector<PotentialFieldsObject*>& otherObjects,
                                    std::vector<PotentialFieldsObject*>& otherStaticObjects,
                                    int excludedObject = -1);

  /** Checks a planned rotation for collisions
  * @param objectPose The pose of the object to be transformed
  * @param rotationPose The position to rotate around also including the current rotation
  * @param rotation The planned rotation
  * @param otherObjects All dynamic objects
  * @param otherStaticObjects All static objects
  * @param excludedObject The index (in otherObjects) of the object to be checked
  * @return A value [0.0 .. 1.0] indicated "how much" of the translation may be executed
  */
  double getMaxRotationForObject(const PfPose& objectPose,
                                 const PfPose& rotationPose,
                                 double rotation,
                                 std::vector<PotentialFieldsObject*>& otherObjects,
                                 std::vector<PotentialFieldsObject*>& otherStaticObjects,
                                 int excludedObject = -1);
};


#endif //FUTUREWORLDMODELGENERATOR_H_

---