---

MapDataDocument_convert_Constraint_group.cpp

//$Header: /home/ben/Mapper/c++/RCS/MapDataDocument_convert_Constraint_group.cpp,v 6.4 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_Element.hpp>

#include <string>

#include "MapDataDocument.h"
#include "MapperErrorHandler.h"
#include "angle_constraint.h"
#include "assoc.h"
#include "bearing_constraint.h"
#include "constraint.h"
#include "distance_constraint.h"
#include "vector2.h"
#include "through_constraint.h"
#include "vector_constraint.h"



inline double degtorad(
   const double d
   )
{
   return d * M_PI/180.0;
};
   
   
   
void MapDataDocument::convert_Angle(
   DOM_Element &elem,
   const double default_uncertainty
   )
   throw(
      error::attribute_error
      )
{
   {//preconditions:
      assert( 0 < default_uncertainty );
   };
   vector2 *at;
   vector2 *from;
   vector2 *to;
   double d;
   double uncertainty = default_uncertainty;
   {//retrieve attribute values
      this->get_attribute( at, elem, "at" );
      this->get_attribute( from, elem, "from" );
      this->get_attribute( to, elem, "to" );
      get_attribute( d, elem, "d" );
      if( has_attribute( elem, "uncertainty" ) ){
         get_attribute( uncertainty, elem, "uncertainty" );
         if( uncertainty <= 0 )
            throw error::attribute_error( elem, "not positive", "uncertainty" );
         ;
      };
   };
   {//convert units
      d = degtorad( d );
      uncertainty = degtorad( uncertainty );
   };
   angle_constraint *a = new angle_constraint( uncertainty, d );
   assert( a ); assert( from ); assert( to );
   assoc( *a, *at, *from, *to );
   this->constraints_.push_back( a );
   elem.setUserData( a );
};
   
   
   
void MapDataDocument::convert_Bearing(
   DOM_Element &elem, //input
   const double default_uncertainty
   )
   throw(
      error::attribute_error
      )
{
   {//preconditions:
      assert( 0 < default_uncertainty );
   };
   vector2 *from;
   vector2 *to;
   double d;
   double uncertainty;
   {//retrieve attribute values
      this->get_attribute( from, elem, "from" );
      this->get_attribute( to, elem, "to" );
      get_attribute( d, elem, "d" );
      if( has_attribute( elem, "uncertainty" ) ){
         get_attribute( uncertainty, elem, "uncertainty" );
         if( uncertainty <= 0 )
            throw error::attribute_error( elem, "not positive", "uncertainty" );
         ;
      }else
         uncertainty = default_uncertainty;
      ;
   };
   {//convert units
      d = degtorad( d );
      uncertainty = degtorad( uncertainty );
   };
   bearing_constraint *b = new bearing_constraint( uncertainty, d );
   assoc( *b, *from, *to );
   this->constraints_.push_back( b );
   elem.setUserData( b );
}
   
   
   
void MapDataDocument::convert_Distance(
   DOM_Element &elem, //input
   const double default_uncertainty_0,
   const double default_uncertainty_1
   )
   throw(
      error::attribute_error
      )
{
   {//preconditions:
      assert( 0 < default_uncertainty_0 );
      assert( 0 <= default_uncertainty_1 );
   };
   vector2 *from;
   vector2 *to;
   double d;
   double uncertainty;
   {//retrieve attribute values
      this->get_attribute( from, elem, "from" );
      this->get_attribute( to, elem, "to" );
      get_attribute( d, elem, "d" );
      if( d <= 0 ) throw error::attribute_error( elem, "not positive", "d" );
      if( has_attribute( elem, "uncertainty" ) ){
         get_attribute( uncertainty, elem, "uncertainty" );
         if( uncertainty <= 0 )
            throw error::attribute_error(
               elem, "not positive", "uncertainty"
               );
         ;
      }else
         uncertainty =
            default_uncertainty_0 + default_uncertainty_1 * d;
      ;
   };
   distance_constraint *c = new distance_constraint( uncertainty, d );
   assoc( *c, *from, *to );
   this->constraints_.push_back( c );
   elem.setUserData( c );
}
   
   
   
void MapDataDocument::convert_Through(
   DOM_Element &elem,
   const double default_uncertainty
   )
   throw(
      error::attribute_error
      )
{
   {//preconditions:
      assert( 0 < default_uncertainty );
   };
   curve *cu;
   vector2 *po;
   double x = 0.0;
   double y = 0.0;
   double uncertainty = default_uncertainty;
   {//retrieve attribute values
      this->get_attribute( cu, elem, "curve" );
      this->get_attribute( po, elem, "point" );
      if( has_attribute( elem, "x" ) )
         get_attribute( x, elem, "x" );
      ;
      if( has_attribute( elem, "y" ) )
         get_attribute( y, elem, "y" );
      ;
      if( has_attribute( elem, "uncertainty" ) ){
         get_attribute( uncertainty, elem, "uncertainty" );
         if( uncertainty <= 0 )
            throw error::attribute_error(
               elem, "not positive", "uncertainty"
               );
         ;
      };
   };
   through_constraint *tc = new through_constraint(
      uncertainty, x, y
      );
   assert( tc && cu && po );
   assoc( *tc, *cu, *po );
   this->constraints_.push_back( tc );
   elem.setUserData( tc );
}
   
   
   
void MapDataDocument::convert_Vector(
   DOM_Element &elem, //input
   const double default_uncertainty_0,
   const double default_uncertainty_1
   )
   throw(
      error::attribute_error
      )
{
   {//preconditions:
      assert( 0 < default_uncertainty_0 );
      assert( 0 <= default_uncertainty_1 );
   };
   vector2 *from;
   vector2 *to;
   double x;
   double y;
   double uncertainty;
   {//retrieve attribute values
      this->get_attribute( from, elem, "from" );
      this->get_attribute( to, elem, "to" );
      get_attribute( x, elem, "x" );
      get_attribute( y, elem, "y" );
      if( has_attribute( elem, "uncertainty" ) ){
         get_attribute( uncertainty, elem, "uncertainty" );
         if( uncertainty <= 0 )
            throw error::attribute_error(
               elem, "not positive", "uncertainty"
               );
         ;
      }else{
         const double d = hypot( x, y );
         uncertainty =
            default_uncertainty_0 + default_uncertainty_1 * d;
      };
   };
   vector_constraint *c = new vector_constraint( uncertainty, x, y );
   assoc( *c, *from, *to );
   this->constraints_.push_back( c );
   elem.setUserData( c );
}
   
   

void MapDataDocument::convert_Constraint_group(
   DOM_Element &elem, //input
   MapperErrorHandler &err_handler
   )
   throw(
      error::attribute_error
      )
{
   double angle_uncertainty;
   double length_uncertainty_0;
   double length_uncertainty_1;
   {//examine attributes
      require_attribute( elem, "length-uncertainty" );
      get_attribute( angle_uncertainty, elem, "angle-uncertainty" );
      const DOMString s( elem.getAttribute(
         DOMString( "length-uncertainty" ) )
         );
      auto_ptr< char > trans( s.transcode() );
      char dummy;
      int n_read = sscanf(
         trans.get(), " %le + %le %% %c",
         &length_uncertainty_0, &length_uncertainty_1, &dummy
         );
      if( n_read == 1 ) //only have constant part
         length_uncertainty_1 = 0.0;
      else if( n_read != 2 )
         throw error::attribute_error(
            elem, "unexpected characters", "length-uncertainty"
            );
      ;
      if( length_uncertainty_0 < 0 || length_uncertainty_1 < 0 )
         throw error::attribute_error(
            elem, "negative value", "length-uncertainty"
            );
      ;
   };
   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("Angle").equals( tag ) )
            this->convert_Angle( child, angle_uncertainty );
         else if(  DOMString("Bearing").equals( tag ) )
            this->convert_Bearing( child, angle_uncertainty );
         else if(  DOMString("Distance").equals( tag ) )
            this->convert_Distance(
               child, length_uncertainty_0, length_uncertainty_1
               );
         else if(  DOMString("Through").equals( tag ) )
            this->convert_Through( child, length_uncertainty_0 );
         else if(  DOMString("Vector").equals( tag ) )
            this->convert_Vector(
               child, length_uncertainty_0, length_uncertainty_1
               );
         else{
            throw error::element_error( child, "unexpected element" );
         };
      }catch( error::element_error &e ){
         err_handler.error( e );
      };
   };
}

---