---

gugr_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 GUGR_IO_H
#define GUGR_IO_H

#include <iostream>
#include <iomanip>

namespace gugr {

using gul::Assert;
using gul::Ptr;
using gul::rtr;
using gul::uint64;
using gul::point2;
using gul::line2;
using gul::triangle2;
using gul::dump_point;

/*------------------------------------------------------------------------
  output functions for debugging
------------------------------------------------------------------------*/
template< class T >
class Dump
{
public:
  static T orgx,orgy,scalex,scaley; 
public:
  static void set_transformation( T aorgx, T aorgy, T ascalex, T ascaley )
  {
    orgx = aorgx; 
    orgy = aorgy;
    scalex = ascalex;
    scaley = ascaley;
  }
  static void dump_vertice( graph_vertex *v )
  {
    double dx1,dy1;
    T x1,y1;
  
    if( v != NULL )
    {
      v->v.v().m_x.Dump(dx1);
      v->v.v().m_y.Dump(dy1);
      x1 = (T)dx1;
      y1 = (T)dy1; 

      x1 = cnv2coord<T>(x1)*scalex + orgx; 
      y1 = cnv2coord<T>(y1)*scaley + orgy;  
      std::cout << (void *)v << ": (" <<
                std::setprecision(8) << x1 << ", " << y1 << 
                "), " << (void *)v->e << "\n";
    }
    std::cout.flush();
  }
  static void dump_vert( const vertex& v )
  {
    double dx1,dy1;
    T x1,y1;
  
    v.v().m_x.Dump(dx1);
    v.v().m_y.Dump(dy1);
    x1 = (T)dx1;
    y1 = (T)dy1; 

    x1 = cnv2coord<T>(x1)*scalex + orgx; 
    y1 = cnv2coord<T>(y1)*scaley + orgy;  
    std::cout << "(" << x1 << ", " << y1 <<  ")\n";
    std::cout.flush();
  }
  static void dump_vertices( graph_vertex *V )
  {
    graph_vertex *v;
    double dx1,dy1;
    T x1,y1;
  
    v = V;
    std::cout << "VERTICES\n";
    while( v != NULL )
    {
      v->v.v().m_x.Dump(dx1);
      v->v.v().m_y.Dump(dy1);
      x1 = (T)dx1;
      y1 = (T)dy1; 

      x1 = cnv2coord<T>(x1)*scalex + orgx; 
      y1 = cnv2coord<T>(y1)*scaley + orgy;  
      std::cout << (void *)v << ": (" <<
                std::setprecision(8) << x1 << ", " << y1 << 
                "), " << (void *)v->e << "\n";
      v = v->next;
    }
    std::cout.flush();
  }
  static void dump_edges( graph_edge *E )
  {
    graph_edge *e;
    double dx1,dx2,dy1,dy2;
    T x1,x2,y1,y2;
    
    e = E;
    std::cout << "EDGES\n";    
    while( e != NULL )
    {
      e->v[0]->v.v().m_x.Dump(dx1);
      e->v[0]->v.v().m_y.Dump(dy1);
      e->v[1]->v.v().m_x.Dump(dx2);
      e->v[1]->v.v().m_y.Dump(dy2);

      x1 = (T)dx1; x2 = (T)dx2; y1 = (T)dy1; y2 = (T)dy2;
      
      x1 = cnv2coord<T>(x1)*scalex + orgx; 
      x2 = cnv2coord<T>(x2)*scalex + orgx; 
      y1 = cnv2coord<T>(y1)*scaley + orgy; 
      y2 = cnv2coord<T>(y2)*scaley + orgy; 

      std::cout << (void *)e << ": [" << e->f[0] << "," << e->f[1] << "] [" <<
                (void *)e->v[0] << "=(" << std::setprecision(8) <<
                x1 << ", " << y1 << "), " << (void *)e->e[0] <<
                "]  [" << (void *)e->v[1] << "=(" <<
                x2 << ", " << y2 << "), " << (void *)e->e[1];
      if( e->l.IsNULL() )
        std::cout << "]\n";
      else
      {
        e->l.v().m_x.Dump(dx1);
        e->l.v().m_y.Dump(dy1);
        x1 = (T)dx1; y1 = (T)dy1;
        x1 = cnv2coord<T>(x1)*scalex + orgx; 
        y1 = cnv2coord<T>(y1)*scaley + orgy; 
 
        e->l.dx().Dump(dx2);
        e->l.dy().Dump(dy2);
        x2 = (T)dx2; y2 = (T)dy2;

        std::cout << "]  L: (" << x1 << ", " << y1 << "), dx=" <<
                  x2 << ", dy=" << y2 << "\n";
      }
      e = e->next;
    }
    std::cout.flush();
  }
};

/*---------------------------------------------------------------------
  same as above, but without the transformation hazzle
----------------------------------------------------------------------*/
class dump_graph
{
public:
  gul::poolmap<graph_vertex*,int> m_V;
  int                             m_nV;
  gul::poolmap<graph_edge*,int>   m_E;
  int                             m_nE;
  graph_vertex_list              *m_VL;
  graph_edge_list                *m_EL;


public:
  dump_graph( graph_vertex_list *V, graph_edge_list *E )
  {
    int i;
    graph_vertex *v = V->First();
    graph_edge   *e = E->First();

    m_VL = V;
    m_EL = E;

    // initialize pointer lookup tables
    i = 1;    
    while( v != NULL )
    {
      m_V[v] = i;
      i++;
      v = v->next;
    }
    m_nV = i;

    i = 1;    
    while( e != NULL )
    {
      m_E[e] = i;
      i++;
      e = e->next;
    }
    m_nE = i;
  };
  
  void dump_vertice( graph_vertex *v, std::ostream& s )
  {
    if( v )
      s << "V" << m_V[v] << ": [(" << v->v.v() << "), " 
        << "E" << m_E[v->e] << "]\n";
    else
      s << "<NULL>\n";
  }

  void dump_vertices( graph_vertex *V, std::ostream& s )
  {
    graph_vertex *v = V;

    s << "VERTICES\n";
    while( v != NULL )
    {
      s << "V" << m_V[v] << ": [(" << v->v.v() << "), " 
        << "E" << m_E[v->e] << "]\n";
      v = v->next;
    }
  }

  void dump_edges( graph_edge *E, std::ostream& s )
  {
    graph_edge *e = E; 

    s << "EDGES\n";    
    while( e != NULL )
    {
      s << "E" << m_E[e] << ": [" << e->f[0].i << "," << e->f[1].i << "] ["
        << "V" << m_V[e->v[0]] << "=(" << e->v[0]->v.v() << "), " 
        << "E" << m_E[e->e[0]] << "]  ["
        << "V" << m_V[e->v[1]] << "=(" << e->v[1]->v.v() << "), " 
        << "E" << m_E[e->e[1]] << "]";                
      s << "\n";
      e = e->next;
    }
  }
};

inline std::ostream& operator<<( std::ostream& s, gugr::dump_graph& g )
{
  g.dump_vertices(g.m_VL->First(),s);
  g.dump_edges(g.m_EL->First(),s);

  return s << "\n";
} 


inline void dump_segment( segment *S, std::ostream& s )
{
   s << "[" << S->f[0].i << ", " << S->f[1].i << "] B=(" 
     << S->B << "), (" << S->E << ")\n";
}


class dump_segs
{
public:
  segment_list *m_S;

public:
  dump_segs( segment_list *S )
  {
    m_S = S;
  }

  void dump( ListNode<segment> *S, std::ostream& s )
  {
    for( ; S; S = S->next )
    {
      s << "[" << S->el.f[0].i << ", " << S->el.f[1].i << "] B=(" 
        << S->el.B << "), (" << S->el.E << ")\n";
    }
  }
};

inline std::ostream& operator<<( std::ostream& s, gugr::dump_segs& S )
{
  S.dump(S.m_S->First(),s);
  return s;
} 

}



#endif

---