# WFMath_Shape (3) - Linux Man Pages

## WFMath_Shape: A fake class which documents the generic parts of the WFMath interface.

## NAME

WFMath::Shape - A fake class which documents the generic parts of the **WFMath** interface.

## SYNOPSIS

#include <shape.h>

### Public Member Functions

bool **isEqualTo** (const **Shape** &s, double tolerance=WFMATH_EPSILON) const

*generic: check if two classes are equal, up to a given tolerance *

bool **operator==** (const **Shape** &s) const

*generic: check if two classes are equal, up to tolerance WFMATH_EPSILON *

bool **operator!=** (const **Shape** &s) const

*generic: check if two classes are not equal, up to tolerance WFMATH_EPSILON *

bool **isValid** () const

*generic: returns true if the class instance has been initialized *

int **numCorners** () const

*shape: return the number of corners in the shape. *

**Point**< dim > **getCorner** (int i) const

*shape: return the position of the i'th corner, where 0 <= i < ***numCorners()**

**Point**< dim > **getCenter** () const

*shape: return the position of the center of the shape *

**Shape** & **shift** (const **Vector**< dim > &v)

*shape: move the shape by an amount given by the ***Vector** v

**Shape** & **moveCornerTo** (const **Point**< dim > &p, int corner)

*shape: move the shape, moving the given corner to the ***Point** p

**Shape** & **moveCenterTo** (const **Point**< dim > &p)

*shape: move the shape, moving the center to the ***Point** p

**Shape** & **rotateCorner** (const **RotMatrix**< dim > &m, int corner)

*shape: rotate the shape while holding the given corner fixed *

**Shape** & **rotateCenter** (const **RotMatrix**< dim > &m)

*shape: rotate the shape while holding the center fixed *

**Shape** & **rotatePoint** (const **RotMatrix**< dim > &m, const **Point**< dim > &p)

*shape: rotate the shape while holding the ***Point** p fixed.

**AxisBox**< dim > **boundingBox** () const

*shape: return the minimal axis-aligned bounding box *

**Ball**< dim > **boundingSphere** () const

*shape: return the minimal bounding sphere *

**Ball**< dim > **boundingSphereSloppy** () const

### Friends

std::ostream & **operator** (std::ostream &os, const **Shape** &s)

*generic: Print an instance to a stream *

std::istream & **operator>>** (std::istream &is, **Shape** &s)

*generic: Parse an instance from a stream *

bool **Intersect** (**Shape**< dim > &s1, **Shape**< dim > &s2, bool proper)

*shape: Returns true if the two shapes intersect. *

bool **Contains** (**Shape**< dim > &s1, **Shape**< dim > &s2, bool proper)

*shape: Returns true if the first shape contains the second. *

## Detailed Description

### template<const int dim> class WFMath::Shape< dim >

A fake class which documents the generic parts of the**WFMath**interface.

This fake class documents two parts of the **WFMath** generic class interface. With a few exceptions (e.g. classes derived from std::exception), every class in **WFMath** implements the part of the interface labeled as 'generic'. The 'shape' interface is implemented by several classes, which identify themselves in their own documentation. Every class which implements the 'shape' interface also implements the 'generic' interface. Classes will not generally document their generic and shape interface functions.

## Member Function Documentation

### template<const int dim> **Ball**<dim> **WFMath::Shape**< dim >::boundingSphereSloppy () const

shape: return an approximate bounding sphere, guaranteed to contain the minimal bounding sphere **boundingSphereSloppy()** uses SloppyDistance() instead of Distance() to calculate it's radius, except in cases like Point<> and Ball<> where it would be silly. Thus, the result of **boundingSphereSloppy()** is guaranteed to contain the result of **boundingSphere()**.

### template<const int dim> **Shape**& **WFMath::Shape**< dim >::moveCenterTo (const **Point**< dim > & p) [inline]

shape: move the shape, moving the center to the **Point** p

The center is defined by **getCenter()**

References WFMath::Shape< dim >::getCenter(), and WFMath::Shape< dim >::shift().

### template<const int dim> **Shape**& **WFMath::Shape**< dim >::moveCornerTo (const **Point**< dim > & p, int corner) [inline]

shape: move the shape, moving the given corner to the **Point** p

The corner in question is getCorner(corner).

References WFMath::Shape< dim >::getCorner(), and WFMath::Shape< dim >::shift().

### template<const int dim> int **WFMath::Shape**< dim >::numCorners () const

shape: return the number of corners in the shape.

For many shape classes, this is a fixed constant

### template<const int dim> **Shape**& **WFMath::Shape**< dim >::rotateCenter (const **RotMatrix**< dim > & m) [inline]

shape: rotate the shape while holding the center fixed

The center is defined by **getCenter()**

References WFMath::Shape< dim >::getCenter(), and WFMath::Shape< dim >::rotatePoint().

### template<const int dim> **Shape**& **WFMath::Shape**< dim >::rotateCorner (const **RotMatrix**< dim > & m, int corner) [inline]

shape: rotate the shape while holding the given corner fixed

The corner in question is getCorner(corner).

References WFMath::Shape< dim >::getCorner(), and WFMath::Shape< dim >::rotatePoint().

### template<const int dim> **Shape**& **WFMath::Shape**< dim >::rotatePoint (const **RotMatrix**< dim > & m, const **Point**< dim > & p)

shape: rotate the shape while holding the **Point** p fixed.

Note that p can be any **Point**, it does not have to lie within the shape.

Referenced by WFMath::Shape< dim >::rotateCenter(), and WFMath::Shape< dim >::rotateCorner().

## Friends And Related Function Documentation

### template<const int dim> bool Contains (**Shape**< dim > & s1, **Shape**< dim > & s2, bool proper) [friend]

shape: Returns true if the first shape contains the second.

If the 'proper' argument is true, the inner shape is not contained if it touches the boundary of the outer shape. Otherwise, it does. Therefore, any shape contains itself (Contains(foo, foo, false) == true), but no shape contains itself properly (Contains(foo, foo, true) == false). Because of this, an empty shape (e.g. a **Polygon** with zero corners) is properly contained by any other shape. A **Point**, or any single point shape (e.g. a **Segment** where the endpoints are equal) properly contains an empty shape, and contains (but not properly) any other single point shape which occupies the same point. The two shapes do not have to be the same class, but must have the same dimension.

### template<const int dim> bool Intersect (**Shape**< dim > & s1, **Shape**< dim > & s2, bool proper) [friend]

shape: Returns true if the two shapes intersect.

If the 'proper' argument is true, shapes which only touch on their boundary do not count as intersecting. If it is false, they do. This function is symmetric in its first two arguments (Intersect(a, b, proper) == Intersect(b, a, proper)). The two shapes do not have to be the same class, but must have the same dimension.

## Author

Generated automatically by Doxygen for WFMath from the source code.