Aria: ArMapObject Class Reference

- Main Page
- Classes
- Files
- Related Pages

- Alphabetical List
- Class List
- Class Hierarchy
- Class Members

# ArMapObject Class Reference

`#include <ArMapObject.h>`

List of all members.

## Detailed Description

A point or region of interest in an Aria map.

ArMapObject contains the data related to an Aria map object, i.e a point or region of interest in an Aria map that is not part of the sensed obstacle data. Examples of map objects include goals, docks, forbidden lines, and forbidden areas. Applications may define their own custom ArMapObject types using the ArMap MapInfo mechanism. See ArMap for more information.

The basic attributes of an ArMapObject include the type of the map object, an optional name of the object, and its position information. As mentioned above, there are two basic categories of ArMapObjects:

- Points: A single ArPose in the map. By convention, if a map object can have an optional heading, then "WithHeading" appears at the end of the object type when the heading is specified. For example, "Goal" designates an (x,y) location in the map (any heading or theta value should be ignored) and "GoalWithHeading" designates an (x,y,th) location.

- Regions: A set of two ArPoses ("from" and "to") which define a rectangle or a line. Rectangles may have an associated rotation value. It is the rotation to be applied to the "from" and "to" poses around the global origin . To retrieve the list of line segments that comprise the rotated rectangle's perimeter, use the getFromToSegments() method.

Note that the ArMapObject is generally immutable. If an object needs to be changed, then the original version should simply be replaced with a new one. See ArMap::getMapObjects(), ArMap::setMapObjects(), and ArMap::mapChanged().

## Public Member Functions
| ArMapObject (const ArMapObject &mapObject)
| Copy constructor.
| ArMapObject (const char *type, ArPose pose, const char *description, const char *iconName, const char *name, bool hasFromTo, ArPose fromPose, ArPose toPose)
| Constructor.
ArPose | findCenter (void) const
| Computes the center pose of the map object.
const char * | getBaseType (void) const
| Returns the "base" (or root) type of the map object.
const char * | getDescription () const
| Returns the optional description of the map object.
const char * | getFileName (void) const
| Gets the fileName of the object (probably never used for maps).
ArPose | getFromPose (void) const
| Returns the "from" pose for lines and rectangles; valid only if hasFromTo().
double | getFromToRotation (void) const
| Returns the optional rotation of a rectangle; or 0 if none.
std::list< ArLineSegment > | getFromToSegments (void)
| Gets a list of fromTo line segments that have been rotated.
const char * | getIconName (void) const
| Returns the icon string of the object.
const char * | getName (void) const
| Returns the name of the map object (if any).
ArPose | getPose (void) const
| Returns the primary pose of the object.
const char * | getStringRepresentation () const
| Returns the text representation of the map object.
ArPose | getToPose (void) const
| Returns the "to" pose for lines and rectangles; valid only if hasFromTo().
const char * | getType (void) const
| Returns the type of the map object.
bool | hasFromTo (void) const
| Returns true if the map object has valid "from/to" poses (i.e. is a line or rectangle).
void | log (const char *intro=NULL)
| Writes the map object to the ArLog.
bool | operator< (const ArMapObject &other) const
| Less than operator (for sets), orders by position.
ArMapObject & | operator= (const ArMapObject &mapObject)
| Assignment operator.
void | setDescription (const char *description)
| Sets the description of the map object.
const char * | toString () const
| Returns the text representation of the map object.
virtual | ~ArMapObject ()
| Destructor.
## Static Public Member Functions
static ArMapObject * | createMapObject (ArArgumentBuilder *arg)
| Creates a new ArMapObject whose attributes are as specified in the given arguments.
## Protected Attributes
std::string | myBaseType
| If non-empty, then myType ends with "WithHeading" and this is the "root".
std::string | myDescription
| The description of the map object.
ArPose | myFromPose
| The "from" pose of a region map object; valid only if myHasFromTo is true.
std::list< ArLineSegment > | myFromToSegments
| For rectangle objects, the line segments that comprise the perimeter (even if rotated).
bool | myHasFromTo
| Whether the map object is a region (line or rect) with "from/to" poses.
std::string | myIconName
| Reserved for future use.
std::string | myName
| The name of the map object, if any.
ArPose | myPose
| For pose objects, THE pose; For rectangle objects, contains the optional rotation.
std::string | myStringRepresentation
| Text representation written to the map file.
ArPose | myToPose
| The "to" pose of a region map object; valid only if myHasFromTo is true.
std::string | myType
| The type of the map object.

## Constructor & Destructor Documentation

ArMapObject::ArMapObject | ( | const char * | type,
|  | ArPose | pose,
|  | const char * | description,
|  | const char * | iconName,
|  | const char * | name,
|  | bool | hasFromTo,
|  | ArPose | fromPose,
|  | ArPose | toPose |
| ) |  |  |

Constructor.

Parameters:

  | type | the char * type of the map object (e.g. "Goal", "ForbiddenLine"); must be non-empty
  | pose | the primary ArPose of the map object; for points, this is its location; for rectangles, this specifies the rotation of the rectangle (in pose.getTh())
  | description | an optional char * description of the object.
  | iconName | char * currently unused
  | name | the char * name of the map object; depending on the object type, this may be optional or required
  | hasFromTo | a bool set to true if the object is a region (i.e. line or rectangle); false if the object is a point
  | fromPose | the ArPose that defines the start point of the region object; applicable only when hasFromTo is true
  | toPose | the ArPose that defines the end point of the region object; applicable only when hasFromTo is true

## Member Function Documentation

static ArMapObject* ArMapObject::createMapObject | ( | ArArgumentBuilder * | arg | ) | `[static]`

Creates a new ArMapObject whose attributes are as specified in the given arguments.

Parameters:

  | arg | the ArArgumentBuilder * from which to create the ArMapObject; this should correspond to a parsed line in the ArMap file

Returns:
  ArMapObject * the newly created map object, or NULL if an error occurred

ArPose ArMapObject::findCenter | ( | void |  | ) | const

Computes the center pose of the map object.

This method determines the center of map objects that have a "from" and a "to" pose (i.e. lines and rectangles). For map objects that are poses, this method simply returns the pose.

const char* ArMapObject::getBaseType | ( | void |  | ) | const

Returns the "base" (or root) type of the map object.

If the map object type ends with "WithHeading", then the base is the corresponding heading-less type. For example, "GoalWithHeading" has a base type of "Goal".

If the map object type does not end with "WithHeading", then the base is the same as the type.

const char* ArMapObject::getFileName | ( | void |  | ) | const

Gets the fileName of the object (probably never used for maps).

This method is maintained solely for backwards compatibility. It now returns the same value as getDescription (i.e. any file names that may have been associated with an object can now be found in the description attribute).

Deprecated:

double ArMapObject::getFromToRotation | ( | void |  | ) | const

Returns the optional rotation of a rectangle; or 0 if none.

Note that this function doesn't know whether it actually makes sense for this map object to have the rotation. (For example, it makes sense on a ForbiddenArea but not a ForbiddenLine.)

std::list<ArLineSegment> ArMapObject::getFromToSegments | ( | void |  | ) |

Gets a list of fromTo line segments that have been rotated.

Note that this function doesn't know whether it actually makes sense for this map object to have the rotation. (For example, it makes sense on a ForbiddenArea but not a ForbiddenLine.) This is just here so that everyone doesn't have to do the same calculation. Note that this might be a little more CPU/Memory intensive transfering these around, so you may want to keep a copy of them if you're using them a lot (but make sure you clear the copy if the map changes). It may not make much difference on a modern processor though (its set up this way for safety).

const char* ArMapObject::getIconName | ( | void |  | ) | const

Returns the icon string of the object.

Reserved for future use

ArPose ArMapObject::getPose | ( | void |  | ) | const

Returns the primary pose of the object.

For points, this is the map object's location; for rectangles, this specifies the rotation of the rectangle (in getPose().getTh())

const char* ArMapObject::getStringRepresentation | ( |  | ) | const`[inline]`

Returns the text representation of the map object.

This method is equivalent to toString();

void ArMapObject::log | ( | const char * | intro = `NULL` | ) |

Writes the map object to the ArLog.

Parameters:

  | intro | an optional string that should appear before the object

void ArMapObject::setDescription | ( | const char * | description | ) |

Sets the description of the map object.

This method really should only be called immediately after the object is created, and before it is added to the map. (Since the map object isn't intended to be mutable.) It exists for backwards compatibility.

const char* ArMapObject::toString | ( |  | ) | const

Returns the text representation of the map object.

The returned string is suitable for writing to the ArMap file. Note that the string does NOT include the map object's optional parameters.

The documentation for this class was generated from the following file:

- ArMapObject.h