---

MapDataDocument_update.cpp

//$Header: /home/ben/Mapper/c++/RCS/MapDataDocument_update.cpp,v 6.14 2002/07/14 19:17:57 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 <cmath>
#include <cstdio>

#include <dom/DOM_Element.hpp>
#include <dom/DOM_Document.hpp>
#include <dom/DOM_NodeList.hpp>

#include "MapDataDocument.h"
#include "constraint.h"
#include "curve.h"
#include "curve_segment.h"
#include "vector2.h"




void MapDataDocument::set_attribute(
   DOM_Element &elem, //input, output
   const string &attr,
   const double x,
   const unsigned precision
   )
{
   const char format[] = "%0.*f";
   int p = precision; //kludge to workaround printf expectation
   unsigned buflen = 6U + precision;
   char *buffer = new char[buflen];
   while( -1 == snprintf( buffer, buflen, format, p, x ) ){//too long
     //expand buffer
     delete buffer;
     buflen *= 2;
     buffer = new char[buflen];
   };
   elem.setAttribute( DOMString( attr.c_str() ), buffer );
   delete buffer;
}



void MapDataDocument::update_points(
   const DOM_NodeList &nodes, //input, output
   unsigned &n_points, //input, output
   double &left, //input, output
   double &right, //input, output
   double & top, //input, output
   double &bottom //input, output
   )
{
   for( unsigned i = 0; i < nodes.getLength(); i++ ){
      DOM_Node node( nodes.item(i) );
      assert( node.getNodeType() == DOM_Node::ELEMENT_NODE );
      DOM_Element &elem( static_cast< DOM_Element & >( node ) );
      vector2 * p = static_cast< vector2 * >( elem.getUserData() );
      if( p ){
         set_attribute( elem, "x", p->x, this->precision );
         set_attribute( elem, "y", p->y, this->precision );
         if( 0 < n_points ){
            left = min( left, p->x );
            right = max( right, p->x );
            top = max( top, p->y );
            bottom = min( bottom, p->y );
         }else{//first point
            left = p->x;
            right = p->x;
            top = p->y;
            bottom = p->y;
         };
         n_points++;
      }; //else earlier error(s) or no point
   };
};



void MapDataDocument::update_constraints(
   const double tol,
   const DOM_NodeList &nodes //input, output
   )
{
   {//preconditions
      assert( 0 < tol && tol < 1 );
   };
   for( unsigned i = 0; i < nodes.getLength(); i++ ){
      DOM_Node node( nodes.item(i) );
      assert( node.getNodeType() == DOM_Node::ELEMENT_NODE );
      DOM_Element &elem( static_cast< DOM_Element & >( node ) );
      constraint * c = static_cast< constraint * >( elem.getUserData() );
      if( c )
         set_attribute( elem, "e", c->energy( tol ), 2U );
      ;//else earlier error(s)
   };
};
   


void MapDataDocument::update_child_Coord(
   DOM_Document &doc, //input
   DOM_Element &elem, //input
   DOM_Node &child, //input, output
   const vector2 &p
   )
{
   static const DOMString Coord( "Coord" ) ;
   while(
      child.isNull() ||
      child.getNodeType() != DOM_Node::ELEMENT_NODE ||
      !static_cast< DOM_Element & >( child ).getTagName().equals( Coord )
      ){ //not a Coord element
      if( child.isNull() ){
         //create a new child
         DOM_Element n( doc.createElement( Coord ) );
         elem.appendChild( n );
         child = n;
      }else
         child = child.getNextSibling();
      ;
   };
   DOM_Element n( static_cast< DOM_Element & >( child ) );
   set_attribute( n, "x", p.x, this->precision + 3 );
   set_attribute( n, "y", p.y, this->precision + 3 );
   child = child.getNextSibling();
}



void MapDataDocument::update_curve_segments(
   const DOM_NodeList &nodes //input
   )
{
   for( unsigned i = 0; i < nodes.getLength(); i++ ){
      DOM_Node node( nodes.item(i) );
      if( node.getNodeType() != DOM_Node::ELEMENT_NODE )
         continue; //syntax error
      DOM_Element &elem( static_cast< DOM_Element & >( node ) );
      curve_segment *s = static_cast< curve_segment * >(
         elem.getUserData()
         );
      if( !s || !s->along || !s->from || !s->to )
         continue; //conversion error
      double t0, t1; //range of parameter values
      {
         const double tol = 1E-8;
         const unsigned max_iter = 100U;
         unsigned iter; //discarded
         double d20, d21; //discarded
         nearest_point(
            *(s->along),
            *(s->from),
            tol, max_iter,
            t0, d20, iter
            );
         nearest_point(
            *(s->along),
            *(s->to),
            tol, max_iter,
            t1, d21, iter
            );
      };
      unsigned n_spline; //number of splines along the curve
      {
         if( s->along->param.size() <= 2 ) //straight line
            n_spline = 1;
         else{
            n_spline = (unsigned)(
               4.0 * double(s->along->param.size() - 2) *
               fabs( t1 - t0 )
               );
            if( n_spline < 1 ) n_spline = 1;
         };
      };
      const double f = (t1 - t0)/(3.0 * double(n_spline)); //scaling factor
      vector2 p3;
      vector2 dpdt3;
      DOM_Node cnode( elem.getFirstChild() );
      DOM_Document doc( elem.getOwnerDocument() );
      {//update the start point
         s->along->position(
            t0, p3, dpdt3
            );
         update_child_Coord( doc, elem, cnode, p3 );
      };
      for( unsigned spline = 1; spline <= n_spline; spline++ ){
         //update the control points for one spline
         vector2 p0, p1, p2;
         vector2 dpdt0;
         {//determine the control points
            p0 = p3;
            dpdt0 = dpdt3;
            p1 = p0 + f*dpdt0;
            const double t = t0 + (t1-t0) * double(spline)/
               double(n_spline);
            s->along->position(
               t, p3, dpdt3
               );
            p2 = p3 - f*dpdt3;
         };
         update_child_Coord( doc, elem, cnode, p1 );
         update_child_Coord( doc, elem, cnode, p2 );
         update_child_Coord( doc, elem, cnode, p3 );
      };
      {//kill excess Coord children
         while( !cnode.isNull() ){
            if( cnode.getNodeType() != DOM_Node::ELEMENT_NODE )
               cnode = cnode.getNextSibling();
            else{
               DOM_Element child( static_cast< DOM_Element & >(
                  cnode )       );
               if( child.getTagName().equals( DOMString( "Coord" ) ) ){
                  cnode = cnode.getNextSibling();
                  elem.removeChild( child );
               }else
                  cnode = cnode.getNextSibling();
               ;
            };
         };
      };
   };
}



void MapDataDocument::update(
   const double tol
   )
{
   {//preconditions
      assert( 0 < tol && tol < 1 );
   };
   DOM_Element root( this->doc.getDocumentElement() );
   unsigned n_points = 0;
   double left;
   double right;
   double top;
   double bottom;
   update_points(
      root.getElementsByTagName( DOMString("Point" ) ),
      n_points, left, right, top, bottom
      );
   update_points(
      root.getElementsByTagName( DOMString("Node" ) ),
      n_points, left, right, top, bottom
      );
   update_points(
      root.getElementsByTagName( DOMString("Line-segment" ) ),
      n_points, left, right, top, bottom
      );
   update_points(
      root.getElementsByTagName( DOMString("Traced-point" ) ),
      n_points, left, right, top, bottom
      );
   {
      DOM_NodeList nodes( root.getElementsByTagName( DOMString("Curve" ) ) );
      for( unsigned i = 0; i < nodes.getLength(); i++ ){
         DOM_Node node( nodes.item(i) );
         if( node.getNodeType() != DOM_Node::ELEMENT_NODE )
            break; //syntax error
         DOM_Element &elem( static_cast< DOM_Element & >( node ) );
         update_points(
            elem.getElementsByTagName( DOMString("Coord" ) ),
            n_points, left, right, top, bottom
            );
      };
   };
   if( 0 < n_points ){//update the attributes of the root tag
      assert( left <= right );
      assert( bottom <= top );
      set_attribute( root, "x", left, this->precision );
      set_attribute( root, "y", top, this->precision );
      set_attribute( root, "width", right - left, this->precision );
      set_attribute( root, "height", top - bottom, this->precision );
   };
   update_constraints(
      tol,
      root.getElementsByTagName( DOMString("Angle" ) )
      );
   update_constraints(
      tol,
      root.getElementsByTagName( DOMString("Bearing" ) )
      );
   update_constraints(
      tol,
      root.getElementsByTagName( DOMString("Distance" ) )
      );
   update_constraints(
      tol,
      root.getElementsByTagName( DOMString("Through" ) )
      );
   update_constraints(
      tol,
      root.getElementsByTagName( DOMString("Vector" ) )
      );
   update_curve_segments(
      root.getElementsByTagName( DOMString("Curve-segment" ) )
      );
}

---