Lustiges Programmieren mit Hypo (Teil n-1)

Hypothraxer

Es ist mal wieder soweit: Ich habe mich entschieden, wieder mal ein wenig zu programmieren (oh was für ein Fehler...). Und natürlich gibt's jetzt schon Probleme

Es darf gelacht werden.

In einem ersten Schritt, soll ein Textfile, das aus Photomodeler exportiert wurde, umformatiert werden, so dass nur die Kameraparameter und die Bildnamen stehen bleiben. Das funktioniert soweit so gut - bist auf das extrahieren des Bildnamens. Mit dem untenstehenden Code gibt es nämlich folgenden Fehler:

terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::substr

Die Idee wäre es, nur den Pfad zu erhalten (also z.B. D:\zeug\Schule\8. Semester\Close-Range Photogrammetry\kirche\DSC00961.JPG) - momentan steht eben auf der Zeile noch eine Ziffer vor dem Pfad, die ich nicht brauche.

Das Programm lässt sich kompilieren (mit g++ unter Fedora 7 aus der Eclipse IDE heraus) und startet auch, nur gibt's dann eben den oben genannten Fehler. Hat jemand Tipps?

Code:

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <math.h>
#include <iomanip.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>
#define MaxDigits 24
using namespace std;

/* Definition of the variables of the interior and exterior orientaion parameters
 as well as the additional parameters */

struct Variablen
{
   // Imagenames
   string imname;
   // Numbering
   double imnr; double ptnr;
    // E.O.
   double omega; double phi; double kappa; double X0; double Y0; double Z0;
   // I.O.
    double xo; double yo; double zo;
    // A.P's.
    double k1; double k2; double k3; double p1; double p2; double a; double s;
    // Measurements
    
    
}
vars;

int main()

{
   fstream parameters;
   parameters.open("parameters.txt", ios::out);
   parameters << setprecision(8);
   fstream input;
   input.open("photo.txt", ios::in);
   input << setprecision(8);
   parameters << "--== Parameter File ==-- \n";
   string tempname;
   size_t pos;
   int i = 0;
   double imnrminus = -1;
   while (!input.eof())
         {
         while (i <= 4)
                {
               getline(input, tempname);
               i++;
                }

         getline(input, tempname);
         //cout << tempname;
         pos = tempname.find('D');
         vars.imname = tempname.substr(pos);
         input >> vars.imnr;
         input >> vars.X0;
         input >> vars.Y0;
         input >> vars.Z0;
         input >> vars.kappa;
         input >> vars.phi;
         input >> vars.omega;
         if (vars.imnr > imnrminus)
            {
            parameters << vars.imname << " " << vars.imnr << " " << vars.X0 << " " << vars.Y0 << " " << vars.Z0 << " " << vars.omega << " " << vars.phi << " " << vars.kappa << "\n";
            i = 0;
            imnrminus = vars.imnr;
            }
         else
            {
            parameters.close();
            input.close();
            }
         }
   
}    

Hypothraxer · **Posted:** 02.10.2007 08:11 **Post subject:**

Hier noch ein Beispielfile, das eingelesen wird (für alle, die das mal laufen lassen wollen):

Code:

Bundle Soln 
 0.005000 20
 1.00000  0.10000 10.00000 100.00000 100.00000 100.00000 20.00000 20.00000 20.00000
 9.0000  3.0000  2.2500 6.00000 4.50000 0.00000 0.00000 0.00000 0.00000 0.00000
 0.10000  0.00600  0.00450 0.500000 0.500000 0.001000 0.000100 0.000100 0.001000 0.001000
   0 D:\zeug\Schule\8. Semester\Close-Range Photogrammetry\kirche\DSC00961.JPG
   0    0.051   -0.010    0.029    0.233    0.456    0.090
   0   1.0000   1.0000   1.0000   2.0000   2.0000   2.0000

   0   5.700   2.880   2.145 5.76000 4.29000 0.00000 0.00000 0.00000 0.00000 0.00000
   0  0.10000  0.00576  0.00429 0.500000 0.500000 0.001000 0.000100 0.000100 0.001000 0.001000
   1 D:\zeug\Schule\8. Semester\Close-Range Photogrammetry\kirche\DSC00962.JPG
   1    0.002   -1.298   -0.154    0.169   -0.174   14.829
   1   1.0000   1.0000   1.0000   2.0000   2.0000   2.0000

   1   5.700   2.880   2.145 5.76000 4.29000 0.00000 0.00000 0.00000 0.00000 0.00000
   1  0.10000  0.00576  0.00429 0.500000 0.500000 0.001000 0.000100 0.000100 0.001000 0.001000
   2 D:\zeug\Schule\8. Semester\Close-Range Photogrammetry\kirche\DSC00963.JPG
   2   -0.054   -2.657   -0.892    0.149   -1.175   29.081
   2   1.0000   1.0000   1.0000   2.0000   2.0000   2.0000

   2   5.700   2.880   2.145 5.76000 4.29000 0.00000 0.00000 0.00000 0.00000 0.00000
   2  0.10000  0.00576  0.00429 0.500000 0.500000 0.001000 0.000100 0.000100 0.001000 0.001000


       1    0.71437    0.27820   -6.69035   0.002003   0.002813   0.009002
       2   -0.17102   -1.79700   -5.40965   0.002432   0.002884   0.007356
       3   -0.02691   -0.08119   -6.78864   0.001652   0.002526   0.009214
       4    0.05849    0.93013   -6.24781   0.001533   0.003288   0.007922
       5    0.45366    1.45012   -4.58297   0.002179   0.004338   0.005073
       6   -0.22848    1.09201   -5.94691   0.001505   0.003346   0.007133
       7   -0.15280    1.08079   -5.94672   0.001485   0.003335   0.007131
      10   -1.08806    0.70237   -6.57472   0.003964   0.004403   0.019192
      11    0.47901   -0.11847   -6.75040   0.001791   0.002452   0.008991
      12    0.48335    0.40738   -6.67019   0.001846   0.002960   0.009063
      13   -0.52337    0.36664   -6.96850   0.002020   0.003208   0.010429
      17    0.32967   -1.03821   -6.51098   0.001521   0.001820   0.007753
      20    1.28678    1.42997   -4.53375   0.002819   0.004231   0.004921
      21    0.66248    1.45953   -4.55928   0.002280   0.004324   0.004993
      22   -1.17226    1.44728   -4.64546   0.003114   0.004466   0.005489
      23   -0.45021   -0.37149   -6.78000   0.001701   0.002246   0.008980
      24   -0.59314   -0.52309   -6.74592   0.001745   0.002104   0.008753
      25    1.71277    0.47087   -6.55380   0.003019   0.002811   0.008304
      26    1.59963   -0.70535   -6.59597   0.002650   0.001933   0.007782
      27   -1.89390    0.52801   -6.47112   0.003065   0.002801   0.008009
      28   -1.20728   -0.86463   -6.61698   0.002186   0.001835   0.008066
      29    0.53540   -1.72077   -5.36309   0.002452   0.002912   0.007588
      30   -0.76095   -1.49554   -5.38147   0.002758   0.002608   0.007940
      31   -2.22522   -0.12201   -6.36057   0.003432   0.002089   0.007509
      32    1.30675    1.06353   -5.91132   0.002308   0.003184   0.006823
      33   -1.48217    0.88412   -6.35306   0.002581   0.003198   0.007988

   0        1 1707.0194  941.0000  1.00000  1.00000
   0        2 1312.6877 1982.1688  1.00000  1.00000
   0        3 1398.7554 1089.4432  1.00000  1.00000
   0        4 1435.5496  640.2500  1.00000  1.00000
   0        5 1677.3184  173.1250  1.00000  1.00000
   0        6 1302.1768  542.8604  1.00000  1.00000
   0        7 1337.9298  548.3782  1.00000  1.00000
   0       10  951.4952  756.1250  1.00000  1.00000
   0       11 1606.5133 1105.7500  1.00000  1.00000
   0       12 1611.4770  886.2500  1.00000  1.00000
   0       13 1202.2155  908.5390  1.00000  1.00000
   0       17 1548.0847 1502.1104  1.00000  1.00000
   0       20 2188.5000  176.5000  1.00000  1.00000
   0       21 1805.3971  162.7500  1.00000  1.00000
   0       22  707.4334  185.5000  1.00000  1.00000
   0       23 1224.4843 1208.5162  1.00000  1.00000
   0       24 1164.4286 1271.2857  1.00000  1.00000
   0       25 2136.0048  857.7500  1.00000  1.00000
   0       26 2084.3293 1358.0000  1.00000  1.00000
   0       27  598.1719  825.3880  1.00000  1.00000
   0       28  899.7458 1418.4026  1.00000  1.00000
   0       29 1678.9286 1952.5114  1.00000  1.00000
   0       30 1007.4697 1827.5000  1.00000  1.00000
   0       31  437.5000 1105.0000  1.00000  1.00000
   0       32 2021.5545  554.9042  1.00000  1.00000
   0       33  764.1768  665.1266  1.00000  1.00000
   1        1 1693.7300 1119.5260  1.00000  1.00000
   1        2 1299.2034 2091.5000  1.00000  1.00000
   1        3 1386.7470 1274.1055  1.00000  1.00000
   1        4 1424.0944  798.0000  1.00000  1.00000
   1        5 1654.5738  199.0000  1.00000  1.00000
   1        6 1297.6489  681.5422  1.00000  1.00000
   1        7 1331.3971  686.0568  1.00000  1.00000
   1       10  947.3898  933.5227  1.00000  1.00000
   1       11 1597.0690 1287.5032  1.00000  1.00000
   1       12 1597.8765 1064.7127  1.00000  1.00000
   1       13 1190.8402 1109.5000  1.00000  1.00000
   1       17 1543.5000 1678.5000  1.00000  1.00000
   1       20 2127.9153  195.7500  1.00000  1.00000
   1       21 1772.4213  187.7500  1.00000  1.00000
   1       22  752.0291  215.2500  1.00000  1.00000
   1       23 1209.5182 1393.6640  1.00000  1.00000
   1       24 1145.9092 1456.8701  1.00000  1.00000
   1       25 2115.1816 1028.0000  1.00000  1.00000
   1       26 2092.8741 1531.8198  1.00000  1.00000
   1       27  597.0981  990.2532  1.00000  1.00000
   1       28  869.1574 1600.5000  1.00000  1.00000
   1       29 1696.1223 2049.4692  1.00000  1.00000
   1       30  973.1840 1914.7451  1.00000  1.00000
   1       31  414.4286 1255.5714  1.00000  1.00000
   1       32 1988.3644  689.8750  1.00000  1.00000
   1       33  768.8499  830.4870  1.00000  1.00000
   2       22  759.3293  113.4594  1.00000  1.00000
   2        5 1623.5472   94.1786  1.00000  1.00000
   2       21 1736.3547   81.4838  1.00000  1.00000
   2       20 2073.6901   85.2500  1.00000  1.00000
   2       12 1579.5303 1112.5000  1.00000  1.00000
   2        1 1679.5012 1165.8961  1.00000  1.00000
   2       11 1583.9564 1333.7500  1.00000  1.00000
   2        3 1361.6586 1325.3653  1.00000  1.00000
   2       13 1157.0448 1184.4399  1.00000  1.00000
   2        4 1400.5000  824.0000  1.00000  1.00000
   2        7 1306.6683  691.5227  1.00000  1.00000
   2        6 1273.2542  687.1753  1.00000  1.00000
   2       17 1537.0508 1703.9123  1.00000  1.00000
   2        2 1273.7240 1984.7500  1.00000  1.00000
   2       23 1172.5012 1443.8669  1.00000  1.00000
   2       24 1105.1162 1503.0682  1.00000  1.00000
   2       25 2109.8571 1065.8571  1.00000  1.00000
   2       26 2122.3039 1559.4919  1.00000  1.00000
   2       27  547.2554 1022.4513  1.00000  1.00000
   2       28  800.2990 1637.8799  1.00000  1.00000
   2       29 1724.7700 1926.1055  1.00000  1.00000
   2       30  908.7143 1786.4286  1.00000  1.00000
   2       31  336.7312 1261.2808  1.00000  1.00000
   2       32 1963.3051  691.5455  1.00000  1.00000
   2       33  734.5872  863.0211  1.00000  1.00000

   1    1        1 
   2    1        2 
   3    1        3 
   4    1        4 
   5    1        5 
   6    1        6 
   7    1        7 
   8    1       10 
   9    1       11 
  10    1       12 
  11    1       13 
  12    1       17 
  13    1       20 
  14    1       21 
  15    1       22 
  16    1       23 
  17    1       24 
  18    1       25 
  19    1       26 
  20    1       27 
  21    1       28 
  22    1       29 
  23    1       30 
  24    1       31 
  25    1       32 
  26    1       33 

   0    1
   0    2
   0    3
   0    4
   0    5
   0    6
   0    7
   0    8
   0    9
   0   10
   0   11
   0   12
   0   13
   0   14
   0   15
   0   16
   0   17
   0   18
   0   19
   0   20
   0   21
   0   22
   0   23
   0   24
   0   25
   0   26
   1    1
   1    2
   1    3
   1    4
   1    5
   1    6
   1    7
   1    8
   1    9
   1   10
   1   11
   1   12
   1   13
   1   14
   1   15
   1   16
   1   17
   1   18
   1   19
   1   20
   1   21
   1   22
   1   23
   1   24
   1   25
   1   26
   2    1
   2    2
   2    3
   2    4
   2    5
   2    6
   2    7
   2    9
   2   10
   2   11
   2   12
   2   13
   2   14
   2   15
   2   16
   2   17
   2   18
   2   19
   2   20
   2   21
   2   22
   2   23
   2   24
   2   25
   2   26

Hypothraxer · **Posted:** 02.10.2007 14:00 **Post subject:**

Ich hab das Problem gelöst. Scheinbar schmeckten dem Programm die Leerzeilen nach den Kameraparametern nicht so (das suchen in einem leeren String hat ihn wohl verwirrt?). Ich habe es jetzt mal umgeschrieben - und es funktioniert soweit. Die letzte Frage dürfte das aber nicht gewesen sein

Code:

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <math.h>
#include <iomanip.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#define MaxDigits 24
using namespace std;

/* Definition of the variables of the interior and exterior orientation parameters
 as well as the additional parameters */

struct Variablen
{
   // Imagenames
   string imname;
   // Numbering
   double imnr; double ptnr;
    // E.O.
   double omega; double phi; double kappa; double X0; double Y0; double Z0;
   // I.O.
    double xo; double yo; double zo;
    // A.P's.
    double k1; double k2; double k3; double p1; double p2; double a; double s;
    // Measurements
    
    
}
vars;

int main()

{
   fstream parameters;
   parameters.open("parameters.txt", ios::out);
   parameters << setprecision(8);
   fstream input;
   input.open("photo.txt", ios::in);
   input << setprecision(8);
   parameters << "--== Parameter File ==-- \n";
   string tempname;
   int headerignore = 0;
   double imnrminus = -1;
   while (imnrminus != -2)
         {
         while (headerignore <= 4)
                         {
                        getline(input, tempname);
                        headerignore++;
                         }
         getline(input, tempname);
         input >> vars.imnr;
         input >> vars.X0;
         input >> vars.Y0;
         input >> vars.Z0;
         input >> vars.kappa;
         input >> vars.phi;
         input >> vars.omega;
         if (vars.imnr > imnrminus)
            {
            vars.imname = tempname.substr(5);
            parameters << vars.imname << "\n" << vars.imnr << " " << vars.X0 << " " << vars.Y0 << " " << vars.Z0 << " " << vars.omega << " " << vars.phi << " " << vars.kappa << "\n";
            headerignore = 0;
            imnrminus = vars.imnr;
            }
         else
            {
            imnrminus = -2;
            }
         }
   
   parameters.close();
   input.close();
}

Hypothraxer · **Posted:** 03.10.2007 16:32 **Post subject:**

Nach etwas umschreiben, liest das Ding nun ein Photomodeler Export File aus und schreibt die Kameraparameter in ein XML-File rein. Schauerlich programmiert

Code:

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <math.h>
#include <iomanip.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#define MaxDigits 24
using namespace std;

#if defined(LIBXML_TREE_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)

/* Definition of the variables of the interior and exterior orientation parameters
 as well as the additional parameters */

struct Variables
{
        // Images
        string imname; int imnr; double w; double h;
    // E.O.
        double omega; double phi; double kappa; double X0; double Y0; double Z0;
        // I.O.
    double xh; double yh; double c;
    // A.P's.
    double k1; double k2; double k3; double p1; double p2; double a; double s;
    // Measurements
   
   
}
vars;


int main(int argc, char **argv)

{
        // XML
        xmlDocPtr doc = NULL;       /* document pointer */
        xmlNodePtr root_node = NULL, node = NULL, node1 = NULL;/* node pointers */
        xmlDtdPtr dtd = NULL;       /* DTD pointer */
        LIBXML_TEST_VERSION;
       
    /*
    * Creates a new document, a node and set it as a root node
    */
    doc = xmlNewDoc(BAD_CAST "1.0");
    root_node = xmlNewNode(NULL, BAD_CAST "root");
    xmlDocSetRootElement(doc, root_node);
   
    /*
    * Creates a DTD declaration. Isn't mandatory.
    */
    dtd = xmlCreateIntSubset(doc, BAD_CAST "root", NULL, BAD_CAST "tree2.dtd");
           
           
    // Stream Input
   
        fstream parameters;
        parameters.open("parameters.txt", ios::out);
        parameters << setprecision(8);
        fstream input;
        input.open("photo.txt", ios::in);
        input << setprecision(8);
        parameters << "--== Parameter File ==-- \n";
        string tempname;
        char buffer[128];
        string file = "test.xml";
        int headerignore = 0, dummy = 0, imnrminus = -1;
        while (imnrminus != -2)
                        {
                        while (headerignore <= 4)
                                                        {
                                                                getline(input, tempname);
                                                                headerignore++;
                                                        }
                        getline(input, vars.imname);
                        input >> vars.imnr;
                        input >> vars.X0;
                        input >> vars.Y0;
                        input >> vars.Z0;
                        input >> vars.kappa;
                        input >> vars.phi;
                        input >> vars.omega;
                        getline(input, tempname);
                        getline(input, tempname);
                        input >> dummy;
                        input >> vars.c;
                        input >> vars.xh;
                        input >> vars.yh;
                        input >> vars.w;
                        input >> vars.h;
                        input >> vars.k1;
                        input >> vars.k2;
                        input >> vars.k3;
                        input >> vars.p1;
                        input >> vars.p2;
                       
                        if (vars.imnr > imnrminus)
                                {
                                vars.imname = vars.imname.substr(5);
                                parameters << vars.imname << "\n"
                                << vars.imnr << " " << vars.X0 << " " << vars.Y0 << " " << vars.Z0 << " " << vars.omega << " " << vars.phi << " " << vars.kappa << "\n"
                                << vars.c << " " << vars.xh << " " << vars.yh << " " << vars.w << " " << vars.h << " " << vars.k1 << " " << vars.k2 << " " << vars.k3 << " " << vars.p1 << " " << vars.p2 << "\n";
                               
                                                        // Building XML Tree
                                                        // Build first node to make the different images distinguishable
                                                        node = xmlNewChild(root_node, NULL, BAD_CAST "Image",
                                                        BAD_CAST NULL);
                                                       
                                                        // Include Image Number, Path and size
                                                        // Might produce memory leaks - check c_str() further
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Pfad",
                                                        BAD_CAST vars.imname.c_str());
                                                        sprintf(buffer,"%d",vars.imnr);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Imagenumber",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.w);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Width",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.h);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Height",
                                                        BAD_CAST buffer);
                                                       
                                                        // Include I.O.
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Interior_Orientation",
                                                        BAD_CAST NULL);
                                                        sprintf(buffer,"%f",vars.c);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "c",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.xh);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "xh",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.yh);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "yh",
                                                        BAD_CAST buffer);
                                                       
                                                        // Include E.0.
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Exterior_Orientation",
                                                        BAD_CAST NULL);
                                                        sprintf(buffer,"%f",vars.X0);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "X0",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.Y0);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Y0",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.Z0);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Z0",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.omega);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Omega",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.phi);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Phi",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.kappa);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Kappa",
                                                        BAD_CAST buffer);
                                                       
                                                        // Include A.P's.
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "Additional_Parameters",
                                                        BAD_CAST NULL);
                                                        sprintf(buffer,"%f",vars.k1);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "K1",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.k2);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "K2",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.k3);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "K3",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.p1);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "P1",
                                                        BAD_CAST buffer);
                                                        sprintf(buffer,"%f",vars.p2);
                                                        node1 = xmlNewChild(node, NULL, BAD_CAST "P2",
                                                        BAD_CAST buffer);
                               
                                headerignore = 3;
                                imnrminus = vars.imnr;
                                }
                        else
                                {
                                imnrminus = -2;
                                }
                        }
       
        parameters.close();
        input.close();

            /*
             * Dumping document to stdio or file
             */
                xmlSaveFormatFileEnc(file.c_str(), doc, "UTF-8", 1);
               
            /*
             * Save to a file
             */
           
            //xmlSaveFormatFile("xml", xmlDocPtr cur, 1);
           
            /*free the document */
            xmlFreeDoc(doc);

            /*
             *Free the global variables that may
             *have been allocated by the parser.
             */
            xmlCleanupParser();

            /*
             * this is to debug memory for regression tests
             */
            xmlMemoryDump();
            return(0);
}
#else
int main(void) {
    fprintf(stderr, "tree support not compiled in\n");
    exit(1);
}
#endif

Hypothraxer · **Posted:** 08.10.2007 16:30 **Post subject:**

Nächstes Problem: Ich habe ein File, in dem pro Zeile ein Punkt definiert wird (X,Y,Z Koordinate). Dies soll nun in einen mehrdimensionalen Array gepackt werden (pro Punkt eine Zeile - pro Zeile drei Zellen (X,Y,Z)). Da ich von vornherein nicht weiss, wie gross das File ist, muss ich das wohl einen Teil des Arrays dynamisch anpassen. Ich habe es geschafft, einen eindimensionalen Array dynamisch anzupassen - aber bei zwei Dimensionen versagt es bei mir komplett.

Um konkrete Tipps wäre ich froh - ich bin kurz davor, den Array statisch zu definieren, indem ich das File durchgehe, und die Zeilen zähle...

Code:

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <math.h>
#include <iomanip.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#define MaxDigits 24
using namespace std;

/* Definition of the variables of the interior and exterior orientation parameters
 as well as the additional parameters */

struct Variables {
   

} vars;

int main()

{
   // Stream Input
   fstream sampled;
   sampled.open("sampled.xyz", ios::out); // Define sampled output file
   sampled << setprecision(16);
   fstream pointcloud;
   pointcloud.open("pointcloud.xyz", ios::in); // Define pointcloud input file
   pointcloud << setprecision(16);
   int linecount = 0;
   string temporary;
   int max = 250000;
   double *rows = new double [max];
   //rows[0] = new int[3];
   rows = (double *)calloc(max, sizeof(double));
   if(NULL == rows)
   {
      printf("Not enough memory\n");
      exit(0);
   }
   while (linecount != 2) {
      getline(pointcloud, temporary);
      linecount++;
   }
   linecount = 1;
   while (!pointcloud.eof()) {
      if (linecount > max - 2)
      {
         max = max + 250000;
         rows = (double *)realloc(rows,max*sizeof(double));
         if(NULL == rows)
         {
            printf("Not enough memory\n");
            exit(1);
         }
         printf("Speicherplatz reserviert "
                          " (%d Bytes)\n",sizeof(double)*max);
         }
         
      pointcloud >> rows[linecount];
      sampled << rows[linecount];
      pointcloud >> rows[linecount];
      sampled << rows[linecount];
      pointcloud >> rows[linecount];
      sampled << rows[linecount] << "\n";
      /*
      cout << pcheap[linecount][1] << "\n";
      cout << pcheap[linecount][2] << "\n";
      cout << pcheap[linecount][3] << "\n";
      cout << linecount << "\n";
      */
      linecount++;
   }
   //free(rows);
   // Define the grid according to the extents of the pointcloud


   sampled.close();
   pointcloud.close();
   
}

thewulf · **Posted:** 08.10.2007 17:23 **Post subject:**

Vorschlag Nummer 1:
Gehe zuerst das File durch und zähle die Zeilen (im Code, nicht manuell

). Dann erst leg das Array an und lies die Daten ein. Somit ersparst du dir das Resizen.

Vorschlag Nummer 2:
Wenn ich mich nicht verlesen habe, legst du hier nie ein zweidimensionales Array an. Außerdem solltest du "new/delete" und "malloc/free" nie vermischen. Entweder - oder.

Möglichkeit eins (calloc):

Code:

double *rows = calloc(nNumRows * 3, sizeof(double));
...
free(rows);

Möglichkeit zwei (new) - sauberer:

Code:

double **rows = new double[nNumRows];
for (int i=0; i < nNumRows; i++)
    rows[i] = new double[3];
...
for (int i=0; i < nNumRows; i++)
    delete []rows[i];

delete []rows;

Möglichkeit drei (new) - mit Structs:

Code:

struct TCoordinates
{
    double x;
    double y;
    double z;

    TCoordinates()
    {
        x = y = z = 0.0;
    }
};

TCoordinates *rows = new TCoordinates[nNumRows];
...
delete []rows;

Letztere Methode ist die meiner Meinung nach die schönste und sauberste

Hypothraxer · **Posted:** 08.10.2007 18:16 **Post subject:**

thewulf wrote:

Vorschlag Nummer 1:
Gehe zuerst das File durch und zähle die Zeilen (im Code, nicht manuell

). Dann erst leg das Array an und lies die Daten ein. Somit ersparst du dir das Resizen.

Jo - ich gewöhn mich immer mehr daran, es so zu machen. Da gibt es momentan noch ein Problem, aber ich glaube das liegt mittlerweile an der Uhrzeit. Ich werde mal sehen, ob das morgen geht...

thewulf wrote:

Vorschlag Nummer 2:
Wenn ich mich nicht verlesen habe, legst du hier nie ein zweidimensionales Array an. Außerdem solltest du "new/delete" und "malloc/free" nie vermischen. Entweder - oder.

Ja genau - weil ich es nicht geschafft habe, das Ganze in ein zweidimensionales Array zu konvertieren

An sich sollte es aber eines sein (in den "Spalten" die Koordinaten und in den "Zeilen" die jeweiligen Punkte). Aber eben - sehr wahrscheinlich lese ich mir einfach nur die Zeilen raus - ich drehe langsam durch

Trotzdem vielen Dank für die Hilfe!

Edit: Es sieht so aus, als fällt die Zeilen-Zähl-Methode weg. Grund: Segementation Fault :b (Vermutung: Er mag es nicht, dass man einem Array so viel Speicher zur Verfügung stellt?). Interessanterweise gibt es keinen Segementation-Fault, wenn ich das File in einen eindimensionalen Array einlese wie oben. Woran kann das liegen? Das File beinhaltet im übrigen ~1.2 Millionen Punkte (also ~3.6 Millionen Koordinaten).

Daniel · **Joined:** 18.10.2004 13:48 **Posts:** 757

Hypothraxer wrote:

Interessanterweise gibt es keinen Segementation-Fault, wenn ich das File in einen eindimensionalen Array einlese wie oben. Woran kann das liegen? Das File beinhaltet im übrigen ~1.2 Millionen Punkte (also ~3.6 Millionen Koordinaten).

Das liegt daran, daß die Speicherverwaltung in größeren Blöcken arbeitet. Obwohl du nur 24 Bytes pro Punkt anforderst, werden gleich 4 KiB bereitgestellt, bei 1.2 Millionen Punkten sprengst du damit den Adressraum bei 32 Bit Betriebssystemen.

Da jeder Punkt wohl gleich aussehen wird, ist der dritte Vorschlag mit der Struktur eindeutig der beste.

Edit: der dritte ist nicht der beste, sondern der einzig wahre.

Hypothraxer · **Posted:** 08.10.2007 20:57 **Post subject:**

Daniel wrote:

Das liegt daran, daß die Speicherverwaltung in größeren Blöcken arbeitet. Obwohl du nur 24 Bytes pro Punkt anforderst, werden gleich 4 KiB bereitgestellt, bei 1.2 Millionen Punkten sprengst du damit den Adressraum bei 32 Bit Betriebssystemen.

Da jeder Punkt wohl gleich aussehen wird, ist der dritte Vorschlag mit der Struktur eindeutig der beste.

Edit: der dritte ist nicht der beste, sondern der einzig wahre.

Wenn ich das also richtig verstehe, dann ist dies mit einer statischen Zuweisung eines Arrays gar nicht möglich ist, sondern nur via Pointer? Ich werd mir in dem Fall morgen die Variante drei nochmal ansehen (huiui).

thewulf · **Posted:** 08.10.2007 23:26 **Post subject:**

Hypothraxer wrote:

An sich sollte es aber eines sein (in den "Spalten" die Koordinaten und in den "Zeilen" die jeweiligen Punkte). Aber eben - sehr wahrscheinlich lese ich mir einfach nur die Zeilen raus - ich drehe langsam durch

Steht denn in rows[linecount] immer der richtige Wert drin, wenn du von pointcloud einliest? Was ist denn als Trenner für die Koordinaten definiert? Selbst wenn alles richtig eingelesen würde, schreibst du bei

Code:

      pointcloud >> rows[linecount];
      sampled << rows[linecount];
      pointcloud >> rows[linecount];
      sampled << rows[linecount];
      pointcloud >> rows[linecount];

dreimal in den selben Index des Arrays. Das macht für das Zielfile jetzt nichts aus, schließlich schreibst du den Wert ohnehin gleich nach dem Einlesen wieder hinaus. Aber falls du nachher rows noch für irgendwas verwenden willst, wirst du wohl nicht die richtigen Daten zur Verfügung haben. Falls du rows nicht mehr brauchst, ist das Array sowieso unnötig.

Weil ichs grad sehe: Die Arrayindizierung muss bei 0 beginnen!

Hypothraxer · **Posted:** 09.10.2007 08:28 **Post subject:**

thewulf wrote:

Steht denn in rows[linecount] immer der richtige Wert drin, wenn du von pointcloud einliest? Was ist denn als Trenner für die Koordinaten definiert?

Der Trenner ist einfach ein Leerzeichen. So sehen die ersten paar Zeilen aus (das Ganze ist 37 MiB gross

):

Code:

# Geomagic Studio
# New Model
3556868 -0.1247339 -0.9005797
3558227 -0.1247327 -0.9000115
3556147 -0.1247623 -0.9000360
3550872 -0.1248465 -0.8998497
3551547 -0.1246499 -0.8996143
3554379 -0.1246179 -0.8993223

Eingelesen wird immer richtig, weil es ein Stream ist (liest die Dinger einfach sequentiell aus und das File ändert sich ja nicht, bis auf die ersten zwei Zeilen, die ich aber ignoriere).

thewulf wrote:

Selbst wenn alles richtig eingelesen würde, schreibst du bei

Code:

      pointcloud >> rows[linecount];
      sampled << rows[linecount];
      pointcloud >> rows[linecount];
      sampled << rows[linecount];
      pointcloud >> rows[linecount];

dreimal in den selben Index des Arrays. Das macht für das Zielfile jetzt nichts aus, schließlich schreibst du den Wert ohnehin gleich nach dem Einlesen wieder hinaus. Aber falls du nachher rows noch für irgendwas verwenden willst, wirst du wohl nicht die richtigen Daten zur Verfügung haben. Falls du rows nicht mehr brauchst, ist das Array sowieso unnötig.

Jo - das ist ein Fehler. Jeder Wert sollte in einen neuen Array-index gespeichert werden. Das ist wohl noch eine alte Code-Version (oder aber ich habs schlicht verpennt :/ ).

thewulf wrote:

Weil ichs grad sehe: Die Arrayindizierung muss bei 0 beginnen!

Jup - auch das ein Fehler (siehe "verpennt")

Ich probiere jetzt mal die Struct-Variante.

Edit: Was mich bei der Struct-Variante interessiert: Ich muss ja die nNumRows ja kennen (hier:

Code:

TCoordinates *rows = new TCoordinates[nNumRows];

Die kenn ich aber nicht, da ich das File erst durchlaufen müsste. Oder ist die Meinung die, dass ich das File erst einmal durchlaufe, die Zeilen zähle und dann die Anzahl Zeilen in nNumRows einfüge? Oder funktioniert das dann mit dem calloc (wobei du ja gesagt hast, dass man das nicht mischen sollte

)? (Bin momentan eben ein wenig Ratlos.

thewulf · **Posted:** 09.10.2007 09:27 **Post subject:**

Ja, das war für alle drei Varianten so gemeint, dass du zuerst das File durchläufst, die Anzahl der Koordinatensätze zählst, dann erst das entsprechende Array anlegst und schließlich die Daten einliest.

Hypothraxer · **Posted:** 09.10.2007 09:33 **Post subject:**

Ah okay. Ich stand vorhin ein wenig auf dem Syntax-Schlauch. Ich glaube jetzt sollte es funktionieren

Hypothraxer · **Posted:** 09.10.2007 10:34 **Post subject:**

So - es hat tatsächlich funktioniert (ein riiiiiiiiiiiiiesiges Dankeschön an Wulf und Daniel!). So sieht's momentan aus:

Code:

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <math.h>
#include <iomanip.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#define MaxDigits 24
using namespace std;

// Struct to read out the pointcloud file into an array-like structure
struct TCoordinates
   {
       double x;
       double y;
       double z;

       TCoordinates()
       {
           x = y = z = 0.0;
       }
   };



int main()

{

   // Stream Input
   /*
   fstream sampled;
   sampled.open("sampled.xyz", ios::out); // Define sampled output file
   sampled << setprecision(16);
   */
   fstream pointcloud;
   pointcloud.open("pointcloud.xyz", ios::in); // Define pointcloud input file
   pointcloud << setprecision(16);
   int linecount = 1, headerignore = 0;
   double xFile, yFile, zFile;
   string temporary;
   // Count the number of points in the file
   while(!pointcloud.eof()){
      // Ignore the first two lines
      while(headerignore != 2){
         getline(pointcloud,temporary);
         headerignore++;
      }
      getline(pointcloud,temporary);
      linecount++;
   }
   pointcloud.close();
   fstream pointcloud2;
   pointcloud2.open("pointcloud.xyz", ios::in); // Define pointcloud input file
   pointcloud2 << setprecision(16);
   // Define the size of the array to store the coordinates in
   TCoordinates *rows = new TCoordinates[linecount];
   linecount = 0;
   headerignore = 0;
   // Read out the file and store the data in the newly created array
   while(!pointcloud2.eof()){
         // Ignore the first two lines
         while(headerignore != 2){
            getline(pointcloud2,temporary);
            headerignore++;
         }
         pointcloud2 >> xFile;
         rows[linecount].x = xFile;
         pointcloud2 >> yFile;
         rows[linecount].y = yFile;
         pointcloud2 >> zFile;
         rows[linecount].z = zFile;
         linecount++;
      }
   cout << rows[1226363].x << " " << rows[1226363].y << " " << rows[1226363].z;
   delete []rows;
   pointcloud2.close();
   //sampled.close();
}

Eine Frage habe ich allerdings noch: Wenn ich die Werte auf der Konsole ausgebe, so werden nicht alle Stellen angezeigt (nur die ersten 6) - ich gehe aber davon aus, dass sämtliche Stellen im Array vorhanden sind. Ist dies zutreffend, oder sehe ich das zu blauäugig?

Edit: Ich habs mal im Debugger angesehen und er scheint alle Stellen mitzunehmen. Teilweise macht er aber gar seltsame Sachen: Z.B. wird aus dem ursprünglichen 0.9005797 ein 0.900579699999998 - das macht er aber längst nicht bei allen Koordinaten. Woher kommt das?

Daniel · **Joined:** 18.10.2004 13:48 **Posts:** 757

Hypothraxer wrote:

Edit: Ich habs mal im Debugger angesehen und er scheint alle Stellen mitzunehmen. Teilweise macht er aber gar seltsame Sachen: Z.B. wird aus dem ursprünglichen 0.9005797 ein 0.900579699999998 - das macht er aber längst nicht bei allen Koordinaten. Woher kommt das?

Zahlen werden binär gespeichert, nicht dezimal. Während im Dezimalsystem die Stellen nach dem Komma die Wertigkeit 1/10, 1/100, 1/1000 usw. haben, sind es eben 1/2, 1/4, 1/8, 1/16, 1/32 usw. im Binärsystem.

Genau so, wie du Pi (oder 1/3, 1/7, ...) im Dezimalsystem niemals exakt darstellen kannst (unendlich Nachkommastellen), kannst du nicht jede dezimal exakt darstellbare Zahl binär exakt darstellen, sondern nur fast.