265 lines
8.2 KiB
C++
Executable File
265 lines
8.2 KiB
C++
Executable File
// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany).
|
|
// All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org).
|
|
// 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$
|
|
// SPDX-License-Identifier: GPL-3.0+
|
|
//
|
|
//
|
|
// Author(s) : Michael Seel <seel@mpi-inf.mpg.de>
|
|
// Peter Hachenberger <hachenberger@mpi-inf.mpg.de>
|
|
|
|
#ifndef CGAL_SPHERE_GEOMETRY_H
|
|
#define CGAL_SPHERE_GEOMETRY_H
|
|
|
|
#include <CGAL/license/Nef_S2.h>
|
|
|
|
|
|
#include <CGAL/basic.h>
|
|
#include <CGAL/intersection_3.h>
|
|
#include <list>
|
|
|
|
#undef CGAL_NEF_DEBUG
|
|
#define CGAL_NEF_DEBUG 113
|
|
#include <CGAL/Nef_2/debug.h>
|
|
|
|
namespace CGAL {
|
|
|
|
template <class R> class Sphere_point;
|
|
template <class R> class Sphere_segment;
|
|
template <class R> class Sphere_triangle;
|
|
template <class R> class Sphere_circle;
|
|
template <class R> class Sphere_direction;
|
|
|
|
} //namespace CGAL
|
|
|
|
#include <CGAL/Nef_S2/Sphere_point.h>
|
|
#include <CGAL/Nef_S2/Sphere_circle.h>
|
|
#include <CGAL/Nef_S2/Sphere_direction.h>
|
|
#include <CGAL/Nef_S2/Sphere_segment.h>
|
|
#include <CGAL/Nef_S2/Sphere_triangle.h>
|
|
#include <CGAL/Nef_S2/sphere_predicates.h>
|
|
|
|
namespace CGAL {
|
|
|
|
template <typename R_>
|
|
struct Positive_halfsphere_geometry {
|
|
|
|
typedef R_ R;
|
|
typedef CGAL::Sphere_point<R> Point_2;
|
|
typedef CGAL::Sphere_segment<R> Segment_2;
|
|
|
|
int axis;
|
|
|
|
Positive_halfsphere_geometry() : axis(2) {}
|
|
Positive_halfsphere_geometry(int check_sphere) : axis(check_sphere) {}
|
|
|
|
Point_2 source(const Segment_2& s) const
|
|
{ return s.source(); }
|
|
Point_2 target(const Segment_2& s) const
|
|
{ return s.target(); }
|
|
Segment_2 construct_segment(const Point_2& p, const Point_2& q) const
|
|
{ return Segment_2(p,q); }
|
|
|
|
void xz_pi_half_rotate(Point_2& p) const
|
|
{ p = Point_2(-p.hz(),p.hy(),p.hx()); }
|
|
|
|
void zx_pi_half_rotate(Point_2& p) const
|
|
{ p = Point_2(-p.hz(),p.hy(),p.hx()); }
|
|
|
|
void xy_pi_half_rotate(Point_2& p) const
|
|
{ p = Point_2(-p.hy(),p.hx(),p.hz()); }
|
|
|
|
int orientation(const Point_2& p1, const Point_2& p2,
|
|
const Point_2& p3) const {
|
|
|
|
int sor = CGAL::spherical_orientation(p1,p2,p3);
|
|
if (sor) return sor;
|
|
Point_2 pp1(p1), pp2(p2), pp3(p3);
|
|
switch(axis) {
|
|
case 0:
|
|
if ( !( p1.hx() == 0 && p2.hx() == 0 && p3.hx() == 0) ) return sor;
|
|
if ( p1.hz()<0 ) zx_pi_half_rotate(pp1);
|
|
if ( p2.hz()<0 ) zx_pi_half_rotate(pp2);
|
|
if ( p3.hz()<0 ) zx_pi_half_rotate(pp3);
|
|
return CGAL::spherical_orientation(pp1,pp2,pp3);
|
|
break;
|
|
case 1:
|
|
if ( !( p1.hy() == 0 && p2.hy() == 0 && p3.hy() == 0) ) return sor;
|
|
if ( p1.hx()>0 ) xy_pi_half_rotate(pp1);
|
|
if ( p2.hx()>0 ) xy_pi_half_rotate(pp2);
|
|
if ( p3.hx()>0 ) xy_pi_half_rotate(pp3);
|
|
return CGAL::spherical_orientation(pp1,pp2,pp3);
|
|
break;
|
|
case 2:
|
|
if ( !( p1.hz() == 0 && p2.hz() == 0 && p3.hz() == 0) ) return sor;
|
|
// sor==0 we perturb any point in the xy-plane with x>0
|
|
// by a negative rotation around the y-axis
|
|
// our perturbation is big :-) we take PI/2 :
|
|
if ( p1.hx()>0 ) xz_pi_half_rotate(pp1);
|
|
if ( p2.hx()>0 ) xz_pi_half_rotate(pp2);
|
|
if ( p3.hx()>0 ) xz_pi_half_rotate(pp3);
|
|
return CGAL::spherical_orientation(pp1,pp2,pp3);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int orientation(const Segment_2& s, const Point_2& p) const
|
|
{ return orientation(s.source(),s.target(),p); }
|
|
|
|
bool is_degenerate(const Segment_2& s) const
|
|
{ return s.is_degenerate(); }
|
|
|
|
int compare_xy(const Point_2& p1, const Point_2& p2) const {
|
|
CGAL_NEF_TRACEN("compare_xy " << axis << ":" << p1 << " / " << p2);
|
|
return CGAL::spherical_compare(p1,p2,axis,+1);
|
|
}
|
|
|
|
Point_2 intersection(const Segment_2& s1, const Segment_2& s2) const
|
|
{ if (s1.sphere_circle() != s2.sphere_circle().opposite())
|
|
return s1.intersection(s2);
|
|
CGAL_assertion(s1.target()==s2.target());
|
|
return s1.target();
|
|
}
|
|
|
|
}; // Positive_halfsphere_geometry<R>
|
|
|
|
template <typename R>
|
|
struct Negative_halfsphere_geometry :
|
|
public Positive_halfsphere_geometry<R> {
|
|
|
|
typedef Positive_halfsphere_geometry<R> Base;
|
|
typedef typename Base::Point_2 Point_2;
|
|
typedef typename Base::Segment_2 Segment_2;
|
|
|
|
using Base::xz_pi_half_rotate;
|
|
using Base::zx_pi_half_rotate;
|
|
using Base::xy_pi_half_rotate;
|
|
|
|
Negative_halfsphere_geometry() : Base() {}
|
|
Negative_halfsphere_geometry(int check_sphere) : Base(check_sphere) {}
|
|
|
|
int orientation(const Point_2& p1, const Point_2& p2,
|
|
const Point_2& p3) const {
|
|
|
|
int sor = CGAL::spherical_orientation(p1,p2,p3);
|
|
if (sor) return sor;
|
|
Point_2 pp1(p1), pp2(p2), pp3(p3);
|
|
switch(((Base*) this)->axis) {
|
|
case 0:
|
|
if ( !( p1.hx() == 0 && p2.hx() == 0 && p3.hx() == 0) ) return sor;
|
|
if ( p1.hz()>0 ) zx_pi_half_rotate(pp1);
|
|
if ( p2.hz()>0 ) zx_pi_half_rotate(pp2);
|
|
if ( p3.hz()>0 ) zx_pi_half_rotate(pp3);
|
|
return CGAL::spherical_orientation(pp1,pp2,pp3);
|
|
break;
|
|
case 1:
|
|
if ( !( p1.hy() == 0 && p2.hy() == 0 && p3.hy() == 0) ) return sor;
|
|
if ( p1.hx()<0 ) xy_pi_half_rotate(pp1);
|
|
if ( p2.hx()<0 ) xy_pi_half_rotate(pp2);
|
|
if ( p3.hx()<0 ) xy_pi_half_rotate(pp3);
|
|
return CGAL::spherical_orientation(pp1,pp2,pp3);
|
|
break;
|
|
case 2:
|
|
if ( !( p1.hz() == 0 && p2.hz() == 0 && p3.hz() == 0) ) return sor;
|
|
// sor==0 we perturb any point in the xy-plane with x>0
|
|
// by a negative rotation around the y-axis
|
|
// our perturbation is big :-) we take PI/2 :
|
|
if ( p1.hx()<0 ) xz_pi_half_rotate(pp1);
|
|
if ( p2.hx()<0 ) xz_pi_half_rotate(pp2);
|
|
if ( p3.hx()<0 ) xz_pi_half_rotate(pp3);
|
|
return CGAL::spherical_orientation(pp1,pp2,pp3);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int orientation(const Segment_2& s, const Point_2& p) const
|
|
{ return orientation(s.source(),s.target(),p); }
|
|
|
|
int compare_xy(const Point_2& p1, const Point_2& p2) const
|
|
{ return CGAL::spherical_compare(p1,p2,this->axis,-1); }
|
|
|
|
}; // Negative_halfsphere_geometry<R>
|
|
|
|
template <typename R_>
|
|
struct Sphere_geometry {
|
|
|
|
typedef R_ R;
|
|
typedef typename R_::RT RT;
|
|
typedef typename R_::FT FT;
|
|
typedef CGAL::Sphere_point<R> Sphere_point;
|
|
typedef CGAL::Sphere_segment<R> Sphere_segment;
|
|
typedef CGAL::Sphere_circle<R> Sphere_circle;
|
|
typedef CGAL::Sphere_direction<R> Sphere_direction;
|
|
typedef CGAL::Sphere_triangle<R> Sphere_triangle;
|
|
typedef typename R::Point_3 Point_3;
|
|
typedef typename R::Plane_3 Plane_3;
|
|
typedef typename R::Aff_transformation_3 Aff_transformation_3;
|
|
typedef CGAL::Positive_halfsphere_geometry<R> Positive_halfsphere_geometry;
|
|
typedef CGAL::Negative_halfsphere_geometry<R> Negative_halfsphere_geometry;
|
|
|
|
Sphere_point source(const Sphere_segment& s) const
|
|
{ return s.source(); }
|
|
|
|
Sphere_point target(const Sphere_segment& s) const
|
|
{ return s.target(); }
|
|
|
|
Sphere_segment construct_segment(const Sphere_point& p,
|
|
const Sphere_point& q) const
|
|
{ return Sphere_segment(p,q); }
|
|
|
|
Sphere_segment construct_segment(const Sphere_point& p,
|
|
const Sphere_point& q,
|
|
const Plane_3& h) const
|
|
{ return Sphere_segment(p,q,Sphere_circle(h)); }
|
|
|
|
Plane_3 affine_representation(const Plane_3& h, const Point_3& p) const
|
|
{ RT wp = p.hw();
|
|
return Plane_3(wp*h.a(),wp*h.b(),wp*h.c(),
|
|
-(p.hx()*h.a() + p.hy()*h.b() + p.hz()*h.c())); }
|
|
|
|
Plane_3 linear_representation(const Plane_3& h) const
|
|
{ return Plane_3(h.a(),h.b(),h.c(),0); }
|
|
|
|
/*
|
|
Positive_halfsphere_geometry PHG;
|
|
const Positive_halfsphere_geometry&
|
|
get_positive_halfsphere_geometry() const
|
|
{ return PHG; }
|
|
|
|
Negative_halfsphere_geometry NHG;
|
|
const Negative_halfsphere_geometry&
|
|
get_negative_halfsphere_geometry() const
|
|
{ return NHG; }
|
|
*/
|
|
|
|
const Positive_halfsphere_geometry&
|
|
get_positive_halfsphere_geometry(int a) const {
|
|
return Positive_halfsphere_geometry(a);
|
|
}
|
|
|
|
const Negative_halfsphere_geometry&
|
|
get_negative_halfsphere_geometry(int a) const {
|
|
return Negative_halfsphere_geometry(a);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} //namespace CGAL
|
|
#endif //CGAL_SPHERE_GEOMETRY_H
|