GNU Gama LocalNetworkAdjustmentResults

Třída GNU_Gama::LocalNetwork AdujstmentResults projektu GNU Gama je určena pro pro čtení výsledků vyrovnání programu gama-local ve formátu XML.

Hlavičkový soubor

#include <gnu_gama/xml/localnetwork_adjustment_results.h>

DTD

http://www.gnu.org/software/gama/gama-local-adjustment.dtd

Veřejné členy

LocalNetwork AdujstmentResults()

implicitní konstruktor

void read_xml(std

:istream&) throw(Exception::parser): metoda read() načítá ze vstupního prooudu výsledky vyrovnání programu gama-local ce formátu XML a uloží je do veřejných datových členů třídy LocalNetwork AdujstmentResults

bool gons

typ úhlové míry (400/360)

network_general_parameters

obecné parametry výsledků vyrovnání

   struct
   {
     std::string gama_local_version;
     std::string gama_local_algorithm;
     std::string gama_local_compiler;
     std::string epoch;
     std::string axes_xy;
     std::string angles;
   
   } network_general_parameters;

coordinates_summary

statistika souřadnic bodů

   struct count
   {
     int xyz, xy, z;
   };
   
   struct
   {
     count adjusted;
     count constrained;
     count fixed;
   
   } coordinates_summary;

observations_summary

statistika měření

   struct
   {
     int distances;
     int directions;
     int angles;
     int xyz_coords;
     int h_diffs;
     int z_angles;
     int s_dists;
     int vectors;
   
   } observations_summary;

fixed_points, approximate_points, adjusted_points

seznamy souřadnic pevných, přibližných a vyrovnaných souřadnic bodů

   struct Point
   {
     std::string id;
     double x, y, z;
     
     bool   hxy, hz;             // point has   x, y, z
     bool   cxy, cz;             // constrained x, y, z
     int    indx, indy, indz;    // adjustment indexes
     
     void clear()
     {
       x=y=z=0;
       hxy=hz=cxy=cz=false;
       indx=indy=indz=0;
     }
   };
   
   typedef std::vector<Point> PointList;
   PointList  fixed_points, approximate_points, adjusted_points;

orientations

vyrovnané oriantační posuny

   struct Orientation
   {
     std::string id;
     double      approx;
     double      adj;
     int         index;          // adjustment index
   };
   
   typedef std::vector<Orientation> OrientationList;
   OrientationList orientations;

cov

kovarianční matice vyrovnaných neznámých parametrů (souřadnice a orientační paramatery)

original_index

původní indexy neznámých parametrů ve vyrovnání

   std::vector<int> original_index;

obslist

seznam vyrovnaných měření

    struct Observation
    {
      std::string xml_tag;
      std::string from;
      std::string to;
      std::string left;         // used in angle observation
      std::string right;        //  ....   angle   ....

      double obs;               // observed value
      double adj;               // adjusted
      double stdev;             // standard deviation of adj. value
      double qrr;               // weight coefficient of the residual
      double f;

      double      std_residual; // standardized residual
      std::string err_obs;      // estimate of observed value error
      std::string err_adj;      //  ....       adjusted  ....

      void clear()
      {
        obs = adj = stdev = qrr = f = std_residual = 0;
        xml_tag     .clear();
        from        .clear();
        to          .clear();
        left        .clear();
        right       .clear();
        err_obs     .clear();
        err_adj     .clear();
      }

      double residual() const throw();
    };

    typedef std::vector<Observation> ObservationList;
    ObservationList  obslist;

xml_tag

Hodnoty atributu xml_tag jsou XML značky definované v DTD pro značku <observation>

distance

direction

angle

height-diff

slope-distance

zenith-angle

dx

dy

dz

coordinate-x

coordinate-y

coordinate-z

Číslo stanoviska je vždy uloženo v atrinutu from, číslo cíle obvykle v to s výjimkou měřených úhlů, pro které jsou čísla levého a pravého cíle ukládána v atributech left a right (levá a pravá záměra).

Příklad

Třída GNU_Gama::LocalNetworkAdujstmentResults je použita v programu gama-local-xml2txt pro konverzi XML formátu do textového výstupu výsledků vyrovnání programu gama-local.

typedef GNU_gama::LocalNetworkAdjustmentResults Adjustment;
typedef GNU_gama::OutStream                     OutStream;

int main(int argc, char* argv[])
{
  Adjustment adj;
  OutStream  out(&std::cout);
  set_gama_language(en);

  try
    {
      if (const int k = parameters(argc, argv, adj, out)) return k;

      adj.read_xml(std::cin);

      general_parameters   (out, adj);
      adjusted_parameters  (out, adj);
      adjusted_observations(out, adj);
    }
  catch (GNU_gama::Exception::parser perr)
    {
      std::cerr << "parser error : " << perr.error_code
                << "  line : "       << perr.line
                << "  text : "       << perr.str
                << std::endl;
      return 1;
    }
  catch (...)
    {
      std::cerr << "unknown exception\n";
    }
}