416 lines
15 KiB
C
416 lines
15 KiB
C
|
// 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-sb.mpg.de>
|
||
|
|
|
||
|
|
#ifndef CGAL_SPHERE_PREDICATES_H
|
||
|
|
#define CGAL_SPHERE_PREDICATES_H
|
||
|
|
|
||
|
|
#include <CGAL/license/Nef_S2.h>
|
||
|
|
|
||
|
|
|
||
|
|
#include <CGAL/basic.h>
|
||
|
|
#undef CGAL_NEF_DEBUG
|
||
|
|
#define CGAL_NEF_DEBUG 23
|
||
|
|
#include <CGAL/Nef_2/debug.h>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
#undef CGAL_forall_iterators
|
||
|
|
#define CGAL_forall_iterators(x,L)\
|
||
|
|
for(x = (L).begin(); x != (L).end(); ++x)
|
||
|
|
|
||
|
|
|
||
|
|
namespace CGAL {
|
||
|
|
|
||
|
|
/* |spherical_orientation| takes three points of one hemisphere and
|
||
|
|
returns the orientation of $p_3$ with respect to the halfcircle
|
||
|
|
through $p_1$ and $p_2$. We map this to the 3d orientation predicate
|
||
|
|
of the origin, $p_1$, $p_2$, and $p_3$ */
|
||
|
|
|
||
|
|
template <class R>
|
||
|
|
int spherical_orientation(const Sphere_point<R>& p1,
|
||
|
|
const Sphere_point<R>& p2,
|
||
|
|
const Sphere_point<R>& p3)
|
||
|
|
{ return CGAL::orientation(typename R::Point_3(0,0,0),
|
||
|
|
(typename R::Point_3)p1,
|
||
|
|
(typename R::Point_3)p2,
|
||
|
|
(typename R::Point_3)p3); }
|
||
|
|
|
||
|
|
|
||
|
|
/* |spherical_compare| codes our order of points during the sweep. The
|
||
|
|
south pole is the first point, the north pole is the last point, then
|
||
|
|
we order lexicographically. We cover the special case where both
|
||
|
|
points are part of the equator first. Otherwise we sort according to
|
||
|
|
the angle of the halfcircle through $S$, $N$, and the points with
|
||
|
|
respect to the xy-plane. If both lie on the same halfcircle then the
|
||
|
|
angle with respect to $OS$ decides. The parameter $pos=1$ does
|
||
|
|
everthing in the positive halfsphere. If $pos=-1$ then we rotate the
|
||
|
|
whole scenery around the y-axis by $\pi$. Then the x-axis points left
|
||
|
|
and the z-axis into the equatorial plane. */
|
||
|
|
|
||
|
|
template <class R>
|
||
|
|
bool is_south(const Sphere_point<R>& p, int axis) {
|
||
|
|
if(axis==1)
|
||
|
|
return (p.hz() > 0 &&
|
||
|
|
p.hx() == 0 &&
|
||
|
|
p.hy() == 0);
|
||
|
|
|
||
|
|
return (p.hy() < 0 &&
|
||
|
|
p.hx() == 0 &&
|
||
|
|
p.hz() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class R>
|
||
|
|
bool is_north(const Sphere_point<R>& p, int axis) {
|
||
|
|
if(axis==1)
|
||
|
|
return (p.hz() < 0 &&
|
||
|
|
p.hx() == 0 &&
|
||
|
|
p.hy() == 0);
|
||
|
|
|
||
|
|
return (p.hy() > 0 &&
|
||
|
|
p.hx() == 0 &&
|
||
|
|
p.hz() == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class R>
|
||
|
|
int spherical_compare(const Sphere_point<R>& p1,
|
||
|
|
const Sphere_point<R>& p2,
|
||
|
|
int axis, int pos) {
|
||
|
|
|
||
|
|
Sphere_point<R> pS, pN;
|
||
|
|
CGAL_assertion(axis>=0 && axis<=2);
|
||
|
|
switch(axis) {
|
||
|
|
case 0:
|
||
|
|
pS=Sphere_point<R>(0,-1,0);
|
||
|
|
// pN=Sphere_point<R>(0,1,0);
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
pS=Sphere_point<R>(0,0,1);
|
||
|
|
// pN=Sphere_point<R>(0,0,-1);
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
pS=Sphere_point<R>(0,-1,0);
|
||
|
|
// pN=Sphere_point<R>(0,1,0);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
typename R::Direction_3
|
||
|
|
d1(p1-CGAL::ORIGIN),
|
||
|
|
d2(p2-CGAL::ORIGIN);
|
||
|
|
if (d1 == d2) return 0;
|
||
|
|
if(is_south(p1,axis) || is_north(p2,axis)) return -1;
|
||
|
|
if(is_south(p2,axis) || is_north(p1,axis)) return 1;
|
||
|
|
// if (d1 == dS || d2 == dN) return -1;
|
||
|
|
// if (d1 == dN || d2 == dS) return 1;
|
||
|
|
// now no more special cases
|
||
|
|
if (axis==0 && (p1.hx()==static_cast<typename R::RT>(0) &&
|
||
|
|
p2.hx()==static_cast<typename R::RT>(0))) {
|
||
|
|
int s1 = CGAL_NTS sign(p1.hz());
|
||
|
|
int s2 = CGAL_NTS sign(p2.hz());
|
||
|
|
if ( s1 != s2 ) return pos * -s1;
|
||
|
|
// now s1 == s2
|
||
|
|
return -s1 * CGAL::spherical_orientation(p1,Sphere_point<R>(1,0,0),p2);
|
||
|
|
} else
|
||
|
|
if (axis==1 && (p1.hy()==static_cast<typename R::RT>(0) &&
|
||
|
|
p2.hy()==static_cast<typename R::RT>(0))) {
|
||
|
|
int s1 = CGAL_NTS sign(p1.hx());
|
||
|
|
int s2 = CGAL_NTS sign(p2.hx());
|
||
|
|
if ( s1 != s2 ) return pos * s1;
|
||
|
|
// now s1 == s2
|
||
|
|
return s1 * CGAL::spherical_orientation(p1,Sphere_point<R>(0,1,0),p2);
|
||
|
|
} else
|
||
|
|
if (axis==2 && (p1.hz()==static_cast<typename R::RT>(0) &&
|
||
|
|
p2.hz()==static_cast<typename R::RT>(0))) {
|
||
|
|
int s1 = CGAL_NTS sign(p1.hx());
|
||
|
|
int s2 = CGAL_NTS sign(p2.hx());
|
||
|
|
if ( s1 != s2 ) return pos * s1;
|
||
|
|
// now s1 == s2
|
||
|
|
return s1 * CGAL::spherical_orientation(p1,Sphere_point<R>(0,0,1),p2);
|
||
|
|
}
|
||
|
|
int sor = CGAL::spherical_orientation(pS,p1,p2);
|
||
|
|
if ( sor ) return sor;
|
||
|
|
if(axis==0)
|
||
|
|
return CGAL::spherical_orientation(Sphere_point<R>(0,0,pos),p2,p1);
|
||
|
|
return CGAL::spherical_orientation(Sphere_point<R>(-pos,0,0),p2,p1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* the next two functions partition the segments in a list into a list
|
||
|
|
that carries the segment parts that are only part of a halfspace.
|
||
|
|
Halfcircles are again divided into two equally sized pieces. */
|
||
|
|
|
||
|
|
template <class R, class I>
|
||
|
|
void partition(const Sphere_circle<R>& c, I start, I beyond,
|
||
|
|
std::list< Sphere_segment<R> >& Lpos)
|
||
|
|
{ CGAL_NEF_TRACEN("partition ");
|
||
|
|
Sphere_segment<R> s1,s2,s3;
|
||
|
|
while ( start != beyond ) { CGAL_NEF_TRACEN(" "<<*start);
|
||
|
|
int i = start->intersection(c,s1,s2);
|
||
|
|
if (i>1) Lpos.push_back(s2);
|
||
|
|
if (i>0) Lpos.push_back(s1);
|
||
|
|
++start;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class R, class I>
|
||
|
|
void partition_xy(I start, I beyond,
|
||
|
|
std::list< Sphere_segment<R> >& L, int pos)
|
||
|
|
{
|
||
|
|
Sphere_circle<R> xy_circle(0,0,1), yz_circle(1,0,0);
|
||
|
|
Sphere_point<R> S(0,-1,0),N(0,1,0);
|
||
|
|
Sphere_segment<R> s1,s2;
|
||
|
|
if (pos > 0) partition(xy_circle,start,beyond,L);
|
||
|
|
else partition(xy_circle.opposite(),start,beyond,L);
|
||
|
|
typename std::list< Sphere_segment<R> >::iterator it,itl;
|
||
|
|
CGAL_NEF_TRACEN("partition_xy ");
|
||
|
|
CGAL_forall_iterators(it,L) {
|
||
|
|
CGAL_NEF_TRACEN(" "<<*it);
|
||
|
|
if ( equal_as_sets(it->sphere_circle(),xy_circle) ) {
|
||
|
|
CGAL_NEF_TRACEN(" splitting xy seg "<<*it);
|
||
|
|
int n1 = it->intersection(yz_circle,s1,s2);
|
||
|
|
if (n1 > 1 && !s2.is_degenerate()) L.insert(it,s2);
|
||
|
|
if (n1 > 0 && !s1.is_degenerate()) L.insert(it,s1);
|
||
|
|
int n2 = it->intersection(yz_circle.opposite(),s1,s2);
|
||
|
|
if (n2 > 1 && !s2.is_degenerate()) L.insert(it,s2);
|
||
|
|
if (n2 > 0 && !s1.is_degenerate()) L.insert(it,s1);
|
||
|
|
itl = it; --it; L.erase(itl);
|
||
|
|
// at least one item was appended
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CGAL_forall_iterators(it,L) {
|
||
|
|
if ( it->is_halfcircle() ) {
|
||
|
|
CGAL_NEF_TRACEN(" splitting halfcircle "<<*it);
|
||
|
|
Sphere_segment<R> s1,s2;
|
||
|
|
it->split_halfcircle(s1,s2);
|
||
|
|
*it = s2; L.insert(it,s1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// append 4 xy-equator segments:
|
||
|
|
Sphere_segment<R> sp(S,N,xy_circle);
|
||
|
|
Sphere_segment<R> sm(S,N,xy_circle.opposite());
|
||
|
|
Sphere_segment<R> s[4];
|
||
|
|
sp.split_halfcircle(s[0],s[1]);
|
||
|
|
sm.split_halfcircle(s[2],s[3]);
|
||
|
|
L.insert(L.end(),s,s+4);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* |intersection| calculates the intersection of a halfspace $h$
|
||
|
|
(defined via a great circle $c$) with a sphere segment
|
||
|
|
$s$. Interesting are the boundary cases. If an endpoint is part of
|
||
|
|
$h^0$, but the part of $s$ incident to the endpoint is not part of
|
||
|
|
$h^{0+}$ then we return a trivial segment.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
template <typename R>
|
||
|
|
int Sphere_segment<R>::
|
||
|
|
intersection(const CGAL::Sphere_circle<R>& c, std::vector<Sphere_segment<R> >& s) const {
|
||
|
|
|
||
|
|
CGAL_NEF_TRACEN(" intersection "<<*this<<" "<<c);
|
||
|
|
if ( is_degenerate() ) {
|
||
|
|
CGAL_NEF_TRACEN(" degenerate");
|
||
|
|
s.push_back(*this);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
CGAL::Oriented_side or1 = c.oriented_side(source());
|
||
|
|
CGAL::Oriented_side or2 = c.oriented_side(target());
|
||
|
|
|
||
|
|
CGAL_NEF_TRACEN(" Orientation " << or1 << " " << or2);
|
||
|
|
|
||
|
|
if ( or1 == CGAL::opposite(or2) && or1 != or2 ) {
|
||
|
|
// it is sure that $s$ intersects $h$ in its interior. the
|
||
|
|
// question is which part is in the halfspace $h^+$.
|
||
|
|
CGAL_NEF_TRACEN(" opposite");
|
||
|
|
Sphere_point<R> i1 = CGAL::intersection(ptr()->c_,c);
|
||
|
|
if ( !has_on(i1) )
|
||
|
|
i1 = i1.antipode();
|
||
|
|
s.push_back(Sphere_segment<R>(source(),i1,sphere_circle()));
|
||
|
|
s.push_back(Sphere_segment<R>(i1,target(),sphere_circle()));
|
||
|
|
return 2;
|
||
|
|
}
|
||
|
|
else if ( or1 == CGAL::ON_ORIENTED_BOUNDARY &&
|
||
|
|
or2 == CGAL::ON_ORIENTED_BOUNDARY ) {
|
||
|
|
// if both ends of $s$ are part of $h$ then $s$ is a halfcircle or
|
||
|
|
// $s$ is fully part of $h$. In this case we have to check if the
|
||
|
|
// halfcircle is not part of $h^-$. This can be formulated by an
|
||
|
|
// orientation test of the point $p$ at the tip of the normal of
|
||
|
|
// |s.sphere_circle()| with respect to the plane through the
|
||
|
|
// endpoints of $s$ and the tip of the normal of $h$.
|
||
|
|
CGAL_NEF_TRACEN(" both in plane");
|
||
|
|
s.push_back(*this);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
else if ( or1 != CGAL::ON_NEGATIVE_SIDE &&
|
||
|
|
or2 != CGAL::ON_NEGATIVE_SIDE ) {
|
||
|
|
// this case covers the endpoints of $s$ as part of the closed
|
||
|
|
// oriented halfspace $h^{0+}$. At least one is part of
|
||
|
|
// $h^{+}$. If $s$ is not long then the segment must be fully part
|
||
|
|
// of $h^{0+}$. Otherwise if $s$ is long, then we at both ends
|
||
|
|
// there are subsegments as part of $h^{0+}$ (one might be
|
||
|
|
// degenerate).
|
||
|
|
if ( is_long() ) {
|
||
|
|
Sphere_point<R> i1 = CGAL::intersection(ptr()->c_,c);
|
||
|
|
Sphere_point<R> i2 = i1.antipode();
|
||
|
|
Sphere_segment<R> so(i1,i2,sphere_circle());
|
||
|
|
if ( so.has_on(source()) && so.has_on(target()) )
|
||
|
|
std::swap(i1,i2);
|
||
|
|
// now source(),i1,i2,target() are circularly ordered
|
||
|
|
s.push_back(Sphere_segment(source(),i1,sphere_circle()));
|
||
|
|
s.push_back(Sphere_segment(i1,i2,sphere_circle()));
|
||
|
|
s.push_back(Sphere_segment(i2,target(),sphere_circle()));
|
||
|
|
// CGAL_NEF_TRACEN(" both >= plane, long "<<s1<<s2);
|
||
|
|
return 3;
|
||
|
|
} // now short:
|
||
|
|
CGAL_NEF_TRACEN(" both >= plane, short ");
|
||
|
|
s.push_back(*this);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
else if ( or1 != CGAL::ON_POSITIVE_SIDE &&
|
||
|
|
or2 != CGAL::ON_POSITIVE_SIDE ) {
|
||
|
|
// either both endpoints of $s$ are in $h^-$ or one is in $h^-$
|
||
|
|
// and one on $h^0$.
|
||
|
|
if ( is_long() ) {
|
||
|
|
Sphere_point<R> i1 = CGAL::intersection(ptr()->c_,c);
|
||
|
|
Sphere_point<R> i2 = i1.antipode();
|
||
|
|
Sphere_segment so(i1,i2,sphere_circle());
|
||
|
|
// CGAL_NEF_TRACEN(" both <= plane, long"<<so);
|
||
|
|
if ( so.has_on(source()) && so.has_on(target()) )
|
||
|
|
{ so = so.complement(); }
|
||
|
|
// CGAL_NEF_TRACEN(" both <= plane, long"<<so);
|
||
|
|
s.push_back(Sphere_segment(source(),so.source(),sphere_circle()));
|
||
|
|
s.push_back(so);
|
||
|
|
s.push_back(Sphere_segment(so.target(),target(),sphere_circle()));
|
||
|
|
return 3;
|
||
|
|
} // now short
|
||
|
|
CGAL_NEF_TRACEN(" both <= plane, short");
|
||
|
|
s.push_back(*this);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
CGAL_error_msg("Oops, forgot some case.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|
||
|
|
template <typename R>
|
||
|
|
int Sphere_segment<R>::
|
||
|
|
intersection(const CGAL::Sphere_circle<R>& c,
|
||
|
|
Sphere_segment<R>& s1, Sphere_segment<R>& s2) const
|
||
|
|
{
|
||
|
|
CGAL_NEF_TRACEN(" intersection "<<*this<<" "<<c);
|
||
|
|
if ( is_degenerate() ) { CGAL_NEF_TRACEN(" degenerate");
|
||
|
|
if ( !c.has_on_negative_side(source()) )
|
||
|
|
{ s1 = *this; return 1; }
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
CGAL::Oriented_side or1 = c.oriented_side(source());
|
||
|
|
CGAL::Oriented_side or2 = c.oriented_side(target());
|
||
|
|
if ( or1 == CGAL::opposite(or2) && or1 != or2 ) {
|
||
|
|
// it is sure that $s$ intersects $h$ in its interior. the
|
||
|
|
// question is which part is in the halfspace $h^+$.
|
||
|
|
CGAL_NEF_TRACEN(" opposite");
|
||
|
|
Sphere_point<R> i1 = CGAL::intersection(this->ptr()->c_,c);
|
||
|
|
if ( !has_on(i1) ) i1 = i1.antipode();
|
||
|
|
if ( or1 == CGAL::ON_POSITIVE_SIDE )
|
||
|
|
s1 = Sphere_segment<R>(source(),i1,sphere_circle());
|
||
|
|
else if ( or2 == CGAL::ON_POSITIVE_SIDE )
|
||
|
|
s1 = Sphere_segment<R>(i1,target(),sphere_circle());
|
||
|
|
else CGAL_error_msg("no intersection.");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
else if ( or1 == CGAL::ON_ORIENTED_BOUNDARY &&
|
||
|
|
or2 == CGAL::ON_ORIENTED_BOUNDARY ) {
|
||
|
|
// if both ends of $s$ are part of $h$ then $s$ is a halfcircle or
|
||
|
|
// $s$ is fully part of $h$. In this case we have to check if the
|
||
|
|
// halfcircle is not part of $h^-$. This can be formulated by an
|
||
|
|
// orientation test of the point $p$ at the tip of the normal of
|
||
|
|
// |s.sphere_circle()| with respect to the plane through the
|
||
|
|
// endpoints of $s$ and the tip of the normal of $h$.
|
||
|
|
CGAL_NEF_TRACEN(" both in plane");
|
||
|
|
if ( source() != target().antipode() ) {
|
||
|
|
s1 = *this; return 1;
|
||
|
|
}
|
||
|
|
// now this is a halfcircle
|
||
|
|
bool halfcircle_notin_hminus =
|
||
|
|
(CGAL::orientation(source(),target(),
|
||
|
|
CGAL::ORIGIN + c.orthogonal_vector(),
|
||
|
|
CGAL::ORIGIN + sphere_circle().orthogonal_vector())
|
||
|
|
!= CGAL::POSITIVE);
|
||
|
|
CGAL_NEF_TRACE(" ");CGAL_NEF_TRACEV(halfcircle_notin_hminus);
|
||
|
|
if ( halfcircle_notin_hminus ) { s1 = *this; return 1; }
|
||
|
|
else {
|
||
|
|
s1 = Sphere_segment(source(),source(),sphere_circle());
|
||
|
|
s2 = Sphere_segment(target(),target(),sphere_circle());
|
||
|
|
return 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( or1 != CGAL::ON_NEGATIVE_SIDE &&
|
||
|
|
or2 != CGAL::ON_NEGATIVE_SIDE ) {
|
||
|
|
// this case covers the endpoints of $s$ as part of the closed
|
||
|
|
// oriented halfspace $h^{0+}$. At least one is part of
|
||
|
|
// $h^{+}$. If $s$ is not long then the segment must be fully part
|
||
|
|
// of $h^{0+}$. Otherwise if $s$ is long, then we at both ends
|
||
|
|
// there are subsegments as part of $h^{0+}$ (one might be
|
||
|
|
// degenerate).
|
||
|
|
if ( is_long() ) {
|
||
|
|
Sphere_point<R> i1 = CGAL::intersection(this->ptr()->c_,c);
|
||
|
|
Sphere_point<R> i2 = i1.antipode();
|
||
|
|
Sphere_segment<R> so(i1,i2,sphere_circle());
|
||
|
|
if ( so.has_on(source()) && so.has_on(target()) )
|
||
|
|
std::swap(i1,i2);
|
||
|
|
// now source(),i1,i2,target() are circularly ordered
|
||
|
|
s1 = Sphere_segment(source(),i1,sphere_circle());
|
||
|
|
s2 = Sphere_segment(i2,target(),sphere_circle());
|
||
|
|
CGAL_NEF_TRACEN(" both >= plane, long "<<s1<<s2);
|
||
|
|
return 2;
|
||
|
|
} // now short:
|
||
|
|
CGAL_NEF_TRACEN(" both >= plane, short ");
|
||
|
|
s1=*this; return 1;
|
||
|
|
}
|
||
|
|
else if ( or1 != CGAL::ON_POSITIVE_SIDE &&
|
||
|
|
or2 != CGAL::ON_POSITIVE_SIDE ) {
|
||
|
|
// either both endpoints of $s$ are in $h^-$ or one is in $h^-$
|
||
|
|
// and one on $h^0$.
|
||
|
|
if ( is_long() ) {
|
||
|
|
Sphere_point<R> i1 = CGAL::intersection(this->ptr()->c_,c);
|
||
|
|
Sphere_point<R> i2 = i1.antipode();
|
||
|
|
Sphere_segment<R> so(i1,i2,sphere_circle());
|
||
|
|
CGAL_NEF_TRACEN(" both <= plane, long"<<so);
|
||
|
|
if ( so.has_on(source()) && so.has_on(target()) )
|
||
|
|
{ so = so.complement(); }
|
||
|
|
CGAL_NEF_TRACEN(" both <= plane, long"<<so);
|
||
|
|
s1 = so; return 1;
|
||
|
|
} // now short
|
||
|
|
CGAL_NEF_TRACEN(" both <= plane, short");
|
||
|
|
if ( or1 == CGAL::ON_ORIENTED_BOUNDARY )
|
||
|
|
{ s1 = Sphere_segment<R>(source(),source(),sphere_circle()); return 1; }
|
||
|
|
if ( or2 == CGAL::ON_ORIENTED_BOUNDARY )
|
||
|
|
{ s1 = Sphere_segment<R>(target(),target(),sphere_circle()); return 1; }
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
CGAL_error_msg("Oops, forgot some case.");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
} //namespace CGAL
|
||
|
|
|
||
|
|
#endif //CGAL_SPHERE_PREDICATES_H
|