mirror of https://github.com/CGAL/cgal
154 lines
5.4 KiB
C++
154 lines
5.4 KiB
C++
/****************************************************************************
|
|
* Core Library Version 1.7, August 2004
|
|
* Copyright (c) 1995-2004 Exact Computation Project
|
|
* All rights reserved.
|
|
*
|
|
* This file is part of CORE (http://cs.nyu.edu/exact/core/).
|
|
* You can redistribute it and/or modify it under the terms of the GNU
|
|
* General Public License as published by the Free Software Foundation,
|
|
* either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* Licensees holding a valid commercial license may use this file in
|
|
* accordance with the commercial license agreement provided with the
|
|
* software.
|
|
*
|
|
* This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
* WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
***************************************************************************/
|
|
/*****************************************************************
|
|
* File: circle2d.h
|
|
* Synopsis:
|
|
* Basic 2-dimensional geometry
|
|
* Author: Shubin Zhao (shubinz@cs.nyu.edu), 2001.
|
|
*
|
|
*****************************************************************
|
|
* CORE Library Version 1.4 (July 2001)
|
|
* Chee Yap <yap@cs.nyu.edu>
|
|
* Chen Li <chenli@cs.nyu.edu>
|
|
* Zilin Du <zilin@cs.nyu.edu>
|
|
*
|
|
* Copyright (c) 1995, 1996, 1998, 1999, 2000, 2001 Exact Computation Project
|
|
*
|
|
* WWW URL: http://cs.nyu.edu/exact/
|
|
* Email: exact@cs.nyu.edu
|
|
*
|
|
* $Id$
|
|
*****************************************************************/
|
|
|
|
#ifndef _CIRCLE2D_H
|
|
#define _CIRCLE2D_H
|
|
|
|
#include <CGAL/CORE/geom2d/point2d.h>
|
|
#include <CGAL/CORE/geom2d/line2d.h>
|
|
|
|
class Circle2d : public GeomObj {
|
|
|
|
/* An instance C of the data type circle is an oriented circle
|
|
in the plane passing through three points p1, p2, p3. The
|
|
orientation of C is equal to the orientation of the three defining
|
|
points. i.e. orientation(p1, p2, p3).
|
|
If \Labs{\{p1, p2, p3\}} = 1, C is the empty circle with center p1.
|
|
If p1, p2 and p3 are collinear, C is a straight line passing through
|
|
p1, p2 and p3 in this order and the center of C is undefined.
|
|
*/
|
|
|
|
private:
|
|
|
|
Point2d p1; // the 3 points defining the circle
|
|
Point2d p2;
|
|
Point2d p3;
|
|
|
|
int orient; //orientation(p1, p2, p3)
|
|
|
|
Point2d* cp; //pointer to center
|
|
double * rp; //pointer to radius
|
|
|
|
public:
|
|
|
|
Circle2d( const Point2d& p1, const Point2d& p2, const Point2d& p3);
|
|
//initialized to the oriented circle through points p1, p2, p3
|
|
|
|
Circle2d(const Point2d& a, const Point2d& b0);
|
|
//initialized to the counter-clockwise oriented circle with center a
|
|
//passing through b0
|
|
|
|
Circle2d(const Point2d& p);
|
|
//initialized to the trivial circle with center p
|
|
|
|
Circle2d();
|
|
//initialized to the trivial circle with center (0,0)
|
|
|
|
Circle2d(const Point2d& c, double r);
|
|
//initialized to the circle with center c and radius r with positive
|
|
//(i.e. counter-clockwise) orientation
|
|
|
|
Circle2d(const Circle2d& c);
|
|
//copy constructor
|
|
|
|
virtual ~Circle2d();
|
|
|
|
Circle2d& operator=(const Circle2d& C);
|
|
|
|
//operations
|
|
|
|
Point2d center();
|
|
//return the center of the circle
|
|
|
|
double radius();
|
|
//returns the radius.
|
|
//precond: the orientation of the circle is not 0
|
|
|
|
Point2d point1() const { return p1; }
|
|
Point2d point2() const { return p2; }
|
|
Point2d point3() const { return p3; }
|
|
|
|
// Point2d point_on_circle(float alpha);
|
|
//returns a point p on the circle with angle of alpha
|
|
|
|
bool is_degerate() const { return orient == 0; }
|
|
//returns true if the defining points are collinear
|
|
|
|
bool is_trivial() const {return p1 == p2; }
|
|
//returns true if radius is zero
|
|
|
|
int orientation() const { return orient; }
|
|
|
|
int side_of(const Point2d& p) const;
|
|
// returns -1, +1 or 0 if p lies right of, left of or on the circle
|
|
// respectively
|
|
|
|
bool inside(const Point2d& p);
|
|
//returns true if p lies inside of the circle
|
|
|
|
bool outside(const Point2d& p);
|
|
|
|
bool contains(const Point2d& p) const ;
|
|
//returns true if p lies on the circle, false otherwise
|
|
|
|
double distance(const Point2d& p);
|
|
//returns the distance between p and the circle: distance to center - radius
|
|
|
|
double distance(const Line2d& l);
|
|
//returns the distance between l and the circle
|
|
//distance from center to l minus radius
|
|
|
|
double distance(Circle2d& D);
|
|
//returns the distance between this circle and circle D
|
|
//distance between two centers minus two radius
|
|
|
|
bool operator==(const Circle2d& D) const ;
|
|
bool operator!=(const Circle2d& D) const
|
|
{ return !operator==(D); }
|
|
|
|
friend std::ostream& operator<<(std::ostream& out, Circle2d& c);
|
|
friend std::istream& operator>>(std::istream& in, Circle2d c); //?? Circle2d &
|
|
|
|
}; // class Circle2d
|
|
|
|
|
|
#endif
|