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 proudu 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";
    }
}