---

cgul.cpp

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.
 */

#include "stdafx.h"

#include <iostream>

#include "gul_types.h"
#include "gunu_mba_approximate.h"
#include "guma_transform.h"

#if defined(__MINGW32__) || defined(_MSC_VER)
  #define GULDECL __declspec(dllexport)
  #define GULCALL __cdecl
  #define CCALL   __cdecl 
#else
  #define GULDECL
  #define GULCALL
  #define CCALL
#endif

using gul::Ptr;
using gul::point;
using gul::point2;

extern "C" {

/*------------------------------------------------------------------
   basic data types, used for import/export
-------------------------------------------------------------------*/

typedef struct
{
  double x,y,z;
}
GULpoint;

typedef struct
{
  double x,y;
}
GULpoint2;

}

/*-----------------------------------------------------------------------
  convenience functions for copying input/output vectors and matrices
-----------------------------------------------------------------------*/

inline void set( double *out, const double& in )
{
  *out = in;
} 

inline void set( point<double> *out, const GULpoint& in )
{
  out->x = in.x;
  out->y = in.y;
  out->z = in.z;
}  

inline void set( point2<double> *out, const GULpoint2& in )
{
  out->x = in.x;
  out->y = in.y;
}

inline void set( GULpoint *out, const point<double>& in  )
{
  out->x = in.x;
  out->y = in.y;
  out->z = in.z;
}  

inline void set( GULpoint2 *out, const point2<double>& in )
{
  out->x = in.x;
  out->y = in.y;
}  

/*----------------------------------------------------------------*/

template< class T1, class T2 >
void copy( int n, const T1 *inP, Ptr<T2>& outP )
{
  int i;
  outP.reserve_pool(n);
  for( i = 0; i < n; i++ )
    set( &outP[i], inP[i] );
}

template< class T1, class T2 >
void copy( int n, const Ptr<T1>& inP, T2 **outP )
{
  int i;
  *outP = (T2 *)galloc( sizeof(T2) * n );
  for( i = 0; i < n; i++ )
    set( &(*outP)[i], inP[i] );
}

/*----------------------------------------------------------------*/

template< class T1, class T2 >
void copy( int m, int n, const T1 **inP, Ptr< Ptr<T2> >& outP )
{
  int i;
  outP.reserve_pool(m);
  for( i = 0; i < m; i++ )
  {
    outP[i].reserve_pool(n);
    for( j = 0; j < n; j++ )
      set( &outP[i][j], inP[i][j] );
  }
}

template< class T1, class T2 >
void copy( int m, int n, const Ptr< Ptr<T1> >& inP, T2 ***outP )
{
  int i,j;
  *outP = (T2**)galloc( sizeof(T2*) * m );
  for( i = 0; i < m; i++ )
  {
    (*outP)[i] = (T2*)galloc( sizeof(T2) * n );
    for( j = 0; j < n; j++ )
      set( &(*outP)[i][j], inP[i][j] );
  }
}

/*---------------------------------------------------------------
  interface functions for plain C
---------------------------------------------------------------*/

extern "C" {

/*---------------------------------------------------------------------
  with this function you can change the functions which are used for
  malloc/free of return arrays (for example necessary when using 'dbg_malloc'
  in the application, since in the dll the normal malloc is used)
----------------------------------------------------------------------*/

static void *(CCALL *GUL_malloc_func)( size_t size ) = 0;
static void (CCALL *GUL_free_func)( void * ) = 0;

GULDECL void GULCALL GUL_set_malloc_func( void *(CCALL *func)(size_t) )
{
  GUL_malloc_func = func;
}

GULDECL void GULCALL GUL_set_free_func( void (CCALL *func)(void *) )
{
  GUL_free_func = func;
}

void *galloc( size_t size )
{
  if( GUL_malloc_func )
    return GUL_malloc_func(size);

  return malloc(size);
}

void gree( void *p )
{
  if( GUL_free_func )
  {
    GUL_free_func(p);
    return;
  }
  free(p);
}

/*-------------------------------------------------------------------*//**
  executes the MBA algorithm and constructs a 3-dimensional surface
  from the results (x,y are linear mappings of u and v ).
  when 'minimize' is set, the base rectangle in the xy-plane is
  chosen so that its area is minimal                                    

  input arrays:

  datPoints  : array of data-points
  StdDevs    : standard deviations of the data points (if useStdDevs = 0,
               all assumed as beeing one)

  output arrays are reserved by the function and have the dimensions:

  retU     : nu + pu + 2
  retV     : nv + pv + 2
  retPw    : nv + 1 
  retPw[i] : nu + 1
                                                                        */
/* ---------------------------------------------------------------------*/

GULDECL void GULCALL GUL_SurfaceOverXYPlane(
          int nDatPoints, GULpoint *datPoints,
          int useStdDevs, double *StdDevs,
          int minimize, int nIter,
          int pu, int pv,
          int *ret_nu, double **retU,
          int *ret_nv, double **retV,
          GULpoint ***retPw )
{
  Ptr< point<double> > datP;
  Ptr<double> stdD, U, V;
  Ptr< Ptr< point<double> > > Pw;

  copy( nDatPoints, datPoints, datP );
  if( useStdDevs ) copy( nDatPoints, StdDevs, stdD );

  gunu::SurfaceOverXYPlane< double,point<double> >( 
               nDatPoints, datP, (useStdDevs!=0), stdD, (minimize!=0), nIter, pu, pv, 
               ret_nu, &U, ret_nv, &V, &Pw );

  copy( U.nElems(), U, retU ); 
  copy( V.nElems(), V, retV ); 
  copy( Pw.nElems(), Pw[0].nElems(), Pw, retPw );
}

/*-------------------------------------------------------------------*//**
  creates a surface with the MBA algorithm. 'Dat' contains the 3d
  values and 'Dom' the locations in the parametric domain 
  (output arrays are reserved automatically)                            */
/* ---------------------------------------------------------------------*/

GULDECL void GULCALL GUL_MBASurface( 
          int nDatPoints, GULpoint *datPoints, GULpoint2 *domPoints, 
          int nIter, int pu, int pv,
          int *ret_nu, double **retU,
          int *ret_nv, double **retV,
          GULpoint ***retPw )
{
  Ptr< point<double> > dat;
  Ptr< point2<double> > dom;
  Ptr<double> U,V;
  Ptr< Ptr< point<double> > > Pw;

  copy( nDatPoints, datPoints, dat );
  copy( nDatPoints, domPoints, dom );

  gunu::MBASurface( nDatPoints, dat, dom, nIter, pu, pv, 
                    ret_nu, &U, ret_nv, &V, &Pw );

  copy( U.nElems(), U, retU ); 
  copy( V.nElems(), V, retV ); 
  copy( Pw.nElems(), Pw[0].nElems(), Pw, retPw );
}


/*-------------------------------------------------------------------
  Calculates a matrix wich transforms points given in a local coordinate
  system at a point 'B' into the world coordinate system.
  An additional point is required (both in world coordinates
  (=P) and local coordinates (=Pb)). 'Ab' must contain the coordinates
  of the origin in the local coordinate system at 'B'.
  Both coordinate systems must be orthonormal, and memory for 'T' (a 4x4
  matrix) must be reserved by the caller.
-------------------------------------------------------------------*/

GULDECL void GULCALL GUL_CommonCoordinateSystem( 
          GULpoint B, GULpoint P, GULpoint Ab, GULpoint Pb,
          double **T )
{
  point<double> b,p,ab,pb;
  Ptr< Ptr<double> > t;
  int i,j;

  b.x = B.x;    b.y = B.y;    b.z = B.z;
  p.x = P.x;    p.y = P.y;    p.z = P.z;
  ab.x = Pb.x;    ab.y = Pb.y;    ab.z = Pb.z;
  pb.x = Pb.x;    pb.y = Pb.y;    pb.z = Pb.z;

  t.reserve_pool(4);
  for( i = 0; i < 4; i++ )
    t[i].reserve_pool(4);

  guma::CommonCoordinateSystem( b, p, ab, pb, t );

  for( i = 0; i < 4; i++ )
    for( j = 0; j < 4; j++ )
      T[i][j] = t[i][j];
}

}

---