---

MapDataDocument_convert_Tracing.cpp

//$Header: /home/ben/Mapper/c++/RCS/MapDataDocument_convert_Tracing.cpp,v 6.14 2002/07/14 17:25:32 ben Exp $
// Copyright Benedict Adamson 2002.
// This file is part of Mapper.

// Mapper is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.

// Mapper 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 General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Mapper; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <memory>

#include <dom/DOM_Attr.hpp>
#include <dom/DOM_DOMException.hpp>
#include <dom/DOM_Element.hpp>
#include <dom/DOM_Document.hpp>
#include <dom/DOM_Node.hpp>

#include <string>

#include "MapDataDocument.h"
#include "MapperErrorHandler.h"
#include "angle_constraint.h"
#include "assoc.h"
#include "constraint.h"
#include "delaunay.h"
#include "vector2.h"
#include "through_constraint.h"



void MapDataDocument::convert_Traced_point(
   map< vector2, vector2 *, order_vector2 > &traced_points, //input, output
   map< vector2, double, order_vector2 > &point_uncertainties, //input, output
   DOM_Element &elem, //input
   const double tracing_width,
   const double tracing_height,
   const double default_uncertainty
   )
   throw(
      error::element_error
      )
{
   {//preconditions:
      assert( 0 < tracing_width );
      assert( 0 < tracing_height );
      assert( 0 < default_uncertainty );
   };
   bool anon;
   string name;
   vector2 position;
   vector2 *point; 
   double uncertainty = default_uncertainty;
   {//retrieve the attribute values
      require_attribute( elem, "tx" );
      require_attribute( elem, "ty" );
      if( has_attribute( elem, "point" ) ){
         anon = false;
         get_attribute( name, elem, "point" );
         this->get_attribute( point, elem, "point" );
      }else{ //anonymous point
         anon = true;
         name = "(anonymous)";
         vector2 global_position( this->random_position() );
         if( has_attribute( elem, "x" ) )
            get_attribute( global_position.x, elem, "x" );
         ;
         if( has_attribute( elem, "y" ) )
            get_attribute( global_position.y, elem, "y" );
         ;
         point = new vector2( global_position );
      };
      get_attribute( position.x, elem, "tx" );
      get_attribute( position.y, elem, "ty" );
      if( has_attribute( elem, "uncertainty" ) ){
         get_attribute( uncertainty, elem, "uncertainty" );
      };
   };
   {//check attribute values
      if( position.x < 0 || tracing_width < position.x )
         throw error::attribute_error( elem, "out of range", "tx" );
      ;
      if( position.y < 0 || tracing_height < position.y )
         throw error::attribute_error( elem, "out of range", "ty" );
      ;
      if( 0 < traced_points.count( position ) )
         throw error::element_error( elem, "position already traced" );
      ;
      if( uncertainty <= 0 )
         throw error::attribute_error( elem, "not positive", "uncertainty" );
      ;
   };
   {//Add the traced point to data structures
      assert( point );
      traced_points[ position ] = point;
      point_uncertainties[ position ] = uncertainty;
      if( anon ){
         this->anon_points_.push_back( point );
      };
      elem.setUserData( point );
   };
}



void MapDataDocument::add_angle_constraint(
   const vector2 &vf, //local coordinates
   const vector2 &va,
   const vector2 &vt,
   vector2 *pf, //points, input
   vector2 *pa,
   vector2 *pt,
   const double uf, //uncertainties
   const double ua,
   const double ut
   )
{
   {//Preconditions
      assert( pf );
      assert( pa );
      assert( pt );
      assert( 0 < uf );
      assert( 0 < ua );
      assert( 0 < ut );
   }
   const double r1c1 = vf.x - va.x;
   const double r1s1 = vf.y - va.y;
   const double r2c2 = vt.x - va.x;
   const double r2s2 = vt.y - va.y;
   const double r1 = hypot( r1c1, r1s1 );
   const double r2 = hypot( r2c2, r2s2 );
   assert( 0 < r1 );
   assert( 0 < r2 );
   const double a1 = atan2( r1s1, r1c1 );
   const double a2 = atan2( r2s2, r2c2 );
   const double angle = a2 - a1;
   const double u1 = (uf + ua)/ r1;
   const double u2 = (ut + ua)/ r2;
   const double uncertainty = u1 + u2;
   angle_constraint *a = new angle_constraint( uncertainty, angle );
   assoc( *a, *pa, *pf, *pt );
   this->constraints_.push_back( a );
}



void MapDataDocument::convert_Tracing(
   DOM_Element &elem,
   MapperErrorHandler &err_handler
   )
   throw(
      error::attribute_error
      )
{
   double length_uncertainty;
   double tracing_height;
   double tracing_width;
   {//process the attributes of the Tracing tag
      {//get attributes
         get_attribute( length_uncertainty, elem, "length-uncertainty" );
         get_attribute( tracing_width, elem, "width" );
         get_attribute( tracing_height, elem, "height" );
      };
      {//check attribute values
         if( length_uncertainty <= 0 )
            throw error::attribute_error(
               elem, "not positive", "length-uncertainty"
               );
         ;
         if( tracing_width <= 0 )
            throw error::attribute_error( elem, "not positive", "width" );
         ;
         if( tracing_height <= 0 )
            throw error::attribute_error( elem, "not positive", "height" );
         ;
      };
   }
   map< vector2, vector2 *, order_vector2 > traced_points;
   map< vector2, double, order_vector2 > point_uncertainties;
   {//process children of the element
      DOM_NodeList children( elem.getChildNodes() );
      for( unsigned i = 0; i < children.getLength(); i++ ){
         DOM_Node node( children.item(i) );
         if( node.getNodeType() != DOM_Node::ELEMENT_NODE ) continue;
         DOM_Element &child( static_cast< DOM_Element & >( node ) );
         DOMString tag( child.getTagName() );
         try{
            if(       DOMString("Cite").equals( tag ) )
               ;//Do nothing
            else if(  DOMString("Traced-point").equals( tag ) )
               this->convert_Traced_point(
                  traced_points, point_uncertainties,
                  child, tracing_width, tracing_height, length_uncertainty
                  );
            else{
               throw error::element_error( child, "unexpected element" );
            };
         }catch( error::element_error &e ){
            err_handler.error( e );
         };
      };
   };
   delaunay::triangulation triangulation(
      -tracing_width, tracing_width*1.1,
      tracing_height*1.1, -tracing_height
      );
   {//create triangulation
      for( map< vector2, vector2 *,order_vector2 >::iterator i =
              traced_points.begin();
           i != traced_points.end();
           i++ ){
         const vector2 &position( (*i).first );
         triangulation.add_point( position );
      };
   };
   {//create constraints
      const vector< delaunay::triangle > &triangles(
         triangulation.triangles()
         );
      for( vector< delaunay::triangle >::const_iterator i = triangles.begin();
           i != triangles.end();
           i++ ){
         const delaunay::triangle &t( *i );
         if( ! triangulation.border_triangle( t ) ){
            //create an angle constraint for each vertex of that triangle
         
            const vector2 &v0( t.vertex(0) );
            const vector2 &v1( t.vertex(1) );
            const vector2 &v2( t.vertex(2) );
            vector2 *p0 = traced_points[ v0 ];
            vector2 *p1 = traced_points[ v1 ];
            vector2 *p2 = traced_points[ v2 ];
            const double u0 = point_uncertainties[ v0 ];
            const double u1 = point_uncertainties[ v1 ];
            const double u2 = point_uncertainties[ v2 ];

            add_angle_constraint(
               v0, v1, v2,
               p0, p1, p2,
               u0, u1, u2
               );
            add_angle_constraint(
               v1, v2, v0,
               p1, p2, p0,
               u1, u2, u0
               );
            add_angle_constraint(
               v2, v0, v1,
               p2, p0, p1,
               u2, u0, u1
               );
         };//else skip that triangle
      };
   };
}

---