---

gunu_intersect.h

Go to the documentation of this file.

/* LIBGUL - Geometry Utility Library
 * Copyright (C) 1998-1999 Norbert Irmer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef GUNU_INTERSECT_H
#define GUNU_INTERSECT_H

namespace gunu {

using gul::Ptr;
using gul::point;
using gul::hpoint;
using gul::line2;
using gul::cross_product;
using gul::euclid;

/*-----------------------------------------------------------------------
  Estimate the (u,v) parameter values of a point P for a NURBS surface F,
  assuming that A = F(0,0), B = F(1,0), C = F(0,1)
------------------------------------------------------------------------*/
/*  this is nonsense
template< class T >
inline void BarycentricUV( 
                    const point<T> A, const point<T> B, const point<T> C,
                    const point<T> P, T *u, T *v )
{
  point<T> AB,AC,AP;
  T fABC, fACP, fABP;

  AB = B - A;
  AC = C - A;
  fABC = cross_product( AB, AC );    // Flaecheninhalt Parallelogramm
  AP = P - A;
  fACP = cross_product( AC, AP );    // Flaecheninhalt Parallelogramm
  fABP = cross_product( AB, AP );

  *v = fABP / fABC;
  *u = fACP / fABC;
}    
*/

template< class T >
class IntersectionLineInfo : public gul::pool_object
{
public:
  gul::point2<T> Suv[2];
  int            Sflag[2];
};

template< class T >
class IntersectInfo : public gul::pool_object
{
public:
  T minx,miny,minz,scalei;

  gul::List<gul::ListNode<IntersectionLineInfo<T> > > IA,IB;
  // only for debugging
  gul::List<gul::ListNode<gul::line<T> > > IS;
};

template< class T, class HP >
struct SurfaceInfo
{
  int      nu;
  int      pu;
  Ptr< T > U; 
  int      nv;
  int      pv;
  Ptr< T > V;
  Ptr< Ptr< HP > > Pw;
  void    *reserved[2];   /* for boundaries */

  point<T> P00;    /* Eckpunkte der Flaeche (um zu verhindern,  */
  point<T> P01;    /* das an T-Stellen der Tesselierung Loecher */
  point<T> P10;    /* entstehen)                                */
  point<T> P11;

  void *operator new( size_t s )
  {
    size_t dummy;

    void *p = gust::PoolAlloc( s, &dummy );
    if( p == NULL ) throw gul::PoolAllocError();
    return(p);
  }  
  void operator delete( void *p, size_t s )
  {
    gust::PoolFree( p, s );
  }
};

template< class T, class HP >
class TessInfo
{
public:
  T x1;   /* Bounding Box */
  T x2;
  T y1;
  T y2;
  T z1;
  T z2;

  T u1;   /* Parameterwerte der Flaeche (bezogen auf  */
  T u2;   /* die Originalflaeche)                     */
  T v1;
  T v2;

  unsigned int linearized : 1;
  unsigned int divided    : 1;
  
  SurfaceInfo<T,HP>      *org;    /* Originalzustand (ungeteilt); */
  TessInfo               *sub[4]; /* Flaeche in 4 Teilflaechen zerteilt */

  void operator delete( void *p, size_t s )
  {
    gust::PoolFree( p, s );
  }
  void *operator new( size_t s )
  {
    size_t dummy;
    void *p = gust::PoolAlloc( s, &dummy );
    if( p == NULL ) throw gul::PoolAllocError();
    return(p);
  }  

  TessInfo()
  {
    linearized = divided = 0;
    org = new SurfaceInfo<T,HP>();
    for( int i = 0; i < 4; i++ ) sub[i] = 0;
  }
  ~TessInfo()
  {
    int i;

//    if( f.divided )
//    {
      for( i = 0; i < 4; i++ )
      {
        delete sub[i];
        sub[i] = 0;
      }
//    } 
//    else
//    {  
      delete org;   /* Speicher fuer ungeteilte Flaeche freigeben */
      org = 0;
//    }  
  }
};


/*--------------------------------------------------------------------
  Check if a NURBS surface can be approximated with two triangles through
  its four corners. If not the surface is subdivided into four parts
----------------------------------------------------------------------*/
template< class T, class HP >
void LinearizeOrDivide( TessInfo<T,HP> *A, const T tol, 
                        bool need_bbox = false );

/*-------------------------------------------------------------------
  Approximate NURBS-Surface with triangles
--------------------------------------------------------------------*/
template< class T, class HP >
void DoLinearizeSurface( 
                 int current_iter, int max_iter,
                 TessInfo<T,HP> *A,
                 const T tol,
                 void    outfunc( TessInfo<T,HP> *, void * ),                                   
                 void   *outfunc_data );


/*---------------------------------------------------------------------
  intersect the linear approximation of two nurbs surfaces
----------------------------------------------------------------------*/
template< class T, class HP >
void DoIntersectSurfaces( 
                 TessInfo<T,HP> *A, TessInfo<T,HP> *B,
                 T tol,
                 IntersectInfo<T> *II );

/*---------------------------------------------------------------------
  intersects the linear approximation of two nurbs surfaces
----------------------------------------------------------------------*/
template< class T, class HP >
GULAPI void IntersectSurfaces( 
            int nu1, int pu1, const Ptr< T >& U1,
            int nv1, int pv1, const Ptr< T >& V1,
            const Ptr< Ptr < HP > >& Pw1,
            int nu2, int pu2, const Ptr< T >& U2,
            int nv2, int pv2, const Ptr< T >& V2,
            const Ptr< Ptr < HP > >& Pw2,
            T tol,
            gul::List<gul::ListNode<IntersectionLineInfo<T> > >& S1,
            gul::List<gul::ListNode<IntersectionLineInfo<T> > >& S2,
            gul::List<gul::ListNode<gul::line<T> > >& S );


}

#endif

---