move predicates and constructions in Kernel packages

This commit is contained in:
Andreas Fabri 2016-03-09 11:36:06 +01:00 committed by Jane Tournois
parent ea6e48e1e4
commit 95027822f5
11 changed files with 667 additions and 173 deletions

View File

@ -30,7 +30,6 @@
#include <CGAL/predicates/kernel_ftC3.h> #include <CGAL/predicates/kernel_ftC3.h>
#include <CGAL/constructions/kernel_ftC2.h> #include <CGAL/constructions/kernel_ftC2.h>
#include <CGAL/constructions/kernel_ftC3.h> #include <CGAL/constructions/kernel_ftC3.h>
#include <CGAL/predicates/Regular_triangulation_ftC3.h>
#include <CGAL/Cartesian/solve_3.h> #include <CGAL/Cartesian/solve_3.h>
namespace CGAL { namespace CGAL {

View File

@ -20,7 +20,7 @@
// $Id$ // $Id$
// //
// //
// Author(s) : Herve Bronnimann // Author(s) : Herve Bronnimann, Mariette Yvinec
#ifndef CGAL_CONSTRUCTIONS_KERNEL_FTC3_H #ifndef CGAL_CONSTRUCTIONS_KERNEL_FTC3_H
#define CGAL_CONSTRUCTIONS_KERNEL_FTC3_H #define CGAL_CONSTRUCTIONS_KERNEL_FTC3_H
@ -403,6 +403,520 @@ squared_areaC3(const FT &px, const FT &py, const FT &pz,
return (CGAL_NTS square(vx) + CGAL_NTS square(vy) + CGAL_NTS square(vz))/4; return (CGAL_NTS square(vx) + CGAL_NTS square(vy) + CGAL_NTS square(vz))/4;
} }
template <class FT>
void
determinants_for_weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw,
FT &num_x, FT &num_y, FT &num_z, FT& den)
{
// translate origin to p
// and compute determinants for weighted_circumcenter and
// circumradius
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz) - qw + pw;
FT rpx = rx-px;
FT rpy = ry-py;
FT rpz = rz-pz;
FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) +
CGAL_NTS square(rpz) - rw + pw;
FT spx = sx-px;
FT spy = sy-py;
FT spz = sz-pz;
FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) +
CGAL_NTS square(spz) - sw + pw;
num_x = determinant(qpy,qpz,qp2,
rpy,rpz,rp2,
spy,spz,sp2);
num_y = determinant(qpx,qpz,qp2,
rpx,rpz,rp2,
spx,spz,sp2);
num_z = determinant(qpx,qpy,qp2,
rpx,rpy,rp2,
spx,spy,sp2);
den = determinant(qpx,qpy,qpz,
rpx,rpy,rpz,
spx,spy,spz);
}
template <class FT>
void
determinants_for_circumcenterC3(
const FT &px, const FT &py, const FT &pz,
const FT &qx, const FT &qy, const FT &qz,
const FT &rx, const FT &ry, const FT &rz,
const FT &sx, const FT &sy, const FT &sz,
FT &num_x, FT &num_y, FT &num_z, FT& den)
{
// translate origin to p
// and compute determinants for weighted_circumcenter and
// circumradius
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz);
FT rpx = rx-px;
FT rpy = ry-py;
FT rpz = rz-pz;
FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) +
CGAL_NTS square(rpz);
FT spx = sx-px;
FT spy = sy-py;
FT spz = sz-pz;
FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) +
CGAL_NTS square(spz);
num_x = determinant(qpy,qpz,qp2,
rpy,rpz,rp2,
spy,spz,sp2);
num_y = determinant(qpx,qpz,qp2,
rpx,rpz,rp2,
spx,spz,sp2);
num_z = determinant(qpx,qpy,qp2,
rpx,rpy,rp2,
spx,spy,sp2);
den = determinant(qpx,qpy,qpz,
rpx,rpy,rpz,
spx,spy,spz);
}
template < class FT>
void
weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw,
FT &x, FT &y, FT &z)
{
// this function compute the weighted circumcenter point only
// Translate p to origin and compute determinants
FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
sx, sy, sz, sw,
num_x, num_y, num_z,den);
CGAL_assertion( ! CGAL_NTS is_zero(den) );
FT inv = FT(1)/(FT(2) * den);
x = px + num_x*inv;
y = py - num_y*inv;
z = pz + num_z*inv;
}
template < class FT>
void
weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw,
FT &x, FT &y, FT &z, FT &w)
{
// this function compute the weighted circumcenter point
// and the squared weighted circumradius
// Translate p to origin and compute determinants
FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
sx, sy, sz, sw,
num_x, num_y, num_z, den);
CGAL_assertion( ! CGAL_NTS is_zero(den) );
FT inv = FT(1)/(FT(2) * den);
x = px + num_x*inv;
y = py - num_y*inv;
z = pz + num_z*inv;
w = (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z))
*CGAL_NTS square(inv) - pw;
}
template< class FT >
FT
squared_radius_orthogonal_sphereC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw)
{
// this function compute the squared weighted circumradius only
// Translate p to origin and compute determinants
FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
sx, sy, sz, sw,
num_x, num_y, num_z,den);
CGAL_assertion( ! CGAL_NTS is_zero(den) );
FT inv = FT(1)/(FT(2) * den);
return
(CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z))
*CGAL_NTS square(inv) - pw;
}
template <class FT>
void
determinants_for_weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
FT &num_x, FT &num_y, FT &num_z, FT &den)
{
// translate origin to p
// and compute determinants for weighted_circumcenter and
// circumradius
// Translate s to origin to simplify the expression.
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz) - qw + pw;
FT rpx = rx-px;
FT rpy = ry-py;
FT rpz = rz-pz;
FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) +
CGAL_NTS square(rpz) - rw + pw;
FT sx = qpy*rpz-qpz*rpy;
FT sy = qpz*rpx-qpx*rpz;
FT sz = qpx*rpy-qpy*rpx;
// The following determinants can be developped and simplified.
//
// FT num_x = determinant(qpy,qpz,qp2,
// rpy,rpz,rp2,
// sy,sz,FT(0));
// FT num_y = determinant(qpx,qpz,qp2,
// rpx,rpz,rp2,
// sx,sz,FT(0));
// FT num_z = determinant(qpx,qpy,qp2,
// rpx,rpy,rp2,
// sx,sy,FT(0));
num_x = qp2 * determinant(rpy,rpz,sy,sz)
- rp2 * determinant(qpy,qpz,sy,sz);
num_y = qp2 * determinant(rpx,rpz,sx,sz)
- rp2 * determinant(qpx,qpz,sx,sz);
num_z = qp2 * determinant(rpx,rpy,sx,sy)
- rp2 * determinant(qpx,qpy,sx,sy);
den = determinant(qpx,qpy,qpz,
rpx,rpy,rpz,
sx,sy,sz);
}
template < class FT >
void
weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
FT &x, FT &y, FT &z)
{
// this function compute the weighted circumcenter point only
// Translate p to origin and compute determinants
FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
num_x, num_y, num_z, den);
CGAL_assertion( den != FT(0) );
FT inv = FT(1)/(FT(2) * den);
x = px + num_x*inv;
y = py - num_y*inv;
z = pz + num_z*inv;
}
template < class FT >
void
weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
FT &x, FT &y, FT &z, FT &w)
{
// this function compute the weighted circumcenter and
// the weighted squared circumradius
// Translate p to origin and compute determinants
FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
num_x, num_y, num_z, den);
CGAL_assertion( den != FT(0) );
FT inv = FT(1)/(FT(2) * den);
x = px + num_x*inv;
y = py - num_y*inv;
z = pz + num_z*inv;
w = (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z))
*CGAL_NTS square(inv) - pw;
}
template< class FT >
CGAL_MEDIUM_INLINE
FT
squared_radius_smallest_orthogonal_sphereC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw)
{
// this function compute the weighted squared circumradius only
// Translate p to origin and compute determinants
FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
num_x, num_y, num_z, den);
CGAL_assertion( den != FT(0) );
FT inv = FT(1)/(FT(2) * den);
return
(CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z))
*CGAL_NTS square(inv) - pw;
}
template < class FT >
void
weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
FT &x, FT &y, FT &z)
{
// this function compute the weighted circumcenter point only
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz);
FT inv = FT(1)/(FT(2)*qp2);
FT alpha = 1/FT(2) + (pw-qw)*inv;
x = px + alpha * qpx;
y = py + alpha * qpy;
z = pz + alpha * qpz;
}
template < class FT >
void
weighted_circumcenterC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
FT &x, FT &y, FT &z, FT &w)
{
// this function compute the weighted circumcenter point and
// the weighted circumradius
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz);
FT inv = FT(1)/(FT(2)*qp2);
FT alpha = 1/FT(2) + (pw-qw)*inv;
x = px + alpha * qpx;
y = py + alpha * qpy;
z = pz + alpha * qpz;
w = CGAL_NTS square(alpha)*qp2 - pw;
}
template< class FT >
CGAL_MEDIUM_INLINE
FT
squared_radius_smallest_orthogonal_sphereC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw)
{
// this function computes
// the weighted circumradius only
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz);
FT inv = FT(1)/(FT(2)*qp2);
FT alpha = 1/FT(2) + (pw-qw)*inv;
return CGAL_NTS square(alpha)*qp2 - pw;
}
template< class FT >
FT
power_productC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw)
{
// computes the power product of two weighted points
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz);
return qp2 - pw - qw ;
}
template < class RT , class We>
void
radical_axisC3(const RT &px, const RT &py, const RT &pz, const We & /* pw */,
const RT &qx, const RT &qy, const RT &qz, const We & /* qw */,
const RT &rx, const RT &ry, const RT &rz, const We & /* rw */,
RT &a, RT &b, RT& c )
{
RT dqx=qx-px, dqy=qy-py, dqz=qz-pz, drx=rx-px, dry=ry-py, drz=rz-pz;
//il manque des tests...
a= RT(1)*determinant(dqy, dqz, dry, drz);
b= - RT(1)*determinant(dqx, dqz, drx, drz);
c= RT(1)*determinant(dqx, dqy, drx, dry);
}
// function used in critical_squared_radiusC3
// power ( t, tw) with respect to
// circle orthogonal (p,pw), (q,qw), (r,rw), (s,sw)
template < class FT>
FT
power_to_orthogonal_sphereC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw,
const FT &tx, const FT &ty, const FT &tz, const FT &tw)
{
//to get the value of the determinant
// We translate the points so that t becomes the origin.
FT dpx = px - tx;
FT dpy = py - ty;
FT dpz = pz - tz;
FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) +
CGAL_NTS square(dpz) - pw + tw ;
FT dqx = qx - tx;
FT dqy = qy - ty;
FT dqz = qz - tz;
FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) +
CGAL_NTS square(dqz) - qw + tw;
FT drx = rx - tx;
FT dry = ry - ty;
FT drz = rz - tz;
FT drt = CGAL_NTS square(drx) + CGAL_NTS square(dry) +
CGAL_NTS square(drz) - rw + tw;
FT dsx = sx - tx;
FT dsy = sy - ty;
FT dsz = sz - tz;
FT dst = CGAL_NTS square(dsx) + CGAL_NTS square(dsy) +
CGAL_NTS square(dsz) - sw + tw;
return determinant(dpx, dpy, dpz, dpt,
dqx, dqy, dqz, dqt,
drx, dry, drz, drt,
dsx, dsy, dsz, dst);
}
// compute the critical weight tw
// where weighted point t is orthogonal to weighted points p, q,r,s
template < class FT>
FT
critical_squared_radiusC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw,
const FT &tx, const FT &ty, const FT &tz, const FT & )
{
// the 5x5 det is a linear function of tw ff(tw)= ff(0) + tw ff(1)
// the critical value for tw is - ff(0)/( ff(1) - ff(0))
FT ff0 = power_to_orthogonal_sphereC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
sx, sy, sz, sw,
tx, ty, tz, FT(0));
FT ff1 = power_to_orthogonal_sphereC3(px, py, pz, pw,
qx, qy, qz, qw,
rx, ry, rz, rw,
sx, sy, sz, sw,
tx, ty, tz, FT(1));
return -ff0/(ff1 - ff0);
}
// I will use this to test if the radial axis of three spheres
// intersect the triangle formed by the centers.
// // resolution of the system (where we note c the center)
// // | dc^2 = cw + rw
// // | (dp-dc)^2 = pw + cw
// // | (dq-dc)^2 = qw + cw
// // | dc = Lamdba*dp + Mu*dq
// FT FT2(2);
// FT dpx = px-rx;
// FT dpy = py-ry;
// FT dpz = pz-rz;
// FT dp = CGAL_NTS square(dpx)+CGAL_NTS square(dpy)+CGAL_NTS square(dpz);
// FT dpp = dp-pw+rw;
// FT dqx = qx-rx;
// FT dqy = qy-ry;
// FT dqz = qz-rz;
// FT dq = CGAL_NTS square(dqx)+CGAL_NTS square(dqy)+CGAL_NTS square(dqz);
// FT dqq = dq-qw+rw;
// FT dpdq = dpx*dqx+dpy*dqy+dpz*dqz;
// FT denom = FT2*(dp*dq-CGAL_NTS square(dpdq));
// FT Lambda = (dpp*dq-dqq*dpdq)/denom;
// FT Mu = (dqq*dp-dpp*dpdq)/denom;
// return (CGAL_NTS square(Lambda)*dp+CGAL_NTS square(Mu)*dq
// +FT2*Lambda*Mu*dpdq - rw);
} //namespace CGAL } //namespace CGAL
#endif // CGAL_CONSTRUCTIONS_KERNEL_FTC3_H #endif // CGAL_CONSTRUCTIONS_KERNEL_FTC3_H

View File

@ -555,6 +555,137 @@ has_smaller_signed_dist_to_planeC3(
prx, pry, prz, px, py, pz, qx, qy, qz) == SMALLER; prx, pry, prz, px, py, pz, qx, qy, qz) == SMALLER;
} }
// return minus the sign of the 5x5 determinant [P,Q,R,S,T]
// where column [P] = transpose[px,py,pz,p^2 -wp,1]
template <class FT>
Oriented_side
power_testC3( const FT &px, const FT &py, const FT &pz, const FT &pwt,
const FT &qx, const FT &qy, const FT &qz, const FT &qwt,
const FT &rx, const FT &ry, const FT &rz, const FT &rwt,
const FT &sx, const FT &sy, const FT &sz, const FT &swt,
const FT &tx, const FT &ty, const FT &tz, const FT &twt)
{
// We translate the points so that T becomes the origin.
FT dpx = px - tx;
FT dpy = py - ty;
FT dpz = pz - tz;
FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) +
CGAL_NTS square(dpz) + (twt - pwt);
FT dqx = qx - tx;
FT dqy = qy - ty;
FT dqz = qz - tz;
FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) +
CGAL_NTS square(dqz) + (twt - qwt);
FT drx = rx - tx;
FT dry = ry - ty;
FT drz = rz - tz;
FT drt = CGAL_NTS square(drx) + CGAL_NTS square(dry) +
CGAL_NTS square(drz) + (twt - rwt);
FT dsx = sx - tx;
FT dsy = sy - ty;
FT dsz = sz - tz;
FT dst = CGAL_NTS square(dsx) + CGAL_NTS square(dsy) +
CGAL_NTS square(dsz) + (twt - swt);
return - sign_of_determinant(dpx, dpy, dpz, dpt,
dqx, dqy, dqz, dqt,
drx, dry, drz, drt,
dsx, dsy, dsz, dst);
}
template <class FT>
Oriented_side
power_testC3( const FT &px, const FT &py, const FT &pz, const FT &pwt,
const FT &qx, const FT &qy, const FT &qz, const FT &qwt,
const FT &rx, const FT &ry, const FT &rz, const FT &rwt,
const FT &tx, const FT &ty, const FT &tz, const FT &twt)
{
// Same translation as above.
FT dpx = px - tx;
FT dpy = py - ty;
FT dpz = pz - tz;
FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) +
CGAL_NTS square(dpz) + (twt - pwt);
FT dqx = qx - tx;
FT dqy = qy - ty;
FT dqz = qz - tz;
FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) +
CGAL_NTS square(dqz) + (twt - qwt);
FT drx = rx - tx;
FT dry = ry - ty;
FT drz = rz - tz;
FT drt = CGAL_NTS square(drx) + CGAL_NTS square(dry) +
CGAL_NTS square(drz) + (twt - rwt);
Sign cmp;
// Projection on the (xy) plane.
cmp = sign_of_determinant(dpx, dpy, dpt,
dqx, dqy, dqt,
drx, dry, drt);
if (cmp != ZERO)
return cmp * sign_of_determinant(px-rx, py-ry,
qx-rx, qy-ry);
// Projection on the (xz) plane.
cmp = sign_of_determinant(dpx, dpz, dpt,
dqx, dqz, dqt,
drx, drz, drt);
if (cmp != ZERO)
return cmp * sign_of_determinant(px-rx, pz-rz,
qx-rx, qz-rz);
// Projection on the (yz) plane.
cmp = sign_of_determinant(dpy, dpz, dpt,
dqy, dqz, dqt,
dry, drz, drt);
return cmp * sign_of_determinant(py-ry, pz-rz,
qy-ry, qz-rz);
}
template <class FT>
Oriented_side
power_testC3( const FT &px, const FT &py, const FT &pz, const FT &pwt,
const FT &qx, const FT &qy, const FT &qz, const FT &qwt,
const FT &tx, const FT &ty, const FT &tz, const FT &twt)
{
// Same translation as above.
FT dpx = px - tx;
FT dpy = py - ty;
FT dpz = pz - tz;
FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) +
CGAL_NTS square(dpz) + (twt - pwt);
FT dqx = qx - tx;
FT dqy = qy - ty;
FT dqz = qz - tz;
FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) +
CGAL_NTS square (dqz) + (twt - qwt);
Comparison_result cmp;
// We do an orthogonal projection on the (x) axis, if possible.
cmp = CGAL_NTS compare(px, qx);
if (cmp != EQUAL)
return cmp * sign_of_determinant(dpx, dpt, dqx, dqt);
// We do an orthogonal projection on the (y) axis, if possible.
cmp = CGAL_NTS compare(py, qy);
if (cmp != EQUAL)
return cmp * sign_of_determinant(dpy, dpt, dqy, dqt);
// We do an orthogonal projection on the (z) axis.
cmp = CGAL_NTS compare(pz, qz);
return cmp * sign_of_determinant(dpz, dpt, dqz, dqt);
}
template <class FT>
Oriented_side
power_testC3(const FT &pwt, const FT &qwt)
{
return CGAL_NTS compare(qwt, pwt);
}
} //namespace CGAL } //namespace CGAL
#endif // CGAL_PREDICATES_KERNEL_FTC3_H #endif // CGAL_PREDICATES_KERNEL_FTC3_H

View File

@ -1,10 +1,10 @@
// Copyright (c) 2009 INRIA Sophia-Antipolis (France). // Copyright (c) 2009 INRIA Sophia-Antipolis (France).
// All rights reserved. // All rights reserved.
// //
// This file is part of CGAL (www.cgal.org). // This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// You can redistribute it and/or modify it under the terms of the GNU // modify it under the terms of the GNU Lesser General Public License as
// General Public License as published by the Free Software Foundation, // published by the Free Software Foundation; either version 3 of the License,
// either version 3 of the License, or (at your option) any later version. // or (at your option) any later version.
// //
// Licensees holding a valid commercial license may use this file in // Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software. // accordance with the commercial license agreement provided with the software.

View File

@ -6,8 +6,10 @@
// General Public License as published by the Free Software Foundation, // General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version. // either version 3 of the License, or (at your option) any later version.
// //
// Licensees holding a valid commercial license may use this file in // This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// accordance with the commercial license agreement provided with the software. // modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of the License,
// or (at your option) any later version.
// //
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

View File

@ -1,10 +1,10 @@
// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // Copyright (c) 1999 INRIA Sophia-Antipolis (France).
// All rights reserved. // All rights reserved.
// //
// This file is part of CGAL (www.cgal.org). // This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// You can redistribute it and/or modify it under the terms of the GNU // modify it under the terms of the GNU Lesser General Public License as
// General Public License as published by the Free Software Foundation, // published by the Free Software Foundation; either version 3 of the License,
// either version 3 of the License, or (at your option) any later version. // or (at your option) any later version.
// //
// Licensees holding a valid commercial license may use this file in // Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software. // accordance with the commercial license agreement provided with the software.
@ -24,7 +24,7 @@
// This file contains the low level homogeneous predicates // This file contains the low level homogeneous predicates
// used by the 3D regular triangulation. // used by the 3D regular triangulation.
#include <CGAL/predicates/Regular_triangulation_ftC3.h> #include <CGAL/predicates/kernel_ftC3.h>
namespace CGAL { namespace CGAL {

View File

@ -29,7 +29,7 @@
#include <CGAL/Cartesian/function_objects.h> #include <CGAL/Cartesian/function_objects.h>
#include <CGAL/Kernel/Return_base_tag.h> #include <CGAL/Kernel/Return_base_tag.h>
#include <CGAL/predicates/sign_of_determinant.h> #include <CGAL/predicates/sign_of_determinant.h>
#include <CGAL/predicates/Regular_triangulation_rtH3.h> #include <CGAL/Homogeneous/Regular_triangulation_rtH3.h>
namespace CGAL { namespace CGAL {

View File

@ -78,7 +78,6 @@ public:
Weighted_point_3(const Rep& p) Weighted_point_3(const Rep& p)
: Rep(p) {} : Rep(p) {}
Weighted_point_3(const Point_3& p) Weighted_point_3(const Point_3& p)
: Rep(typename R::Construct_weighted_point_3()(Return_base_tag(), p, 0)) : Rep(typename R::Construct_weighted_point_3()(Return_base_tag(), p, 0))
{} {}

View File

@ -1,10 +1,10 @@
// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // Copyright (c) 1997 INRIA Sophia-Antipolis (France).
// All rights reserved. // All rights reserved.
// //
// This file is part of CGAL (www.cgal.org). // This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// You can redistribute it and/or modify it under the terms of the GNU // modify it under the terms of the GNU Lesser General Public License as
// General Public License as published by the Free Software Foundation, // published by the Free Software Foundation; either version 3 of the License,
// either version 3 of the License, or (at your option) any later version. // or (at your option) any later version.
// //
// Licensees holding a valid commercial license may use this file in // Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software. // accordance with the commercial license agreement provided with the software.
@ -127,156 +127,6 @@ in_smallest_orthogonal_sphereC3(
// return ON_UNBOUNDED_SIDE, ON_BOUNDARY or ON_BOUNDED_SIDE according
// to the position of the weighted circumcenter of pqrs
// with respect with the tertraedron formed by bare points in p, q,r,s
template <class FT>
Bounded_side
does_simplex_intersect_weighted_dual_supportC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw,
const FT &sx, const FT &sy, const FT &sz, const FT &sw)
{
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT rpx = rx-px;
FT rpy = ry-py;
FT rpz = rz-pz;
FT spx = sx-px;
FT spy = sy-py;
FT spz = sz-pz;
FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz);
FT rr = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz);
FT ss = CGAL_NTS square(spx) + CGAL_NTS square(spy) + CGAL_NTS square(spz);
FT qr = qpx*rpx + qpy*rpy + qpz*rpz;
FT rs = rpx*spx + rpy*spy + rpz*spz;
FT qs = spx*qpx + spy*qpy + spz*qpz;
FT qpw = qq - qw + pw ;
FT rpw = rr - rw + pw ;
FT spw = ss - sw + pw ;
FT den = determinant(qq,qr,qs,
qr,rr,rs,
qs,rs,ss);
FT detq = determinant(qpw,qr,qs,
rpw,rr,rs,
spw,rs,ss);
FT detr = determinant(qq,qpw,qs,
qr,rpw,rs,
qs,spw,ss);
FT dets = determinant(qq,qr,qpw,
qr,rr,rpw,
qs,rs,spw);
CGAL_assertion( ! CGAL_NTS is_zero(den) );
// The barycentrique coordinate of the smallest orthogonal sphere center
// are detq/2*den detr/2*den dets/2*den
// and 1-(detq+ detr+dets)/2*den
CGAL::Sign sign1 = CGAL_NTS sign(FT(2)*den - detq -detr -dets);
if (
(CGAL_NTS sign(detq) == CGAL_NTS sign(den) || CGAL_NTS sign(detq)== ZERO) &&
(CGAL_NTS sign(detr) == CGAL_NTS sign(den) || CGAL_NTS sign(detr)== ZERO) &&
(CGAL_NTS sign(dets) == CGAL_NTS sign(den) || CGAL_NTS sign(dets)== ZERO) &&
( sign1 == POSITIVE || sign1 == ZERO )) { // inside or on boundary
if (CGAL_NTS sign(detq) != ZERO &&
CGAL_NTS sign(detr) != ZERO &&
CGAL_NTS sign(dets) != ZERO &&
sign1 != ZERO)
return ON_BOUNDED_SIDE;
else return ON_BOUNDARY ;
}
return ON_UNBOUNDED_SIDE;
}
// return ON_UNBOUNDED_SIDE, ON_BOUNDARY or ON_BOUNDED_SIDE according
// to the position of the intersection if the radialaxis
// of weighted circumcenter of pqr with affine hull of bare p,q,r
// with respect with the triangle formed by bare points in p, q,r.
template <class FT>
Bounded_side
does_simplex_intersect_weighted_dual_supportC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw)
{
// returns true if weighted circumcenter of pqr is in
// triangle pqr or on boundary
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT rpx = rx-px;
FT rpy = ry-py;
FT rpz = rz-pz;
FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz);
FT rr = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz);
FT qr = qpx*rpx + qpy*rpy + qpz*rpz;
FT qpw = qq - qw + pw ;
FT rpw = rr - rw + pw ;
FT den = determinant(qq,qr,
qr,rr);
FT detq = determinant(qpw,qr,
rpw,rr);
FT detr = determinant(qq,qpw,
qr,rpw);
CGAL_assertion( ! CGAL_NTS is_zero(den) );
// The barycentrique coordinate of the smallest orthogonal sphere center
// are detq/2*den detr/2*den
// and 1-(detq+ detr)/2*den
CGAL::Sign sign1 = CGAL_NTS sign(FT(2)*den - detq - detr);
if (
(CGAL_NTS sign(detq) == CGAL_NTS sign(den) || CGAL_NTS sign(detq)== ZERO) &&
(CGAL_NTS sign(detr) == CGAL_NTS sign(den) || CGAL_NTS sign(detr)== ZERO) &&
( sign1 == POSITIVE || sign1 == ZERO )) { // inside or on boundary
if ( CGAL_NTS sign(detq) != ZERO &&
CGAL_NTS sign(detr) != ZERO &&
sign1 != ZERO)
return ON_BOUNDED_SIDE;
else return ON_BOUNDARY;
}
return ON_UNBOUNDED_SIDE;
}
template <class FT>
Bounded_side
does_simplex_intersect_weighted_dual_supportC3(
const FT &px, const FT &py, const FT &pz, const FT &pw,
const FT &qx, const FT &qy, const FT &qz, const FT &qw)
{
// returns true if weighted circumcenter of pq is in
// segment pq or on boundary
FT qpx = qx-px;
FT qpy = qy-py;
FT qpz = qz-pz;
FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz);
FT dw = pw - qw;
CGAL::Sign sign1 = CGAL_NTS sign( qq + dw);
CGAL::Sign sign2 = CGAL_NTS sign( qq - dw);
if( ( sign1 == POSITIVE || sign1 == ZERO ) &&
( sign2 == POSITIVE || sign2 == ZERO )) { // inside or on boundary
if (sign1 != ZERO && sign2 != ZERO) return ON_BOUNDED_SIDE;
else return ON_BOUNDARY;
}
return ON_UNBOUNDED_SIDE;
}
//------------------------------------------------------------------- //-------------------------------------------------------------------
} //namespace CGAL } //namespace CGAL
//------------------------------------------------------------------- //-------------------------------------------------------------------

View File

@ -32,7 +32,7 @@
#include <CGAL/Robust_construction.h> #include <CGAL/Robust_construction.h>
#include <CGAL/Exact_predicates_exact_constructions_kernel.h> #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Regular_triangulation_euclidean_traits_3.h> #include <CGAL/Regular_triangulation_euclidean_traits_3.h>
#include <CGAL/constructions/constructions_on_weighted_points_cartesian_3.h> #include <CGAL/constructions/kernel_ftC3.h>
namespace CGAL { namespace CGAL {

View File

@ -33,9 +33,8 @@
bool del=true; bool del=true;
typedef CGAL::Exact_predicates_inexact_constructions_kernel FK; typedef CGAL::Exact_predicates_inexact_constructions_kernel FK;
// typedef CGAL::Regular_triangulation_euclidean_traits_3<FK> traits; typedef CGAL::Regular_triangulation_euclidean_traits_3<FK> traits;
typedef FK traits;
// Explicit instantiation of the whole class : // Explicit instantiation of the whole class :
template class CGAL::Regular_triangulation_3<traits>; template class CGAL::Regular_triangulation_3<traits>;
@ -449,7 +448,7 @@ int main()
typedef CGAL::Spatial_lock_grid_3< typedef CGAL::Spatial_lock_grid_3<
CGAL::Tag_priority_blocking> Lock_ds; CGAL::Tag_priority_blocking> Lock_ds;
typedef CGAL::Triangulation_data_structure_3< typedef CGAL::Triangulation_data_structure_3<
CGAL::Triangulation_vertex_base_3<CGAL::Weighted_point_triangulation_traits_3<traits> >, CGAL::Triangulation_vertex_base_3<traits>,
CGAL::Regular_triangulation_cell_base_3<traits>, CGAL::Regular_triangulation_cell_base_3<traits>,
CGAL::Parallel_tag > Tds_parallel; CGAL::Parallel_tag > Tds_parallel;
typedef CGAL::Regular_triangulation_3< typedef CGAL::Regular_triangulation_3<