CGAL users discussion list

[Cynthia <>]

I have found the right codes of threetuple.h through the internet, but there
are errors in some other files such as function_objects_3.h.

The original code:
// Copyright (c) 2006  Utrecht University (The Netherlands).
// All rights reserved.
//
// This file is a part of the Conformal Geometric Algebra Packge for CGAL; 
// you may redistribute it under the terms of the Q Public License version
1.0.
// See the file LICENSE.QPL distributed with this package.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the
software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// 
// Author(s)     : Chaim Zonnenberg, Remco Veltkamp
//

#ifndef CGAL_GA_FUNCTION_OBJECTS_3_H
#define CGAL_GA_FUNCTION_OBJECTS_3_H

#include<CGAL/config.h>
#include <iostream>
#include <vector>
#include <CGAL/enum.h>

// Cartesian kernel only used for validation
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Filtered_kernel.h>
#include <CGAL/Predicates/kernel_ftC3.h>


CGAL_BEGIN_NAMESPACE

// The following method is used for debugging
// It compares two 3d-points.
template <class FT>
static bool equalPointCoordinates(FT x1, FT x2, FT y1, FT y2, FT z1, FT z2)
{
        double threshold = GA_Precision;
        if (x1-x2>threshold) return false;
        if (x2-x1>threshold) return false;
        if (y1-y2>threshold) return false;
        if (y2-y1>threshold) return false;
        if (z1-z2>threshold) return false;
        if (z2-z1>threshold) return false;
        return true;
}



// Function object: Coplanar_orientation_3
// Call:            ()(const Point_3& p, const Point_3& q, const Point_3& r)
// If p,q,r are collinear, then COLLINEAR is returned. If
// not, then p,q,r define a plane P. The return value in
// this case is either POSITIVE or NEGATIVE, but we don抰
// specify it explicitely. However, we guarantee that all calls
// to this predicate over 3 points in P will return a coherent
// orientation if considered a 2D orientation in P.
template <typename K>
class Coplanar_orientation_3
{
        typedef typename K::Point_3      Point_3;         
        typedef typename K::FT      FT;
        typedef typename K::GA_Type GA_Type;

private:
        /*
        The plane $P$ has the formula $P=p\wedge q \wedge r \wedge
\mathbf{e}_{\infty}$. 
        The plane with opposite orientation is $-P$. The dual of the plane 
$P$ has
the form: 
        $\widetilde{P}=\mathbf{n}+d \mathbf{e}_{\infty}$, where $\mathbf{n}$ 
is the
3D-tangent 
        vector to the plane with generic formula $\mathbf{n}=a\mathbf{e}_1+b
\mathbf{e}_2+c 
        \mathbf{e}_3$, and where $d$ is the distance to from the plane to the
origin point 
        $\mathbf{e}_0$.\\ The direction of the normal vector (positive or 
negative
also 
        determines its orientation. So a consistent orientation 
(\ccc{POSITIVE} or
\ccc{NEGATIVE})
        can be given by looking at the sign of one of the normal vector
co\"{e}fficients 
        ($a$, $b$ or $c$). When such a co\"{e}fficient is zero, we should 
look at
another 
        co\"{e}fficient. We do this in the order $c$, $b$, $a$, because in 
that way
we get 
        the same results as the CartesianKernel-version of this function. When
\ccc{p,q,r} 
        are collinear, then $P=p\wedge q\wedge r\wedge \mathbf{e}_\infty$ 
returns
zero.
        */
        Orientation calculationGA(const Point_3& p, const Point_3& q, const
Point_3& r) const
        {
                GA_Type pp = p.normalize();
                GA_Type qq = q.normalize();
                GA_Type rr = r.normalize();

                GA_Type plane = (pp^qq)^(rr^e_ni);
                FT c = hip(plane.dual(), e_e3).scalar();
                if (c<GA_Precision) return NEGATIVE;
                if (c>GA_Precision) return POSITIVE;                    
                FT b = hip(plane, e_e2).scalar();
                if (b<GA_Precision) return NEGATIVE;
                if (b>GA_Precision) return POSITIVE;
                FT a = hip(plane, e_e1).scalar();
                if (a<GA_Precision) return NEGATIVE;
                if (a>GA_Precision) return POSITIVE;

                return COLLINEAR;       
        }

public: 

        Orientation operator()(const Point_3& p, const Point_3& q, const 
Point_3&
r) const
        {
                Orientation result = calculationGA(p,q,r);

#ifdef GA_VALIDATION             
                Orientation result2 = coplanar_orientationC3(p.x(), p.y(), 
p.z(),
                        q.x(), q.y(), q.z(),
                        r.x(), r.y(), r.z());
                if (result!=result2)
                {
                        // Output the error as exact as possible
                        p.print("\n p: ");
                        q.print("\n q: ");
                        r.print("\n r: ");
                        std::cerr << "\n GA_Result: " << result;
                        std::cerr << "\n C3_Result: " << result2;
                        // Terminate the program
                        CGAL_precondition(false);
                }
#endif                          
                return result;
        }       
};

// Function object: orientation_3
// Call:            ()(const Point_3& p, const Point_3& q, const Point_3& r,
const Point_3& s)
// returns \ccStyle{POSITIVE}, if $s$ lies on the positive side of the
oriented 
// plane $h$ defined by $p$, $q$, and $r$, returns \ccStyle{NEGATIVE} if $s$ 
// lies on the negative side of $h$, and returns \ccStyle{COPLANAR} if $s$
lies
// on $h$.
template <typename K>
class Orientation_3
{
        typedef typename K::Point_3 Point_3;
        typedef typename K::FT      FT;
public:
        typedef Orientation      result_type;
        typedef typename K::GA_Type             GA_Type;    

        /*
        The GA-formula $S = p\wedge q\wedge r\wedge s$ defines an oriented 
sphere.
This orientation 
        can be determined by looking at the sign of the $\mathbf{e}_0$
co\"efficient. This 
        co\"efficient $c$ can easily be calculated by taking the inner 
product of S
with 
        $\mathbf{e}_\infty$: $c=-S\cdot\mathbf{e}_\infty$ (because
$\mathbf{e}_0\cdot
        \mathbf{e}_\infty=-1$, while $\mathbf{e}_i\cdot\mathbf{e}_\infty=0$ 
where
$1\leq i 
        \leq 3$ and $\mathbf{e}_\infty\cdot\mathbf{e}_\infty=0$).
        */
        Orientation calculationGA( const Point_3& p, const Point_3& q,
                const Point_3& r, const Point_3& s) const
        { 
                // Points should be normalized (i.e. have positive 
orientation) 
                GA_Type pp = p.normalize();
                GA_Type qq = q.normalize();
                GA_Type rr = r.normalize();
                GA_Type ss = s.normalize();

                GA_Type sphere = (pp^qq)^(rr^ss);
                FT value = hip(sphere.dual(), e_ni).scalar();

                if (value>GA_Precision) return RIGHT_TURN;
                if (value<GA_Precision) return LEFT_TURN;
                return ZERO; 
        }

        Orientation operator()( const Point_3&amp; p, const Point_3&amp; q,
                const Point_3&amp; r, const Point_3&amp; s) const
        {
                Orientation result = calculationGA(p,q,r,s);
#ifdef GA_VALIDATION             
                Orientation result2 = orientationC3(p.x(), p.y(), p.z(),
                        q.x(), q.y(), q.z(),
                        r.x(), r.y(), r.z(),
                        s.x(), s.y(), s.z());
                if (result!=result2)
                {
                        // Output the error as exact as possible
                        p.print(&quot;\n p: &quot;);
                        q.print(&quot;\n q: &quot;);
                        r.print(&quot;\n r: &quot;);
                        s.print(&quot;\n s: &quot;);
                        std::cerr &lt;&lt; &quot;\n GA_Result: &quot; 
&lt;&lt; result;
                        std::cerr &lt;&lt; &quot;\n C3_Result: &quot; 
&lt;&lt; result2;
                        // Terminate the program
                        CGAL_precondition(false);
                }
#endif           
                return result;
        }
};

// Function object: Construct_circumcenter_3
// Call:            ()(const Point_3&amp; p, const Point_3&amp; q, const
Point_3&amp; r, const Point_3&amp; s)
// compute the center of the circle passing through the points $p$, $q$ and
$r$.
// \ccPrecond $p$, $q$ and $r$ are not collinear.
template &lt;typename K>
class Construct_circumcenter_3
{        
        typedef typename K::FT          FT;
        typedef typename K::Point_3     Point_3;
        typedef typename K::GA_Type             GA_Type;    

        /*
        First the circle $C$ through the points $p$, $q$ and $r$ is 
constructed.
After that 
        the centre of this circle is calculated. The circle has GA-formula:
$C=p\wedge 
        q\wedge r$. The middlepoint of the circle is $m=\frac{(C 
\mathbf{e}_\infty
C)}
        {2 (\mathbf{e}_\infty\cdot C)^2}$
        */    
        Point_3 calculationGA(const Point_3& p, const Point_3& q, const 
Point_3& r)
const
        {      
                GA_Type s = p^(q^r);  // s is the GA-circle through the 
points p, q and r 

                // Precondition: p, q and r should not be on one line.
                // A circle is a round in CGA. A property of a round is that 
its square
(s*s) is unequal to zero.
                FT test = (s*s).scalar();
                CGAL_kernel_assertion((-GA_Precision<test) || 
(test>GA_Precision)); //test
wheter it is zero or not

                // calculate result
                GA_Type result = (s * e_ni * s) / (hip(e_ni,s) * 
hip(e_ni,s))/2;      

                return Point_3(Point_3(result).normalize());                  
  
        }

public:
        Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& 
r)
const
        { 
                Point_3 result = calculationGA(p,q,r);

#ifdef GA_VALIDATION                      
                FT x, y, z;        
                circumcenterC3(p.x(), p.y(), p.z(),
                        q.x(), q.y(), q.z(),
                        r.x(), r.y(), r.z(),
                        x, y, z);
                if (!equalPointCoordinates(x,result.x(), y, result.y(), z, 
result.z()))
                {
                        // Output the error as exact as possible
                        p.print("\n p: ");
                        q.print("\n q: ");
                        r.print("\n r: ");
                        result.print("\n GA_Result: ");
                        std::cerr << "\n C3_Result: " << x << " " << y << " " 
<< z << " ";
                        // Terminate the program
                        CGAL_precondition(false);                             
                                                                  
                }
#endif         
                return result;               
        }
};

// Function object: Compare_distance_3
// Call:            ()(const Point_3&p, const Point_3&q, const Point_3&r);
// compares the distances of points \ccc{q} and \ccc{r} to point \ccc{p}
template <typename K>
class Compare_distance_3          
{
        typedef typename K::Point_3   Point_3;
        typedef typename K::FT        FT;
        typedef typename K::GA_Type             GA_Type;

        /*
        In CGA the distance between two normalized points $p$ and $q$ can be
calculated 
        with the following formula $d(p,q)=\sqrt{-2(p\cdot q)}$. This 
function only 
        returns which of the two distances is the smallest; therefore taking 
the
square 
        roots is not necessary, because that does not affect the result of the
function.
        */
        Comparison_result calculationGA(const Point_3& p, const Point_3& q, 
const
Point_3& r) const
        { 
                FT minus2sqrdistPQ = hip(p.normalize(), 
q.normalize()).scalar();
                FT minus2sqrdistPR = hip(p.normalize(), 
r.normalize()).scalar();

                if (minus2sqrdistPQ>minus2sqrdistPR) return SMALLER;
                if (minus2sqrdistPQ<minus2sqrdistPR) return LARGER;
                return EQUAL;
        }

public:
        Comparison_result operator()(const Point_3&amp; p, const Point_3&amp; 
q,
const Point_3&amp; r) const
        {
                Comparison_result result = calculationGA(p,q,r);
#ifdef GA_VALIDATION             
                Comparison_result result2 = cmp_dist_to_pointC3(p.x(), p.y(), 
p.z(),
                        q.x(), q.y(), q.z(),
                        r.x(), r.y(), r.z());
                if (result!=result2)
                {
                        // Output the error as exact as possible
                        p.print(&quot;\n p: &quot;);
                        q.print(&quot;\n q: &quot;);
                        r.print(&quot;\n r: &quot;);
                        std::cerr &lt;&lt; &quot;\n GA_Result: &quot; 
&lt;&lt; result;
                        std::cerr &lt;&lt; &quot;\n C3_Result: &quot; 
&lt;&lt; result2;
                        // Terminate the program
                        CGAL_precondition(false);
                }
#endif           
                return result;
        }    
};


// Function object: Compare_xyz_3
// Call:            ()( const Point_3&amp; p, const Point_3&amp; q);
/*
Compares the Cartesian coordinates of points \ccStyle{p} and
\ccStyle{q} lexicographically in $xy$ order: first 
$x$-coordinates are compared, if they are equal, $y$-coordinates
are compared. If they are equal, $z$-coordinates are compared.
*/
template &lt;typename K>
class Compare_xyz_3
{       
        typedef typename K::FT        FT;
        typedef typename K::GA_Type             GA_Type;    
        typedef typename K::Point_3    Point_3;

public:    
        /*
        This function uses cartesian co\"ordinates to perform this comparison 
(see 
        function requirements above). In the GA-kernel this method has a more 
        generic implementation. To calculate the cartesian co\"ordinates a 
special 
        C3GA-kernel function \ccStyle{default_base_element(index)} is used. 
This 
        function gives 3 orthogonal unit base vectors. By default it returns 
the 
        cartesian unit base vectors. Other orthogonal vectors can be used by 
        adapting this function.
        */
        Comparison_result operator()( const Point_3& p, const Point_3& q) 
const
        { 
                GA_Type pp = p.normalize();
                GA_Type qq = q.normalize();

                FT p1 = hip(pp, K::default_base_element(1)).scalar();
                FT q1 = hip(qq, K::default_base_element(1)).scalar();
                if (p1<q1) return SMALLER;
                if (p1>q1) return LARGER;

                FT p2 = hip(pp, K::default_base_element(2)).scalar();
                FT q2 = hip(qq, K::default_base_element(2)).scalar();
                if (p2<q2) return SMALLER;
                if (p2>q2) return LARGER;

                FT p3 = hip(pp, K::default_base_element(3)).scalar();
                FT q3 = hip(qq, K::default_base_element(3)).scalar();
                if (p3<q3) return SMALLER;
                if (p3>q3) return LARGER;

                return EQUAL;

        }
};

// Function object: Coplanar_side_of_bounded_circle_3
// Call:            ()( const Point_3& p, const Point_3& q,
//                                      const Point_3& r, const Point_3& t);
/*
returns the bounded side of the circle defined
by \ccc{p}, \ccc{q}, and \ccc{r} on which \ccc{t} lies.
\ccPrecond \ccc{p}, \ccc{q}, \ccc{r}, and \ccc{t} are coplanar and
\ccc{p}, \ccc{q}, and \ccc{r} are not collinear.
*/
template <typename K>
class Coplanar_side_of_bounded_circle_3
{

        typedef typename K::Point_3   Point_3;
        typedef typename K::FT        FT;
        typedef typename K::GA_Type             GA_Type;        

        /*
        First this function calculates the circumcenter point $m$ of the 
given 
        point. Then it calculates the distance from $m$ to $p$ with the 
distance 
        from $m$ to $t$.
        */
        Bounded_side calculationGA( const Point_3& p, const Point_3& q,
                const Point_3& r, const Point_3& t) const
        {               
                // Precondition check: p, q, r and t should be in the same 
plane
                FT test = (hip((p^q)^(r^t),(p^q)^(r^t) )).scalar();
                CGAL_kernel_assertion(-GA_Precision<= test && test <= 
GA_Precision);

                // Second precondition is checked by construct_circumcenter_3 
                Point_3 m = K().construct_circumcenter_3_object()(p,q,r); // 
point in the
middle of circle through p, q, r

                Comparison_result res = K().compare_distance_3_object()(m, p, 
t);

                if (res==SMALLER) return ON_UNBOUNDED_SIDE;
                if (res==LARGER) return ON_BOUNDED_SIDE;

                return ON_BOUNDARY;
        }

public:
        Bounded_side operator()( const Point_3& p, const Point_3& q,
                const Point_3& r, const Point_3& t) const
        { 
                Bounded_side result = calculationGA(p,q,r,t);
#ifdef GA_VALIDATION             
                Bounded_side result2 = 
coplanar_side_of_bounded_circleC3(p.x(), p.y(),
p.z(),
                        q.x(), q.y(), q.z(),
                        r.x(), r.y(), r.z(),
                        t.x(), t.y(), t.z());
                if (result!=result2)
                {
                        // Output the error as exact as possible
                        p.print("\n p: ");
                        q.print("\n q: ");
                        r.print("\n r: ");
                        t.print("\n t: ");

                        std::cerr << "\n GA_Result: " << result;
                        std::cerr << "\n C3_Result: " << result2;
                        // Terminate the program
                        CGAL_precondition(false);
                }
#endif                          
                return result;
        }
};

// Function object: Side_of_oriented_sphere_3
// Call:            ()( const Point_3& p, const Point_3& q, const Point_3&
r,
//                                              const Point_3& s, const 
Point_3& test)
/*
returns the relative position of point \ccStyle{t}
to the oriented sphere defined by $p$, $q$, $r$ and $s$.
The order of the points $p$, $q$, $r$, and $s$ is important,
since it determines the orientation of the implicitly
constructed sphere. If the points $p$, $q$, $r$ and $s$
are positive oriented, positive side is the bounded interior
of the sphere.
*/
template <typename K>
class Side_of_oriented_sphere_3
{
        typedef typename K::Point_3        Point_3;

        typedef Oriented_side    result_type;
        typedef Arity_tag< 5 >   Arity;
        typedef typename K::GA_Type             GA_Type;    
        typedef typename K::FT      FT;    

        /*      First the sphere is calculated: $B=p\wedge q\wedge r\wedge 
s$. (a sphere 
        always has an orientation) Then the sign of the orientation can be 
        determined by looking at the sign of the scalar $t\cdot\widetilde{B}
        */
        Oriented_side
                calculationGA( const Point_3& p, const Point_3& q, const 
Point_3& r,
                const Point_3& s, const Point_3& test) const
        { 
                // Precondition check: p, q, r and t should not be in the 
same plane
                FT testScalar = (hip((p^q)^(r^s),(p^q)^(r^s) )).scalar();
                CGAL_kernel_assertion(testScalar<-GA_Precision || testScalar>
GA_Precision);

                GA_Type pp = p.normalize();
                GA_Type qq = q.normalize();
                GA_Type rr = r.normalize();
                GA_Type ss = s.normalize();
                GA_Type testt = test.normalize();

                GA_Type dualSphere = ((pp^qq)^(rr^ss)).dual();
                FT scalar          = hip(testt,dualSphere).scalar();

                if (scalar<-GA_Precision) return ON_NEGATIVE_SIDE;
                if (scalar>GA_Precision) return ON_POSITIVE_SIDE;

                return ON_ORIENTED_BOUNDARY;
        }

public:    
        Oriented_side
                operator()( const Point_3& p, const Point_3& q, const 
Point_3& r,
                const Point_3& s, const Point_3& test) const
        {
                Oriented_side result =calculationGA(p,q,r,s,test);
#ifdef GA_VALIDATION             
                Oriented_side result2 = side_of_oriented_sphereC3(p.x(), 
p.y(), p.z(),
                        q.x(), q.y(), q.z(),
                        r.x(), r.y(), r.z(),
                        s.x(), s.y(), s.z(),
                        test.x(), test.y(), test.z());
                if (result!=result2)
                {
                        // Output the error as exact as possible
                        p.print("\n p: ");
                        q.print("\n q: ");
                        r.print("\n r: ");
                        s.print("\n s: ");
                        test.print("\n test: ");

                        std::cerr << "\n GA_Result: " << result;
                        std::cerr << "\n C3_Result: " << result2;
                        // Terminate the program
                        CGAL_precondition(false);
                }
#endif                          
                return result;
        }
};


// Function object: Construct_perpendicular_line_3
// Call:            ()( const Plane_3& pl, const Point_3& p);
// returns the line that is perpendicular to \ccc{pl} and that
//        passes through point \ccStyle{p}. The line is oriented from
//        the negative to the positive side of \ccc{pl}
template <typename K>
class Construct_perpendicular_line_3
{
        typedef typename K::Line_3    Line_3;
        typedef typename K::Point_3   Point_3;
        typedef typename K::Plane_3   Plane_3;
        typedef typename K::GA_Type             GA_Type;
public:                  
        /*
        This is done by calculating the normal vector to the plane \ccc{pl}:
\ccc{f}
        (in GA-free-vector form). 
$f=\widetilde{\mbox{pl}}\wedge\mathbf{e}_\infty$. 
        The line is calculated by taking the join (i.e. outer product) of $f$ 
and 
        $p$.
        */
        Line_3 operator()( const Plane_3& pl, const Point_3& p) const
        { 
                GA_Type pp = p.normalize();

                return Line_3( (pl.base.dual() ^ e_ni) ^ pp);
        }
};

template <typename K>
class Construct_plane_3
{
        typedef typename K::RT           RT;
        typedef typename K::Point_3      Point_3;
        typedef typename K::Vector_3     Vector_3;
        typedef typename K::Direction_3  Direction_3;
        typedef typename K::Line_3       Line_3;
        typedef typename K::Ray_3        Ray_3;
        typedef typename K::Segment_3    Segment_3;
        typedef typename K::Plane_3      Plane_3;
public:
        typedef Plane_3          result_type;
        typedef Arity_tag< 2 >   Arity;
        typedef typename K::GA_Type             GA_Type;        

        Plane_3
                operator()() const
        { return Plane_3(); }

        /*
        creates a plane  passing through the points \ccStyle{p},
        \ccStyle{q} and \ccStyle{r}. The plane is oriented such that 
\ccStyle{p}, 
        \ccStyle{q} and \ccStyle{r} are oriented in a positive sense 
        (that is counterclockwise) when seen from the positive side of the 
plane.
        Notice that is degenerate if the points are collinear.
        */
        Plane_3  operator()(const Point_3& p, const Point_3& q, const 
Point_3& r)
const
        { 
                return Plane_3(p^q^r^e_ni); 
        }

        /*
        introduces a plane  that passes through point \ccStyle{p} and
        that has as an orthogonal direction equal to \ccStyle{d}.
        */
        Plane_3 operator()(const Point_3& p, const Direction_3& d) const
        { return Plane_3(p, d); }

        /*
        introduces a plane that passes through point \ccStyle{p} and
        that is orthogonal to \ccStyle{v}.
        */
        Plane_3
                operator()(const Point_3& p, const Vector_3& v) const
        { return Plane_3(p, v); }

        /*
        introduces a plane  that passes through the line \ccStyle{l} and the 
        point \ccStyle{p}.
        */    
        Plane_3
                operator()(const Line_3& l, const Point_3& p) const
        { return Plane_3(l, p); }

        /*
        introduces a plane  that is defined through the  ray \ccStyle{r} 
        and the point \ccStyle{p}.
        */
        Plane_3
                operator()(const Ray_3& r, const Point_3& p) const
        { return Plane_3(r, p); }

        /*
        introduces a plane that is defined through the segment \ccStyle{s} 
        and the point \ccStyle{p}.
        */
        Plane_3
                operator()(const Segment_3& s, const Point_3& p) const
        { return Plane_3(s, p); }
};

template <typename K>
class Construct_ray_3
{
        typedef typename K::Point_3      Point_3;
        typedef typename K::Vector_3     Vector_3;
        typedef typename K::Direction_3  Direction_3;
        typedef typename K::Line_3       Line_3;
        typedef typename K::Ray_3        Ray_3;
        typedef typename K::GA_Type             GA_Type;        
public:

        /*
        introduces a ray with source $p$ and with the direction given by $v$.
        */    
        Ray_3
                operator()(const Point_3& p, const Vector_3& v) const
        {  return Ray_3(p, v); }

        /*
        introduces a ray with source $p$ and with 
        the same direction as $l$.
        */
        Ray_3
                operator()(const Point_3& p, const Line_3& l) const
        {  return Ray_3(p, l); }
};

/*  template <typename K>
class Construct_object_3
{

typedef typename K::Object_3   Object_3;
public:
typedef Object_3         result_type;
typedef Arity_tag< 1 >   Arity;

template <class Cls>Object_3 operator()( const Cls& c) const
{ 
//TODO
//return make_object(c); 
}
};*/

template <typename K>
class Construct_segment_3
{
        typedef typename K::Segment_3  Segment_3;
        typedef typename K::Point_3    Point_3;
public:

        /*
        introduces an uninitialized variable
        */
        Segment_3
                operator()() const
        {  return Segment_3(); }

        /*
        introduces a segment  with source $p$ and target $q$. It is directed 
from 
        the source towards the target.
        */
        Segment_3
                operator()( const Point_3& p, const Point_3& q) const
        {  
                return Segment_3(p,q);
        }
};

template <typename K>
class Construct_triangle_3
{
        typedef typename K::Triangle_3   Triangle_3;
        typedef typename K::Point_3      Point_3;
public:
        //      introduces an uninitialized variable    
        Triangle_3
                operator()() const
        { 
                return Triangle_3(); 
        }

        // introduces a triangle with vertices $p$, $q$ and $r$.
        Triangle_3
                operator()( const Point_3& p, const Point_3& q, const 
Point_3& r) const
        { 
                return Triangle_3(p, q, r); 
        }
};


template <typename K>
class Construct_tetrahedron_3
{
        typedef typename K::Tetrahedron_3   Tetrahedron_3;
        typedef typename K::Point_3         Point_3;
public:

        // introduces a tetrahedron  with vertices $p$, $q$, $r$ and $s$
        Tetrahedron_3
                operator()( const Point_3& p, const Point_3& q,
                const Point_3& r, const Point_3& s) const
        { return Tetrahedron_3(p, q, r, s); }
};


CGAL_END_NAMESPACE

#endif //CGAL_GA_FUNCTION_OBJECTS_3_H




-----
Cynthia
Shanghai
--
View this message in context: 
http://cgal-discuss.949826.n4.nabble.com/There-are-many-errors-in-threetuple-h-tp4656364p4656373.html
Sent from the cgal-discuss mailing list archive at Nabble.com.