---

gul_io.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 GUL_IO_H
#define GUL_IO_H

namespace gul {

using std::ostream;

enum dump_format
{
  human_readable = 0,
  gul_format
};

enum dump_point_format
{
  homogeneous = 0,
  euclidian,
  mixed
};

class dump_defaults
{
public:
  GULAPI static dump_format       m_format;       // default: human_readable;
  GULAPI static dump_point_format m_point_format; // default: homogeneous;

  static void set_format( dump_format f ) { m_format = f; }
  static void set_point_format( dump_point_format f ) { m_point_format = f; }
};

template< class EP >
class dump_point
{
public:
  EP                m_P;
  dump_format       m_f; 
  dump_point_format m_e;

  dump_point( const EP& P, dump_format f, dump_point_format e )
  {
    m_P = P;
    m_f = f;
    m_e = e;
  }
  dump_point( const EP& P )
  {
    m_P = P;
    m_f = dump_defaults::m_format;
    m_e = dump_defaults::m_point_format;
  }

  std::ostream& out_human( std::ostream& s ) const
  {
    int i;

    if( (!EP::hom()) || (m_e == homogeneous) )
    {
      s << m_P[0];
      for( i = 1; i < EP::dim(); i++ )
      {
        s << " ";
        s << m_P[i];   
      }
    }
    else if( m_e == euclidian )
    {
      s << m_P[0]/m_P.weight();
      for( i = 1; i < EP::dim()-1; i++ )
      {
        s << " ";
        s << m_P[i]/m_P.weight();   
      }
    }
    else if( m_e == mixed )
    {
      s << m_P[0]/m_P.weight();
      for( i = 1; i < EP::dim()-1; i++ )
      {
        s << " ";
        s << m_P[i]/m_P.weight();   
      }
      s << " ";
      s << m_P.weight();   
    }
    return s;
  }

  std::ostream& out_gul( std::ostream& s ) const
  {
    int i;

    if( (!EP::hom()) || (m_e == homogeneous) )
    {
      s << "(" << m_P[0];
      for( i = 1; i < EP::dim(); i++ )
      {
        s << ", ";
        s << m_P[i];   
      }
      s << ")";
    }
    else if( m_e == euclidian )
    {
      s << "(" << m_P[0]/m_P.weight();
      for( i = 1; i < EP::dim()-1; i++ )
      {
        s << ", ";
        s << m_P[i]/m_P.weight();   
      }
      s << ")";
    }
   else if( m_e == mixed )
    {
      s << "(" << m_P[0]/m_P.weight();
      for( i = 1; i < EP::dim()-1; i++ )
      {
        s << ", ";
        s << m_P[i]/m_P.weight();   
      }
      s << ", ";
      s << m_P.weight();   
      s << ")";
    }
    return s;
  }
};

template< class EP >
inline std::ostream& operator<<( std::ostream& os, const gul::dump_point<EP>& P )
{
  if( P.m_f == human_readable )
    P.out_human(os);
  else if( P.m_f == gul_format )
    P.out_gul(os);

  return os;
}


template< class T >
inline ostream& operator<<( ostream& s, const point1<T>& p )
{
  return s << gul::dump_point<gul::point1<T> >(p);
} 
template< class T>
inline ostream& operator<<( ostream& s, const hpoint1<T>& p )
{
  return s << gul::dump_point<gul::hpoint1<T> >(p);
} 

template< class T >
inline ostream& operator<<( ostream& s, const point2<T>& p )
{
  return s << gul::dump_point<gul::point2<T> >(p);
} 
template< class T>
inline ostream& operator<<( ostream& s, const hpoint2<T>& p )
{
  return s << gul::dump_point<gul::hpoint2<T> >(p);
} 

template< class T >
inline ostream& operator<<( ostream& s, const point<T>& p )
{
  return s << gul::dump_point<gul::point<T> >(p);
} 
template< class T>
inline ostream& operator<<( ostream& s, const hpoint<T>& p )
{
  return s << gul::dump_point<gul::hpoint<T> >(p);
} 

template< class EP, class L >
class dump_line
{
public:
  L m_line;
  dump_format       m_f;
  dump_point_format m_e;

  dump_line( const L& l, dump_format f, dump_point_format e )
  {
    m_line = l;
    m_f = f;
    m_e = e;
  }
  dump_line( const L& l )
  {
    m_line = l;
    m_f = dump_defaults::m_format;
    m_e = dump_defaults::m_point_format;
  }
  ostream& out_human( ostream& os ) const
  {
    os << "(" << dump_point<EP>(m_line[0],m_f,m_e) << " "
       << dump_point<EP>(m_line[1],m_f,m_e) << ")";

    return os;
  }
  ostream& out_gul( ostream& os ) const
  {
    os << "(" << dump_point<EP>(m_line[0],m_f,m_e) << ", "
       << dump_point<EP>(m_line[1],m_f,m_e) << ")";

    return os;
  }
};

template< class EP, class L >
inline ostream& operator<<( ostream& os, const dump_line<EP,L>& l )
{
  if( l.m_f == human_readable )
    l.out_human(os);
  else if( l.m_f == gul_format )
    l.out_gul(os);

  return os;
}

template< class T >
inline ostream& operator<<( ostream& os, const line<T>& l )
{
  os << dump_line<point<T>,line<T> >(l);
  return os;
}

template< class T >
inline ostream& operator<<( ostream& os, const line2<T>& l )
{
  os << dump_line<point2<T>,line2<T> >(l);
  return os;
}

template< class T >
class dump_list
{
public:
  List<ListNode<T> > *m_L;

  dump_list( List<ListNode<T> > *L )
  {
    m_L = L;
  }
  ostream& out_gul( ostream& os ) const
  {
    ListNode<T> *n;

    os << "(\n";

    n = m_L->First();
    if( n )
      os << "  " << n->el;

    for( ; n; n = n->next )
    {
      os << ",\n";
      os << "  " << n->el;
    }

    os << "\n";
    os << ")";

    return os;
  }
};

template< class T >
inline ostream& operator<<( ostream& os, const dump_list<T>& L )
{
  L.out_gul(os);

  return os;
}


template< class T, class HP >
class dump_surf
{
public:
  int               m_nu;
  int               m_pu;
  Ptr<T>            m_U;
  int               m_nv;
  int               m_pv;
  Ptr<T>            m_V;
  Ptr< Ptr< HP > >  m_Pw;
  dump_format       m_f;
  dump_point_format m_e;

  dump_surf( int nu, int pu, Ptr<T>& U, int nv, int pv, Ptr<T>& V,
             Ptr< Ptr< HP > >& Pw, dump_format f, dump_point_format e )
  {
    m_nu = nu;
    m_pu = pu;
    m_U = U;
    m_nv = nv;
    m_pv = pv;
    m_V = V;
    m_Pw = Pw;
    m_f = f;
    m_e = e;
  }
  dump_surf( int nu, int pu, Ptr<T>& U, int nv, int pv, Ptr<T>& V,
             Ptr< Ptr< HP > >& Pw )
  {
    m_nu = nu;
    m_pu = pu;
    m_U = U;
    m_nv = nv;
    m_pv = pv;
    m_V = V;
    m_Pw = Pw;
    m_f = dump_defaults::m_format;
    m_e = dump_defaults::m_point_format;
  }

  std::ostream& out_human( std::ostream& os ) const
  {
   int i,j;

    os << "Knot Vector V\n";
    for( i = 0; i < m_nv+m_pv+2; i++ )
      os << m_V[i] << " ";
    os << "\n";

    os << "Knot Vector U\n";
    for( i = 0; i < m_nu+m_pu+2; i++ )
      cout << m_U[i] << " ";
    os << "\n";
    os.flush();

    os << "Control Points:\n";
    for( i = 0; i < m_nv+1; i++ )
    {
      for( j = 0; j < m_nu+1; j++ )
        os << "(" << dump_point<HP>(m_Pw[i][j],m_f,m_e) << ") ";
      os << "\n";
    }
    os.flush();

    return os;
  }
  std::ostream& out_gul( std::ostream& os ) const
  {
    int i,j;

    os << "(\n";
    // u knot vector
    os << "  (\n";
    os << "    " << m_U[0];
    for( i = 1; i < m_nu + m_pu + 2; i++ )
    {
      os << ",\n";
      os << "    " << m_U[i];        
    }
    os << "\n";
    os << "  ),\n";

    // v knot vector
    os << "  (\n";
    os << "    " << m_V[0];
    for( i = 1; i < m_nv + m_pv + 2; i++ )
    {
      os << ",\n";
      os << "    " << m_V[i];        
    }
    os << "\n  ),\n";

    // control point matrix
    os << "  (\n";

    // first row
    os << "    (\n";
    os << "      " << dump_point<HP>(m_Pw[0][0],m_f,m_e);
    for( i = 1; i <= m_nu; i++ )
    {
      os << ",\n";
      os << "      " << dump_point<HP>(m_Pw[0][i],m_f,m_e);
    }
    os << "\n    )";

    // remaining rows
    for( j = 1; j <= m_nv; j++ )
    {
      os << ",\n";
      os << "    (\n";
      os << "      " << dump_point<HP>(m_Pw[j][0],m_f,m_e);
      for( i = 1; i <= m_nu; i++ )
      {
        os << ",\n";
        os << "      " << dump_point<HP>(m_Pw[j][i],m_f,m_e);
      }
      os << "\n    )";
    }

    os << "\n  )\n";
    os << ")";

    return os;
  }
};

template< class T, class HP >
inline ostream& operator<<( ostream& os, const dump_surf<T,HP>& s )
{
  if( s.m_f == human_readable )
    s.out_human(os);
  else if( s.m_f == gul_format )
    s.out_gul(os);

  return os;
}



template< class T, class HP >
class dump_curve
{
public:
  int              m_n;
  int              m_p;
  Ptr<T>           m_U;
  Ptr< HP >        m_Pw;

  dump_curve( int n, int p, Ptr<T>& U, Ptr< HP >& Pw )
  {
    m_n = n;
    m_p = p;
    m_U = U;
    m_Pw = Pw;
  }
};

template< class T, class HP >
inline ostream& operator<<( ostream& os, const dump_curve<T,HP>& c )
{
  int i;

  os << "Knot Vector U\n";
  for( i = 0; i < c.m_n+c.m_p+2; i++ )
    cout << c.m_U[i] << " ";
  os << "\n";
  os.flush();

  os << "Control Points:\n";
  for( i = 0; i < c.m_n+1; i++ )
  {
    os << "(" << c.m_Pw[i] << ") ";
  }
  os.flush();

  return os;
}

template< class HP >
class dump_matrix
{
public:
  int                     m_nRows;
  int                     m_nCols;
  const Ptr< Ptr< HP > >& m_M;

  dump_matrix( int nRows, int nCols, const Ptr< Ptr< HP > >& M ) : m_M(M)
  {
    m_nRows = nRows;
    m_nCols = nCols;
  }
};

template< class HP >
inline ostream& operator<<( ostream& os, const dump_matrix<HP>& m )
{
  int i,j;

  os << "Matrix:\n";
  for( i = 0; i < m.m_nRows; i++ )
  {
    for( j = 0; j < m.m_nCols; j++ )
      os << "(" << m.m_M[i][j] << ") ";
    os << "\n";
  }
  os.flush();

  return os;
}

template< class HP >
class dump_vector
{
public:
  int            m_nV;
  const Ptr<HP>& m_V;

  dump_vector( int nV, const Ptr<HP>& V ) : m_V(V)
  {
    m_nV = nV;
  }
};

template< class HP >
inline ostream& operator<<( ostream& os, const dump_vector<HP>& m )
{
  int i;

  os << "Vector:\n";
  for( i = 0; i < m.m_nV; i++ )
  {
    os << "(" << m.m_V[i] << ") ";
    os << "\n";
  }
  os.flush();

  return os;
}





















}

#endif

---