int
|
S.dimension ()
|
returns the dimension of the ambient space.
|
|
Point_d<Kernel>
|
S.point ( int i)
|
returns the ith defining
point. Precondition: | 0 ≤ i ≤ dim. |
|
|
point_iterator
|
S.points_begin ()
|
returns an iterator
pointing to the first defining point.
|
|
point_iterator
|
S.points_end ()
|
returns an iterator pointing
beyond the last defining point.
|
|
bool
|
S.is_degenerate ()
|
returns true iff the defining points
are not full dimensional.
|
|
bool
|
S.is_legal ()
|
returns true iff the set of defining
points is legal. A set of defining points is legal iff their
orientation is non-zero or if they are all equal.
|
|
Point_d<Kernel>
|
S.center ()
|
returns the center of S.
Precondition: | S is legal. |
|
|
FT
|
S.squared_radius ()
|
returns the squared radius of the
sphere. Precondition: | S is legal. |
|
|
Orientation
|
S.orientation ()
|
returns the orientation of
S.
|
|
Oriented_side
|
S.oriented_side ( Point_d<Kernel> p)
|
| |
returns
either the constant ON_ORIENTED_BOUNDARY,
ON_POSITIVE_SIDE, or ON_NEGATIVE_SIDE, iff p lies on the
boundary, properly on the positive side, or properly on the negative
side of sphere, resp. Precondition: | S.dimension()==p.dimension(). |
|
|
Bounded_side
|
S.bounded_side ( Point_d<Kernel> p)
|
| |
returns
ON_BOUNDED_SIDE, ON_BOUNDARY, or ON_UNBOUNDED_SIDE
iff p lies properly inside, on the boundary, or properly outside of
sphere, resp. Precondition: | S.dimension()==p.dimension(). |
|
|
bool
|
S.has_on_positive_side ( Point_d<Kernel> p)
|
| |
returns
S.oriented_side(p)==ON_POSITIVE_SIDE. Precondition: | S.dimension()==p.dimension(). |
|
|
bool
|
S.has_on_negative_side ( Point_d<Kernel> p)
|
| |
returns
S.oriented_side(p)==ON_NEGATIVE_SIDE. Precondition: | S.dimension()==p.dimension(). |
|
|
bool
|
S.has_on_boundary ( Point_d<Kernel> p)
|
| |
returns
S.oriented_side(p)==ON_ORIENTED_BOUNDARY, which is the same as
S.bounded_side(p)==ON_BOUNDARY. Precondition: | S.dimension()==p.dimension(). |
|
|
bool
|
S.has_on_bounded_side ( Point_d<Kernel> p)
|
| |
returns
S.bounded_side(p)==ON_BOUNDED_SIDE. Precondition: | S.dimension()==p.dimension(). |
|
|
bool
|
S.has_on_unbounded_side ( Point_d<Kernel> p)
|
| |
returns
S.bounded_side(p)==ON_UNBOUNDED_SIDE. Precondition: | S.dimension()==p.dimension(). |
|
|
Sphere_d<Kernel>
|
S.opposite ()
|
returns the sphere with the same
center and squared radius as S but with opposite orientation.
|
|
Sphere_d<Kernel>
|
S +
Vector_d<Kernel> v
|
returns the
sphere translated by v. Precondition: | S.dimension()==v.dimension(). |
|
Spheres are implemented by a vector of points as a handle type. All
operations like creation, initialization, tests, input and output of a
sphere s take time O(s.dimension()). dimension(),
point access take constant time. The center()-operation takes
time O(d3) on its first call and constant time thereafter. The
sidedness and orientation tests take time O(d3). The space
requirement for spheres is O(s.dimension()) neglecting the
storage room of the points.