From 95027822f5323df2c7f7ef5ca6e449b736671599 Mon Sep 17 00:00:00 2001 From: Andreas Fabri Date: Wed, 9 Mar 2016 11:36:06 +0100 Subject: [PATCH] move predicates and constructions in Kernel packages --- .../include/CGAL/Cartesian/function_objects.h | 1 - .../include/CGAL/constructions/kernel_ftC3.h | 516 +++++++++++++++++- .../include/CGAL/predicates/kernel_ftC3.h | 131 +++++ .../Compare_weighted_squared_radius_3.h | 8 +- .../internal/Static_filters/Power_test_3.h | 6 +- .../Homogeneous/Regular_triangulation_rtH3.h | 10 +- .../CGAL/Homogeneous/function_objects.h | 2 +- Kernel_23/include/CGAL/Weighted_point_3.h | 1 - ...redicates_on_weighted_points_cartesian_3.h | 158 +----- ..._weighted_circumcenter_filtered_traits_3.h | 2 +- .../test/Triangulation_3/test_regular_3.cpp | 5 +- 11 files changed, 667 insertions(+), 173 deletions(-) diff --git a/Cartesian_kernel/include/CGAL/Cartesian/function_objects.h b/Cartesian_kernel/include/CGAL/Cartesian/function_objects.h index 99a9322ada2..a9c04aa7594 100644 --- a/Cartesian_kernel/include/CGAL/Cartesian/function_objects.h +++ b/Cartesian_kernel/include/CGAL/Cartesian/function_objects.h @@ -30,7 +30,6 @@ #include #include #include -#include #include namespace CGAL { diff --git a/Cartesian_kernel/include/CGAL/constructions/kernel_ftC3.h b/Cartesian_kernel/include/CGAL/constructions/kernel_ftC3.h index ae9c0c9edfc..3e788c571a9 100644 --- a/Cartesian_kernel/include/CGAL/constructions/kernel_ftC3.h +++ b/Cartesian_kernel/include/CGAL/constructions/kernel_ftC3.h @@ -20,7 +20,7 @@ // $Id$ // // -// Author(s) : Herve Bronnimann +// Author(s) : Herve Bronnimann, Mariette Yvinec #ifndef 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; } + +template +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 +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 +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 #endif // CGAL_CONSTRUCTIONS_KERNEL_FTC3_H diff --git a/Cartesian_kernel/include/CGAL/predicates/kernel_ftC3.h b/Cartesian_kernel/include/CGAL/predicates/kernel_ftC3.h index a67774721a0..00d47400432 100644 --- a/Cartesian_kernel/include/CGAL/predicates/kernel_ftC3.h +++ b/Cartesian_kernel/include/CGAL/predicates/kernel_ftC3.h @@ -555,6 +555,137 @@ has_smaller_signed_dist_to_planeC3( 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 +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 +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 +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 +Oriented_side +power_testC3(const FT &pwt, const FT &qwt) +{ + return CGAL_NTS compare(qwt, pwt); +} + + } //namespace CGAL #endif // CGAL_PREDICATES_KERNEL_FTC3_H diff --git a/Filtered_kernel/include/CGAL/internal/Static_filters/Compare_weighted_squared_radius_3.h b/Filtered_kernel/include/CGAL/internal/Static_filters/Compare_weighted_squared_radius_3.h index 8223733890d..7783edbe180 100644 --- a/Filtered_kernel/include/CGAL/internal/Static_filters/Compare_weighted_squared_radius_3.h +++ b/Filtered_kernel/include/CGAL/internal/Static_filters/Compare_weighted_squared_radius_3.h @@ -1,10 +1,10 @@ // Copyright (c) 2009 INRIA Sophia-Antipolis (France). // 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. +// This file is part of CGAL (www.cgal.org); you can redistribute it and/or +// 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. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. diff --git a/Filtered_kernel/include/CGAL/internal/Static_filters/Power_test_3.h b/Filtered_kernel/include/CGAL/internal/Static_filters/Power_test_3.h index b0f0221ddf7..09748942db0 100644 --- a/Filtered_kernel/include/CGAL/internal/Static_filters/Power_test_3.h +++ b/Filtered_kernel/include/CGAL/internal/Static_filters/Power_test_3.h @@ -6,8 +6,10 @@ // 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 part of CGAL (www.cgal.org); you can redistribute it and/or +// 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 // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. diff --git a/Homogeneous_kernel/include/CGAL/Homogeneous/Regular_triangulation_rtH3.h b/Homogeneous_kernel/include/CGAL/Homogeneous/Regular_triangulation_rtH3.h index c53de8de40d..c18f9912f03 100644 --- a/Homogeneous_kernel/include/CGAL/Homogeneous/Regular_triangulation_rtH3.h +++ b/Homogeneous_kernel/include/CGAL/Homogeneous/Regular_triangulation_rtH3.h @@ -1,10 +1,10 @@ // Copyright (c) 1999 INRIA Sophia-Antipolis (France). // 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. +// This file is part of CGAL (www.cgal.org); you can redistribute it and/or +// 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. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. @@ -24,7 +24,7 @@ // This file contains the low level homogeneous predicates // used by the 3D regular triangulation. -#include +#include namespace CGAL { diff --git a/Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h b/Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h index 0735157ece4..f11a2a8ae4d 100644 --- a/Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h +++ b/Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h @@ -29,7 +29,7 @@ #include #include #include -#include +#include namespace CGAL { diff --git a/Kernel_23/include/CGAL/Weighted_point_3.h b/Kernel_23/include/CGAL/Weighted_point_3.h index 997b134c988..f4edaa4ea3b 100644 --- a/Kernel_23/include/CGAL/Weighted_point_3.h +++ b/Kernel_23/include/CGAL/Weighted_point_3.h @@ -78,7 +78,6 @@ public: Weighted_point_3(const Rep& p) : Rep(p) {} - Weighted_point_3(const Point_3& p) : Rep(typename R::Construct_weighted_point_3()(Return_base_tag(), p, 0)) {} diff --git a/Kernel_23/include/CGAL/predicates/predicates_on_weighted_points_cartesian_3.h b/Kernel_23/include/CGAL/predicates/predicates_on_weighted_points_cartesian_3.h index 9155e1cd1e4..453120013f3 100644 --- a/Kernel_23/include/CGAL/predicates/predicates_on_weighted_points_cartesian_3.h +++ b/Kernel_23/include/CGAL/predicates/predicates_on_weighted_points_cartesian_3.h @@ -1,10 +1,10 @@ // Copyright (c) 1997 INRIA Sophia-Antipolis (France). // 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. +// This file is part of CGAL (www.cgal.org); you can redistribute it and/or +// 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. // // Licensees holding a valid commercial license may use this file in // 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 -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 -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 -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 //------------------------------------------------------------------- diff --git a/Mesh_3/include/CGAL/Mesh_3/Robust_weighted_circumcenter_filtered_traits_3.h b/Mesh_3/include/CGAL/Mesh_3/Robust_weighted_circumcenter_filtered_traits_3.h index b78e754cede..784a5481655 100644 --- a/Mesh_3/include/CGAL/Mesh_3/Robust_weighted_circumcenter_filtered_traits_3.h +++ b/Mesh_3/include/CGAL/Mesh_3/Robust_weighted_circumcenter_filtered_traits_3.h @@ -32,7 +32,7 @@ #include #include #include -#include +#include namespace CGAL { diff --git a/Triangulation_3/test/Triangulation_3/test_regular_3.cpp b/Triangulation_3/test/Triangulation_3/test_regular_3.cpp index 2813f6f1f45..3cf92e10739 100644 --- a/Triangulation_3/test/Triangulation_3/test_regular_3.cpp +++ b/Triangulation_3/test/Triangulation_3/test_regular_3.cpp @@ -33,9 +33,8 @@ bool del=true; typedef CGAL::Exact_predicates_inexact_constructions_kernel FK; -// typedef CGAL::Regular_triangulation_euclidean_traits_3 traits; +typedef CGAL::Regular_triangulation_euclidean_traits_3 traits; -typedef FK traits; // Explicit instantiation of the whole class : template class CGAL::Regular_triangulation_3; @@ -449,7 +448,7 @@ int main() typedef CGAL::Spatial_lock_grid_3< CGAL::Tag_priority_blocking> Lock_ds; typedef CGAL::Triangulation_data_structure_3< - CGAL::Triangulation_vertex_base_3 >, + CGAL::Triangulation_vertex_base_3, CGAL::Regular_triangulation_cell_base_3, CGAL::Parallel_tag > Tds_parallel; typedef CGAL::Regular_triangulation_3<