songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Improved readability of weighted point-related functors (no real changes) 

Fixed indentation, trailing whitespace, english, etc.
This commit is contained in:
Mael Rouxel-Labbé 2017-04-19 11:40:58 +02:00
parent 046058fabe
commit 1223f5f5a0
4 changed files with 544 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cartesian_kernel/include/CGAL/constructions/kernel_ftC2.h
View File

@ -418,7 +418,6 @@ scaled_distance_to_lineC2( const FT &px, const FT &py,
return determinant<FT>(px-rx, py-ry, qx-rx, qy-ry); return determinant<FT>(px-rx, py-ry, qx-rx, qy-ry);
} }
template < class RT > template < class RT >
void void
weighted_circumcenter_translateC2(const RT &dqx, const RT &dqy, const RT &dqw, weighted_circumcenter_translateC2(const RT &dqx, const RT &dqy, const RT &dqw,
@ -461,7 +460,6 @@ weighted_circumcenterC2( const RT &px, const RT &py, const We &pw,
y += py; y += py;
} }
template < class RT , class We> template < class RT , class We>
void void
radical_axisC2(const RT &px, const RT &py, const We &pw, radical_axisC2(const RT &px, const RT &py, const We &pw,
@ -472,7 +470,7 @@ radical_axisC2(const RT &px, const RT &py, const We &pw,
b = RT(2)*(py - qy); b = RT(2)*(py - qy);
c = - CGAL_NTS square(px) - CGAL_NTS square(py) c = - CGAL_NTS square(px) - CGAL_NTS square(py)
+ CGAL_NTS square(qx) + CGAL_NTS square(qy) + CGAL_NTS square(qx) + CGAL_NTS square(qy)
+RT(pw) - RT(qw); + RT(pw) - RT(qw);
} }
template< class FT > template< class FT >

220
Cartesian_kernel/include/CGAL/constructions/kernel_ftC3.h
View File

@ -403,7 +403,6 @@ 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> template <class FT>
void void
determinants_for_weighted_circumcenterC3( determinants_for_weighted_circumcenterC3(
@ -416,19 +415,19 @@ determinants_for_weighted_circumcenterC3(
// translate origin to p // translate origin to p
// and compute determinants for weighted_circumcenter and // and compute determinants for weighted_circumcenter and
// circumradius // circumradius
FT qpx = qx-px; FT qpx = qx - px;
FT qpy = qy-py; FT qpy = qy - py;
FT qpz = qz-pz; FT qpz = qz - pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz) - qw + pw; CGAL_NTS square(qpz) - qw + pw;
FT rpx = rx-px; FT rpx = rx - px;
FT rpy = ry-py; FT rpy = ry - py;
FT rpz = rz-pz; FT rpz = rz - pz;
FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) +
CGAL_NTS square(rpz) - rw + pw; CGAL_NTS square(rpz) - rw + pw;
FT spx = sx-px; FT spx = sx - px;
FT spy = sy-py; FT spy = sy - py;
FT spz = sz-pz; FT spz = sz - pz;
FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) + FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) +
CGAL_NTS square(spz) - sw + pw; CGAL_NTS square(spz) - sw + pw;
@ -448,8 +447,7 @@ determinants_for_weighted_circumcenterC3(
template <class FT> template <class FT>
void void
determinants_for_circumcenterC3( determinants_for_circumcenterC3(const FT &px, const FT &py, const FT &pz,
const FT &px, const FT &py, const FT &pz,
const FT &qx, const FT &qy, const FT &qz, const FT &qx, const FT &qy, const FT &qz,
const FT &rx, const FT &ry, const FT &rz, const FT &rx, const FT &ry, const FT &rz,
const FT &sx, const FT &sy, const FT &sz, const FT &sx, const FT &sy, const FT &sz,
@ -458,19 +456,19 @@ determinants_for_circumcenterC3(
// translate origin to p // translate origin to p
// and compute determinants for weighted_circumcenter and // and compute determinants for weighted_circumcenter and
// circumradius // circumradius
FT qpx = qx-px; FT qpx = qx - px;
FT qpy = qy-py; FT qpy = qy - py;
FT qpz = qz-pz; FT qpz = qz - pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz); CGAL_NTS square(qpz);
FT rpx = rx-px; FT rpx = rx - px;
FT rpy = ry-py; FT rpy = ry - py;
FT rpz = rz-pz; FT rpz = rz - pz;
FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) +
CGAL_NTS square(rpz); CGAL_NTS square(rpz);
FT spx = sx-px; FT spx = sx - px;
FT spy = sy-py; FT spy = sy - py;
FT spz = sz-pz; FT spz = sz - pz;
FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) + FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) +
CGAL_NTS square(spz); CGAL_NTS square(spz);
@ -488,17 +486,15 @@ determinants_for_circumcenterC3(
spx,spy,spz); spx,spy,spz);
} }
template < class FT> template < class FT>
void void
weighted_circumcenterC3( weighted_circumcenterC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw, 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 &sx, const FT &sy, const FT &sz, const FT &sw,
FT &x, FT &y, FT &z) FT &x, FT &y, FT &z)
{ {
// this function compute the weighted circumcenter point only // this function computes the weighted circumcenter point only
// Translate p to origin and compute determinants // Translate p to origin and compute determinants
FT num_x, num_y, num_z, den; FT num_x, num_y, num_z, den;
@ -518,14 +514,13 @@ weighted_circumcenterC3(
template < class FT> template < class FT>
void void
weighted_circumcenterC3( weighted_circumcenterC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw, 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 &sx, const FT &sy, const FT &sz, const FT &sw,
FT &x, FT &y, FT &z, FT &w) FT &x, FT &y, FT &z, FT &w)
{ {
// this function compute the weighted circumcenter point // this function computes the weighted circumcenter point
// and the squared weighted circumradius // and the squared weighted circumradius
// Translate p to origin and compute determinants // Translate p to origin and compute determinants
@ -543,11 +538,10 @@ weighted_circumcenterC3(
y = py - num_y*inv; y = py - num_y*inv;
z = pz + num_z*inv; z = pz + num_z*inv;
w = (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) w = (CGAL_NTS square(num_x) + CGAL_NTS square(num_y) + CGAL_NTS square(num_z))
*CGAL_NTS square(inv) - pw; * CGAL_NTS square(inv) - pw;
} }
template< class FT > template< class FT >
FT FT
squared_radius_orthogonal_sphereC3( squared_radius_orthogonal_sphereC3(
@ -556,8 +550,7 @@ squared_radius_orthogonal_sphereC3(
const FT &rx, const FT &ry, const FT &rz, const FT &rw, 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 &sx, const FT &sy, const FT &sz, const FT &sw)
{ {
// this function computes the squared weighted circumradius only
// this function compute the squared weighted circumradius only
// Translate p to origin and compute determinants // Translate p to origin and compute determinants
FT num_x, num_y, num_z, den; FT num_x, num_y, num_z, den;
@ -570,12 +563,10 @@ squared_radius_orthogonal_sphereC3(
CGAL_assertion( ! CGAL_NTS is_zero(den) ); CGAL_assertion( ! CGAL_NTS is_zero(den) );
FT inv = FT(1)/(FT(2) * den); FT inv = FT(1)/(FT(2) * den);
return return (CGAL_NTS square(num_x) + CGAL_NTS square(num_y) + CGAL_NTS square(num_z))
(CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) * CGAL_NTS square(inv) - pw;
*CGAL_NTS square(inv) - pw;
} }
template <class FT> template <class FT>
void void
determinants_for_weighted_circumcenterC3( determinants_for_weighted_circumcenterC3(
@ -584,37 +575,36 @@ determinants_for_weighted_circumcenterC3(
const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &rx, const FT &ry, const FT &rz, const FT &rw,
FT &num_x, FT &num_y, FT &num_z, FT &den) FT &num_x, FT &num_y, FT &num_z, FT &den)
{ {
// translate origin to p // translate origin to p and compute determinants for weighted_circumcenter
// and compute determinants for weighted_circumcenter and // and circumradius
// circumradius
// Translate s to origin to simplify the expression. // Translate s to origin to simplify the expression.
FT qpx = qx-px; FT qpx = qx - px;
FT qpy = qy-py; FT qpy = qy - py;
FT qpz = qz-pz; FT qpz = qz - pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz) - qw + pw; CGAL_NTS square(qpz) - qw + pw;
FT rpx = rx-px; FT rpx = rx - px;
FT rpy = ry-py; FT rpy = ry - py;
FT rpz = rz-pz; FT rpz = rz - pz;
FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) +
CGAL_NTS square(rpz) - rw + pw; CGAL_NTS square(rpz) - rw + pw;
FT sx = qpy*rpz-qpz*rpy; FT sx = qpy*rpz - qpz*rpy;
FT sy = qpz*rpx-qpx*rpz; FT sy = qpz*rpx - qpx*rpz;
FT sz = qpx*rpy-qpy*rpx; FT sz = qpx*rpy - qpy*rpx;
// The following determinants can be developped and simplified. // The following determinants can be developped and simplified.
// //
// FT num_x = determinant(qpy,qpz,qp2, // FT num_x = determinant(qpy,qpz,qp2,
// rpy,rpz,rp2, // rpy,rpz,rp2,
// sy,sz,FT(0)); // sy,sz,FT(0));
// FT num_y = determinant(qpx,qpz,qp2, // FT num_y = determinant(qpx,qpz,qp2,
// rpx,rpz,rp2, // rpx,rpz,rp2,
// sx,sz,FT(0)); // sx,sz,FT(0));
// FT num_z = determinant(qpx,qpy,qp2, // FT num_z = determinant(qpx,qpy,qp2,
// rpx,rpy,rp2, // rpx,rpy,rp2,
// sx,sy,FT(0)); // sx,sy,FT(0));
num_x = qp2 * determinant(rpy,rpz,sy,sz) num_x = qp2 * determinant(rpy,rpz,sy,sz)
- rp2 * determinant(qpy,qpz,sy,sz); - rp2 * determinant(qpy,qpz,sy,sz);
@ -632,15 +622,14 @@ determinants_for_weighted_circumcenterC3(
template < class FT > template < class FT >
void void
weighted_circumcenterC3( weighted_circumcenterC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &rx, const FT &ry, const FT &rz, const FT &rw,
FT &x, FT &y, FT &z) FT &x, FT &y, FT &z)
{ {
// this function compute the weighted circumcenter point only // this function computes the weighted circumcenter point only
// Translate p to origin and compute determinants // Translate p to origin and compute determinants
FT num_x, num_y, num_z, den; FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw, determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw, qx, qy, qz, qw,
@ -648,26 +637,24 @@ weighted_circumcenterC3(
num_x, num_y, num_z, den); num_x, num_y, num_z, den);
CGAL_assertion( den != FT(0) ); CGAL_assertion( den != FT(0) );
FT inv = FT(1)/(FT(2) * den); FT inv = FT(1) / (FT(2) * den);
x = px + num_x*inv; x = px + num_x*inv;
y = py - num_y*inv; y = py - num_y*inv;
z = pz + num_z*inv; z = pz + num_z*inv;
} }
template < class FT > template < class FT >
void void
weighted_circumcenterC3( weighted_circumcenterC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &rx, const FT &ry, const FT &rz, const FT &rw,
FT &x, FT &y, FT &z, FT &w) FT &x, FT &y, FT &z, FT &w)
{ {
// this function compute the weighted circumcenter and // this function computes the weighted circumcenter and
// the weighted squared circumradius // the weighted squared circumradius
// Translate p to origin and compute determinants // Translate p to origin and compute determinants
FT num_x, num_y, num_z, den; FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw, determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw, qx, qy, qz, qw,
@ -675,17 +662,16 @@ weighted_circumcenterC3(
num_x, num_y, num_z, den); num_x, num_y, num_z, den);
CGAL_assertion( den != FT(0) ); CGAL_assertion( den != FT(0) );
FT inv = FT(1)/(FT(2) * den); FT inv = FT(1) / (FT(2) * den);
x = px + num_x*inv; x = px + num_x*inv;
y = py - num_y*inv; y = py - num_y*inv;
z = pz + num_z*inv; z = pz + num_z*inv;
w = (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) w = (CGAL_NTS square(num_x) + CGAL_NTS square(num_y) + CGAL_NTS square(num_z))
*CGAL_NTS square(inv) - pw; *CGAL_NTS square(inv) - pw;
} }
template< class FT > template< class FT >
CGAL_MEDIUM_INLINE CGAL_MEDIUM_INLINE
FT FT
@ -694,9 +680,9 @@ squared_radius_smallest_orthogonal_sphereC3(
const FT &qx, const FT &qy, const FT &qz, const FT &qw, 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 &rx, const FT &ry, const FT &rz, const FT &rw)
{ {
// this function compute the weighted squared circumradius only // this function computes the weighted squared circumradius only
// Translate p to origin and compute determinants // Translate p to origin and compute determinants
FT num_x, num_y, num_z, den; FT num_x, num_y, num_z, den;
determinants_for_weighted_circumcenterC3(px, py, pz, pw, determinants_for_weighted_circumcenterC3(px, py, pz, pw,
qx, qy, qz, qw, qx, qy, qz, qw,
@ -706,60 +692,53 @@ squared_radius_smallest_orthogonal_sphereC3(
CGAL_assertion( den != FT(0) ); CGAL_assertion( den != FT(0) );
FT inv = FT(1)/(FT(2) * den); FT inv = FT(1)/(FT(2) * den);
return return (CGAL_NTS square(num_x) + CGAL_NTS square(num_y) + CGAL_NTS square(num_z))
(CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) * CGAL_NTS square(inv) - pw;
*CGAL_NTS square(inv) - pw;
} }
template < class FT > template < class FT >
void void
weighted_circumcenterC3( weighted_circumcenterC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
FT &x, FT &y, FT &z) FT &x, FT &y, FT &z)
{ {
// this function compute the weighted circumcenter point only // this function computes the weighted circumcenter point only
FT qpx = qx-px; FT qpx = qx - px;
FT qpy = qy-py; FT qpy = qy - py;
FT qpz = qz-pz; FT qpz = qz - pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz); CGAL_NTS square(qpz);
FT inv = FT(1)/(FT(2)*qp2); FT inv = FT(1) / (FT(2) * qp2);
FT alpha = 1/FT(2) + (pw-qw)*inv; FT alpha = 1 / FT(2) + (pw-qw) * inv;
x = px + alpha * qpx; x = px + alpha * qpx;
y = py + alpha * qpy; y = py + alpha * qpy;
z = pz + alpha * qpz; z = pz + alpha * qpz;
} }
template < class FT > template < class FT >
void void
weighted_circumcenterC3( weighted_circumcenterC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
FT &x, FT &y, FT &z, FT &w) FT &x, FT &y, FT &z, FT &w)
{ {
// this function compute the weighted circumcenter point and // this function computes the weighted circumcenter point and
// the weighted circumradius // the weighted circumradius
FT qpx = qx-px; FT qpx = qx - px;
FT qpy = qy-py; FT qpy = qy - py;
FT qpz = qz-pz; FT qpz = qz - pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz); CGAL_NTS square(qpz);
FT inv = FT(1)/(FT(2)*qp2); FT inv = FT(1) / (FT(2) * qp2);
FT alpha = 1/FT(2) + (pw-qw)*inv; FT alpha = 1 / FT(2) + (pw-qw) * inv;
x = px + alpha * qpx; x = px + alpha * qpx;
y = py + alpha * qpy; y = py + alpha * qpy;
z = pz + alpha * qpz; z = pz + alpha * qpz;
w = CGAL_NTS square(alpha)*qp2 - pw; w = CGAL_NTS square(alpha) * qp2 - pw;
} }
template< class FT > template< class FT >
CGAL_MEDIUM_INLINE CGAL_MEDIUM_INLINE
FT FT
@ -767,30 +746,27 @@ squared_radius_smallest_orthogonal_sphereC3(
const FT &px, const FT &py, const FT &pz, const FT &pw, 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 &qx, const FT &qy, const FT &qz, const FT &qw)
{ {
// this function computes // this function computes the weighted circumradius only
// the weighted circumradius only FT qpx = qx - px;
FT qpx = qx-px; FT qpy = qy - py;
FT qpy = qy-py; FT qpz = qz - pz;
FT qpz = qz-pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz); CGAL_NTS square(qpz);
FT inv = FT(1)/(FT(2)*qp2); FT inv = FT(1) / (FT(2) * qp2);
FT alpha = 1/FT(2) + (pw-qw)*inv; FT alpha = 1 / FT(2) + (pw-qw) * inv;
return CGAL_NTS square(alpha)*qp2 - pw; return CGAL_NTS square(alpha)*qp2 - pw;
} }
template< class FT > template< class FT >
FT FT
power_productC3( power_productC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw)
{ {
// computes the power product of two weighted points // computes the power product of two weighted points
FT qpx = qx-px; FT qpx = qx - px;
FT qpy = qy-py; FT qpy = qy - py;
FT qpz = qz-pz; FT qpz = qz - pz;
FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) +
CGAL_NTS square(qpz); CGAL_NTS square(qpz);
return qp2 - pw - qw ; return qp2 - pw - qw ;
@ -807,9 +783,9 @@ radical_axisC3(const RT &px, const RT &py, const RT &pz, const We & /* pw */,
//il manque des tests... //il manque des tests...
a= RT(1)*determinant(dqy, dqz, dry, drz); a = RT(1)*determinant(dqy, dqz, dry, drz);
b= - RT(1)*determinant(dqx, dqz, drx, drz); b = - RT(1)*determinant(dqx, dqz, drx, drz);
c= RT(1)*determinant(dqx, dqy, drx, dry); c = RT(1)*determinant(dqx, dqy, drx, dry);
} }
// function used in critical_squared_radiusC3 // function used in critical_squared_radiusC3
@ -817,8 +793,7 @@ radical_axisC3(const RT &px, const RT &py, const RT &pz, const We & /* pw */,
// circle orthogonal (p,pw), (q,qw), (r,rw), (s,sw) // circle orthogonal (p,pw), (q,qw), (r,rw), (s,sw)
template < class FT> template < class FT>
FT FT
power_to_orthogonal_sphereC3( power_to_orthogonal_sphereC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw, 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 &sx, const FT &sy, const FT &sz, const FT &sw,
@ -851,17 +826,13 @@ power_to_orthogonal_sphereC3(
dqx, dqy, dqz, dqt, dqx, dqy, dqz, dqt,
drx, dry, drz, drt, drx, dry, drz, drt,
dsx, dsy, dsz, dst); dsx, dsy, dsz, dst);
} }
// compute the critical weight tw // compute the critical weight tw
// where weighted point t is orthogonal to weighted points p, q,r,s // where weighted point t is orthogonal to weighted points p, q,r,s
template < class FT> template < class FT>
FT FT
power_distance_to_power_sphereC3( power_distance_to_power_sphereC3(const FT &px, const FT &py, const FT &pz, const FT &pw,
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 &qx, const FT &qy, const FT &qz, const FT &qw,
const FT &rx, const FT &ry, const FT &rz, const FT &rw, 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 &sx, const FT &sy, const FT &sz, const FT &sw,
@ -870,7 +841,6 @@ power_distance_to_power_sphereC3(
// the 5x5 det is a linear function of tw ff(tw)= ff(0) + tw ff(1) // 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)) // the critical value for tw is - ff(0)/( ff(1) - ff(0))
FT ff0 = power_to_orthogonal_sphereC3(px, py, pz, pw, FT ff0 = power_to_orthogonal_sphereC3(px, py, pz, pw,
qx, qy, qz, qw, qx, qy, qz, qw,
rx, ry, rz, rw, rx, ry, rz, rw,
@ -886,8 +856,6 @@ power_distance_to_power_sphereC3(
return -ff0/(ff1 - ff0); return -ff0/(ff1 - ff0);
} }
// I will use this to test if the radial axis of three spheres // I will use this to test if the radial axis of three spheres
// intersect the triangle formed by the centers. // intersect the triangle formed by the centers.
// // resolution of the system (where we note c the center) // // resolution of the system (where we note c the center)
@ -913,9 +881,7 @@ power_distance_to_power_sphereC3(
// FT Mu = (dqq*dp-dpp*dpdq)/denom; // FT Mu = (dqq*dp-dpp*dpdq)/denom;
// return (CGAL_NTS square(Lambda)*dp+CGAL_NTS square(Mu)*dq // return (CGAL_NTS square(Lambda)*dp+CGAL_NTS square(Mu)*dq
// +FT2*Lambda*Mu*dpdq - rw); // + FT2*Lambda*Mu*dpdq - rw);
} //namespace CGAL } //namespace CGAL

3
Cartesian_kernel/include/CGAL/predicates/kernel_ftC2.h
View File

@ -635,7 +635,6 @@ side_of_oriented_lineC2(const FT &a, const FT &b, const FT &c,
return CGAL_NTS sign(a*x+b*y+c); return CGAL_NTS sign(a*x+b*y+c);
} }
template <class FT> template <class FT>
Comparison_result Comparison_result
compare_power_distanceC2(const FT& px, const FT& py, const FT& pwt, compare_power_distanceC2(const FT& px, const FT& py, const FT& pwt,
@ -648,7 +647,6 @@ compare_power_distanceC2(const FT& px, const FT& py, const FT& pwt,
return CGAL_NTS compare(d1, d2); return CGAL_NTS compare(d1, d2);
} }
template <class FT> template <class FT>
Oriented_side Oriented_side
power_side_of_oriented_power_circleC2( const FT &px, const FT &py, const FT &pwt, power_side_of_oriented_power_circleC2( const FT &px, const FT &py, const FT &pwt,
@ -699,7 +697,6 @@ power_side_of_oriented_power_circleC2( const FT &px, const FT &py, const FT &pwt
return cmpy * sign_of_determinant(dpy, dpz, dqy, dqz); return cmpy * sign_of_determinant(dpy, dpz, dqy, dqz);
} }
} //namespace CGAL } //namespace CGAL
#endif // CGAL_PREDICATES_KERNEL_FTC2_H #endif // CGAL_PREDICATES_KERNEL_FTC2_H

265
Kernel_23/include/CGAL/Kernel/function_objects.h
View File

@ -301,7 +301,6 @@ namespace CommonKernelFunctors {
} }
}; };
template < typename K > template < typename K >
class Compare_power_distance_3 class Compare_power_distance_3
{ {
@ -312,7 +311,7 @@ namespace CommonKernelFunctors {
typedef Comparison_result result_type; typedef Comparison_result result_type;
Comparison_result operator() ( const Point_3 & p, Comparison_result operator()(const Point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r) const const Weighted_point_3 & r) const
{ {
@ -322,19 +321,17 @@ namespace CommonKernelFunctors {
} }
}; };
template < typename K >
class Construct_weighted_circumcenter_3
template < typename K > {
class Construct_weighted_circumcenter_3 public:
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::Point_3 Point_3; typedef typename K::Point_3 Point_3;
typedef typename K::FT FT; typedef typename K::FT FT;
typedef Point_3 result_type; typedef Point_3 result_type;
Point_3 operator() ( const Weighted_point_3 & p, Point_3 operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s) const const Weighted_point_3 & s) const
@ -348,7 +345,7 @@ public:
return Point_3(x,y,z); return Point_3(x,y,z);
} }
Point_3 operator() ( const Weighted_point_3 & p, Point_3 operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r) const const Weighted_point_3 & r) const
{ {
@ -360,7 +357,7 @@ public:
return Point_3(x,y,z); return Point_3(x,y,z);
} }
Point_3 operator() ( const Weighted_point_3 & p, Point_3 operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q) const const Weighted_point_3 & q) const
{ {
FT x, y, z; FT x, y, z;
@ -369,23 +366,21 @@ public:
x,y,z); x,y,z);
return Point_3(x,y,z); return Point_3(x,y,z);
} }
}; };
////////////////////// // operator ()
// return the sign of the power test of last weighted point
// operator () // with respect to the smallest sphere orthogonal to the others
// return the sign of the power test of last weighted point template< typename K >
// with respect to the smallest sphere orthogonal to the others class Power_side_of_bounded_power_sphere_3
template< typename K > {
class Power_side_of_bounded_power_sphere_3 public:
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::Sign Sign; typedef typename K::Sign Sign;
typedef Bounded_side result_type; typedef Bounded_side result_type;
Bounded_side operator() (const Weighted_point_3 & p, Bounded_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s, const Weighted_point_3 & s,
@ -402,7 +397,7 @@ public:
return enum_cast<Bounded_side>(o * os); return enum_cast<Bounded_side>(o * os);
} }
Bounded_side operator() (const Weighted_point_3 & p, Bounded_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s) const const Weighted_point_3 & s) const
@ -414,7 +409,7 @@ public:
s.x(), s.y(), s.z(), s.weight()); s.x(), s.y(), s.z(), s.weight());
} }
Bounded_side operator() (const Weighted_point_3 & p, Bounded_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r) const const Weighted_point_3 & r) const
{ {
@ -424,7 +419,7 @@ public:
r.x(), r.y(), r.z(), r.weight()); r.x(), r.y(), r.z(), r.weight());
} }
Bounded_side operator() (const Weighted_point_3 & p, Bounded_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q) const const Weighted_point_3 & q) const
{ {
return enum_cast<Bounded_side>( return enum_cast<Bounded_side>(
@ -433,19 +428,18 @@ public:
CGAL_NTS square(p.z()-q.z()) + CGAL_NTS square(p.z()-q.z()) +
p.weight() - q.weight())); p.weight() - q.weight()));
} }
};
}; template < typename K >
class Power_side_of_oriented_power_sphere_3
template < typename K > {
class Power_side_of_oriented_power_sphere_3 public:
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::Oriented_side Oriented_side; typedef typename K::Oriented_side Oriented_side;
typedef Oriented_side result_type; typedef Oriented_side result_type;
Oriented_side operator() ( const Weighted_point_3 & p, Oriented_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s, const Weighted_point_3 & s,
@ -458,7 +452,7 @@ public:
t.x(), t.y(), t.z(), t.weight()); t.x(), t.y(), t.z(), t.weight());
} }
Oriented_side operator() ( const Weighted_point_3 & p, Oriented_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s) const const Weighted_point_3 & s) const
@ -469,7 +463,7 @@ public:
s.x(), s.y(), s.z(), s.weight()); s.x(), s.y(), s.z(), s.weight());
} }
Oriented_side operator() ( const Weighted_point_3 & p, Oriented_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r) const const Weighted_point_3 & r) const
{ {
@ -478,17 +472,17 @@ public:
r.x(), r.y(), r.z(), r.weight()); r.x(), r.y(), r.z(), r.weight());
} }
Oriented_side operator() ( const Weighted_point_3 & p, Oriented_side operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q) const const Weighted_point_3 & q) const
{ {
return power_side_of_oriented_power_sphereC3(p.weight(),q.weight()); return power_side_of_oriented_power_sphereC3(p.weight(),q.weight());
} }
}; };
template < typename K > template < typename K >
class Compute_weight_2 class Compute_weight_2
{ {
public: public:
typedef typename K::Weighted_point_2 Weighted_point_2; typedef typename K::Weighted_point_2 Weighted_point_2;
typedef typename K::FT Weight; typedef typename K::FT Weight;
@ -498,14 +492,12 @@ public:
{ {
return p.rep().weight(); return p.rep().weight();
} }
}; };
template < typename K >
class Compute_weight_3
template < typename K > {
class Compute_weight_3 public:
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::FT Weight; typedef typename K::FT Weight;
@ -515,33 +507,29 @@ public:
{ {
return p.rep().weight(); return p.rep().weight();
} }
}; };
template < typename K >
class Compute_power_product_3
{
template < typename K > public:
class Compute_power_product_3
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::FT FT; typedef typename K::FT FT;
typedef FT result_type; typedef FT result_type;
FT operator() (const Weighted_point_3 & p, FT operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q) const const Weighted_point_3 & q) const
{ {
return power_productC3(p.x(), p.y(), p.z(), p.weight(), return power_productC3(p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight()); q.x(), q.y(), q.z(), q.weight());
} }
}; };
template < typename K >
template < typename K > class Compute_squared_radius_smallest_orthogonal_circle_2
class Compute_squared_radius_smallest_orthogonal_circle_2 {
{ public:
public:
typedef typename K::Weighted_point_2 Weighted_point_2; typedef typename K::Weighted_point_2 Weighted_point_2;
typedef typename K::FT FT; typedef typename K::FT FT;
@ -567,67 +555,62 @@ public:
{ {
return - p.weight(); return - p.weight();
} }
}; };
template < typename K > template < typename K >
class Compute_squared_radius_smallest_orthogonal_sphere_3 class Compute_squared_radius_smallest_orthogonal_sphere_3
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::FT FT;
typedef FT result_type;
FT operator() ( const Weighted_point_3 & p,
const Weighted_point_3 & q,
const Weighted_point_3 & r,
const Weighted_point_3 & s) const
{ {
return squared_radius_orthogonal_sphereC3(
p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight(),
r.x(), r.y(), r.z(), r.weight(),
s.x(), s.y(), s.z(), s.weight());
}
FT operator() ( const Weighted_point_3 & p,
const Weighted_point_3 & q,
const Weighted_point_3 & r) const
{
return squared_radius_smallest_orthogonal_sphereC3(
p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight(),
r.x(), r.y(), r.z(), r.weight());
}
FT operator() (const Weighted_point_3 & p,
const Weighted_point_3 & q) const
{
return squared_radius_smallest_orthogonal_sphereC3(
p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight());
}
FT operator() (const Weighted_point_3 & p) const
{
return -p.weight();
}
};
// Compute the square radius of the sphere centered in t
// and orthogonal to the sphere orthogonal to p,q,r,s
template< typename K>
class Compute_power_distance_to_power_sphere_3
{
public: public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::FT FT; typedef typename K::FT FT;
typedef FT result_type; typedef FT result_type;
result_type operator() (const Weighted_point_3 & p, FT operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q,
const Weighted_point_3 & r,
const Weighted_point_3 & s) const
{
return squared_radius_orthogonal_sphereC3(p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight(),
r.x(), r.y(), r.z(), r.weight(),
s.x(), s.y(), s.z(), s.weight());
}
FT operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q,
const Weighted_point_3 & r) const
{
return squared_radius_smallest_orthogonal_sphereC3(p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight(),
r.x(), r.y(), r.z(), r.weight());
}
FT operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q) const
{
return squared_radius_smallest_orthogonal_sphereC3(p.x(), p.y(), p.z(), p.weight(),
q.x(), q.y(), q.z(), q.weight());
}
FT operator()(const Weighted_point_3 & p) const
{
return - p.weight();
}
};
// Compute the square radius of the sphere centered in t
// and orthogonal to the sphere orthogonal to p,q,r,s
template< typename K>
class Compute_power_distance_to_power_sphere_3
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::FT FT;
typedef FT result_type;
result_type operator()(const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s, const Weighted_point_3 & s,
@ -639,78 +622,60 @@ class Compute_power_distance_to_power_sphere_3
s.x(),s.y(),s.z(),FT(s.weight()), s.x(),s.y(),s.z(),FT(s.weight()),
t.x(),t.y(),t.z(),FT(t.weight())); t.x(),t.y(),t.z(),FT(t.weight()));
} }
}; };
template <typename K>
class Compare_weighted_squared_radius_3
{
template <typename K>
class Compare_weighted_squared_radius_3
{
public:
typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Weighted_point_3 Weighted_point_3;
typedef typename K::Comparison_result Comparison_result; typedef typename K::Comparison_result Comparison_result;
typedef typename K::FT FT; typedef typename K::FT FT;
public:
typedef Comparison_result result_type; typedef Comparison_result result_type;
result_type operator()(const Weighted_point_3 & p,
result_type operator() (
const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const Weighted_point_3 & s, const Weighted_point_3 & s,
const FT& w) const const FT& w) const
{ {
return CGAL::compare( return CGAL::compare(squared_radius_orthogonal_sphereC3(
squared_radius_orthogonal_sphereC3(
p.x(),p.y(),p.z(),p.weight(), p.x(),p.y(),p.z(),p.weight(),
q.x(),q.y(),q.z(),q.weight(), q.x(),q.y(),q.z(),q.weight(),
r.x(),r.y(),r.z(),r.weight(), r.x(),r.y(),r.z(),r.weight(),
s.x(),s.y(),s.z(),s.weight() ), s.x(),s.y(),s.z(),s.weight()),
w); w);
} }
result_type operator() ( result_type operator()(const Weighted_point_3 & p,
const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const Weighted_point_3 & r, const Weighted_point_3 & r,
const FT& w) const const FT& w) const
{ {
return CGAL::compare( return CGAL::compare(squared_radius_smallest_orthogonal_sphereC3(
squared_radius_smallest_orthogonal_sphereC3(
p.x(),p.y(),p.z(),p.weight(), p.x(),p.y(),p.z(),p.weight(),
q.x(),q.y(),q.z(),q.weight(), q.x(),q.y(),q.z(),q.weight(),
r.x(),r.y(),r.z(),r.weight() ), r.x(),r.y(),r.z(),r.weight()),
w); w);
} }
result_type operator() ( result_type operator()(const Weighted_point_3 & p,
const Weighted_point_3 & p,
const Weighted_point_3 & q, const Weighted_point_3 & q,
const FT& w) const const FT& w) const
{ {
return CGAL::compare( return CGAL::compare(squared_radius_smallest_orthogonal_sphereC3(
squared_radius_smallest_orthogonal_sphereC3(
p.x(),p.y(),p.z(),p.weight(), p.x(),p.y(),p.z(),p.weight(),
q.x(),q.y(),q.z(),q.weight() ), q.x(),q.y(),q.z(),q.weight()),
w); w);
} }
result_type operator() ( result_type operator()(const Weighted_point_3 & p,
const Weighted_point_3 & p,
const FT& w) const const FT& w) const
{ {
return CGAL::compare(-p.weight(),w); return CGAL::compare(-p.weight(), w);
} }
}; };
//////////////////////
template <typename K> template <typename K>
class Compare_squared_distance_2 class Compare_squared_distance_2