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é orientač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í parametry)

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

• Načtení výstupního souboru formátu XML a výpis některých načtených hodnot

#include <gnu_gama/xml/localnetwork_adjustment_results.h>
#include <gnu_gama/outstream.h>
#include <gamalib/language.h>

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

int main(int argc, char* argv[])
{
	Adjustment adj;
  	try
    	{
      		adj.read_xml(std::cin);
      		
		//gons?
		std::cout << "gons?:" << adj.gons << std::endl;

		//network general parameters
		std::cout << "axes:  " << adj.network_general_parameters.axes_xy << std::endl;
	
        	//description
		std::cout << "descr: " << adj.description << std::endl;
		
                //coordinates_summary
		std::cout << "adjxy: " << adj.coordinates_summary.adjusted.xy << std::endl;
		
                //observations_summary
		std::cout << "dist:  " << adj.observations_summary.distances << std::endl;
		
                //project_equations
		std::cout << "eqn:   " << adj.project_equations.equations << std::endl;
		
                //standard_deviation
		std::cout << "apost?:" << adj.standard_deviation.using_aposteriori << std::endl;
	
		//points
	        for (int i=0, N=adj.fixed_points.size(); i<N; ++i)
        	{
          		const Adjustment::Point& point = adj.fixed_points[i];
			std::cout.width(13);
			std::cout << point.id << ":";
			if (point.hxy)
			{
				std::cout.precision(3);
				std::cout.width(13);
				std::cout << "x=" << point.x;
				std::cout << "  ";
				std::cout.width(13);
				std::cout << "y=" << point.y;
				std::cout << std::endl;
			}
		}

		//covmat
		std::cout << "dim: " << adj.cov.dim() << std::endl;
		std::cout << "band:" << adj.cov.bandWidth() << std::endl;
		int band = adj.cov.bandWidth();
		for (int i=1, N=adj.cov.dim(); i<=N; ++i)
		{
			for(int j=1; j<=N; ++j)
			{
				if (abs(i-j) > band) 
				{
					std::cout.precision(3);
					std::cout.width(10);
					std::cout << 0.0;
				}else{
					std::cout.precision(3);
					std::cout.width(10);
					std::cout << adj.cov(i,j);
				}
			}
			std::cout << std::endl;
		
               //original index
		std::cout << "Original index:";
		for (int i=1, N=adj.original_index.size(); i<N; ++i)
		{
			std::cout << adj.original_index[i] << " ";
		}
		std::cout << std::endl;
		
		//observations
		std::cout << "Observations:" << std::endl;
		for (int i=0, N=adj.obslist.size(); i<N; ++i)
		{
			const Adjustment::Observation& obs = adj.obslist[i];
			std::cout << obs.xml_tag << " : ";
			std::cout << obs.from <<  " : ";
			std::cout << obs.obs << std::endl;
		}
		std::cout << std::endl;

    	} //try
  	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";
    	}
}
}

Překlad zdrojového kódu na linuxu, pokud je knihovna libgama.a umístěna v adresáři /usr/local/lib/gama, knihonva libexpat.a ve standartním adresáři /usr/lib a hlavičkové soubory knihovny v adresáři /usr/local/include/gama

g++ -I/usr/local/include/gama -L/usr/local/lib/gama -o jmeno_programu zdrojovy_kod.cpp -lexpat -lgama