[Wsplgen-commits] r40 - trunk/src
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Mon Mar 27 13:04:14 CEST 2006
Author: mrchip
Date: 2006-03-27 13:04:13 +0200 (Mon, 27 Mar 2006)
New Revision: 40
Modified:
trunk/src/file.cpp
trunk/src/file.h
trunk/src/parameter.cpp
trunk/src/parameter.h
trunk/src/test_file.cpp
trunk/src/test_tri.cpp
trunk/src/test_xy.cpp
trunk/src/tools.cpp
trunk/src/tools.h
trunk/src/tri.cpp
trunk/src/tri.h
trunk/src/wsplgen.cpp
trunk/src/xy.cpp
trunk/src/xy.h
Log:
Die Br?\195?\188che wurden implementiert und es wurde Speicherplatzoptimierung und Debuging betrieben.
Modified: trunk/src/file.cpp
===================================================================
--- trunk/src/file.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/file.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -40,6 +40,10 @@
line[sizeof(line)-1] = '\0';
if (strlen(line) > 0) line[strlen(line)-1] = '\0';
+ if ('\n' == line[strlen(line)-1]) line[strlen(line)-1] = '\0';
+ if ('\r' == line[strlen(line)-1]) line[strlen(line)-1] = '\0';
+ if ('\n' == line[strlen(line)-1]) line[strlen(line)-1] = '\0';
+
ParList->push_back(line);
}
@@ -51,7 +55,7 @@
}
//---------------------------------------------------------------------
-unsigned int LoadDGM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug)
+unsigned int LoadDGM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel)
{
write_fortschritt("->DGM laden\n");
@@ -65,26 +69,26 @@
if (ToUpperCase(Ext) == ".ADF")
{
- AnzScheiben = LoadDGMTIN(FileName, NodeList, ElementList, XyList, MaxNodesPerSlice, Debug);
+ AnzScheiben = LoadDGMTIN(FileName, NodeList, ElementList, XyList, MaxNodesPerSlice, DebugLevel);
}
else if (ToUpperCase(Ext) == ".2DM")
{
- AnzScheiben = LoadDGM2DM(FileName, NodeList, ElementList, XyList, MaxNodesPerSlice, Debug);
+ AnzScheiben = LoadDGM2DM(FileName, NodeList, ElementList, XyList, MaxNodesPerSlice, DebugLevel);
}
else if (ToUpperCase(Ext) == ".GRD")
{
- AnzScheiben = LoadDGMGRD(FileName, NodeList, ElementList, XyList, MaxNodesPerSlice, Debug);
- CheckForDuplicates(NodeList, Debug);
+ AnzScheiben = LoadDGMGRD(FileName, NodeList, ElementList, XyList, MaxNodesPerSlice, DebugLevel);
+ CheckForDuplicates(NodeList, DebugLevel);
}
else if (ToUpperCase(Ext) == ".XYZ")
{
- AnzScheiben = LoadDGMXYZ(FileName, NodeList, XyList, MaxNodesPerSlice, Debug);
- CheckForDuplicates(NodeList, Debug);
+ AnzScheiben = LoadDGMXYZ(FileName, NodeList, XyList, MaxNodesPerSlice, DebugLevel);
+ CheckForDuplicates(NodeList, DebugLevel);
}
else if (ToUpperCase(Ext) == ".SHP")
{
- AnzScheiben = LoadDGMSHP(FileName, NodeList, XyList, MaxNodesPerSlice, Debug);
- CheckForDuplicates(NodeList, Debug);
+ AnzScheiben = LoadDGMSHP(FileName, NodeList, XyList, MaxNodesPerSlice, DebugLevel);
+ CheckForDuplicates(NodeList, DebugLevel);
}
else
{
@@ -97,7 +101,7 @@
}
//---------------------------------------------------------------------------
-unsigned int LoadDGMTIN(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug)
+unsigned int LoadDGMTIN(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel)
{
write_fortschritt("->DGM TIN laden\n");
@@ -112,7 +116,8 @@
FILE *fhz = 0;
FILE *fhod = 0;
- unsigned int AnzNodes = 0;
+ unsigned int AnzKnoten = 0;
+ unsigned int AnzWerte = 0;
try
{
@@ -137,15 +142,17 @@
while (1 == fread(&X, sizeof(X), 1, fhxy) && fread(&Y, sizeof(Y), 1, fhxy) && 1 == fread(&Z, sizeof(Z), 1, fhz))
{
- if (Debug && AnzNodes % 10000 == 0) write_fortschritt("%d Knoten geladen\n", AnzNodes);
- else if (AnzNodes % 100000 == 0) write_fortschritt("%d Knoten geladen\n", AnzNodes);
-
Swap8Bytes((byte *)&X);
Swap8Bytes((byte *)&Y);
Swap4Bytes((byte *)&Z);
- AnzNodes++;
+ AnzWerte++;
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzWerte % 10000 == 0) || (AnzWerte > 0 && AnzWerte % 100000 == 0))
+ {
+ write_fortschritt("%d Werten gelesen, %d von %d Knoten im Speicher\n", AnzWerte, NodeList->size(), AnzKnoten);
+ }
+
if (Z < 1e30 && Z > -1e30)
{
X = (long)(X * 100.0 + 0.5) / 100.0;
@@ -156,21 +163,24 @@
if (XyList) InsideTyp = XyList->IsInsideXYList(X, Y);
if (InsideTyp == INSIDE || InsideTyp == ON_LINE)
{
- if (AnzNodes < MaxNodesPerSlice)
+ AnzKnoten++;
+
+ if (AnzKnoten < MaxNodesPerSlice)
{
- TNode *Node = new TNode(AnzNodes, X, Y, Z);
+ TNode *Node = new TNode(AnzWerte, X, Y, Z);
NodeList->push_back(Node);
}
}
}
}
+ write_fortschritt("%d Werten gelesen, %d von %d Knoten im Speicher\n", AnzWerte, NodeList->size(), AnzKnoten);
fclose(fhxy);
fclose(fhz);
- write_fortschritt("%d Knoten geladen\n", AnzNodes);
+
fhod = fopen(OdFileName.c_str(), "rb");
if (fhod == 0)
@@ -187,8 +197,10 @@
int AnzElements = 0;
while (1 == fread(&Nr1, sizeof(Nr1), 1, fhod) && fread(&Nr2, sizeof(Nr2), 1, fhod) && 1 == fread(&Nr3, sizeof(Nr3), 1, fhod))
{
- if (Debug && AnzElements % 10000 == 0) write_fortschritt("%d Elemente geladen\n", AnzElements);
- else if (AnzElements % 100000 == 0) write_fortschritt("%d Elemente geladen\n", AnzElements);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzElements % 10000 == 0) || (AnzElements > 0 && AnzElements % 100000 == 0))
+ {
+ write_fortschritt("%d Elemente geladen, %d Elemente im Speicher\n", AnzElements, ElementList->size());
+ }
Swap4Bytes((byte *)&Nr1);
Swap4Bytes((byte *)&Nr2);
@@ -208,7 +220,7 @@
fclose(fhod);
- write_fortschritt("%d Elemente geladen\n", AnzElements);
+ write_fortschritt("%d Elemente geladen, %d Elemente im Speicher\n", AnzElements, ElementList->size());
}
catch(...)
{
@@ -226,7 +238,7 @@
}
//---------------------------------------------------------------------------
-unsigned int LoadDGMGRD(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug)
+unsigned int LoadDGMGRD(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel)
{
write_fortschritt("->DGM GRD laden\n");
@@ -415,8 +427,10 @@
AnzWerte++;
- if (Debug && AnzWerte % 10000 == 0) write_fortschritt("%d von %d Werten gelesen, %d von %d Knoten gespeichert\n", AnzWerte, MaxWerte, NodeList->size(), AnzKnoten);
- else if (AnzWerte % 100000 == 0) write_fortschritt("%d von %d Werten gelesen, %d von %d Knoten gespeichert\n", AnzWerte, MaxWerte, NodeList->size(), AnzKnoten);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzWerte % 10000 == 0) || (AnzWerte > 0 && AnzWerte % 100000 == 0))
+ {
+ write_fortschritt("%d von %d Werten gelesen, %d von %d Knoten im Speicher\n", AnzWerte, MaxWerte, NodeList->size(), AnzKnoten);
+ }
X = (long)(X * 100 + 0.5) / 100.0;
Y = (long)(Y * 100 + 0.5) / 100.0;
@@ -435,18 +449,18 @@
}
}
}
- write_fortschritt("%d von %d Werten gelesen, %d von %d Knoten gespeichert\n", AnzWerte, MaxWerte, NodeList->size(), AnzKnoten);
+ write_fortschritt("%d von %d Werten gelesen, %d von %d Knoten im Speicher\n", AnzWerte, MaxWerte, NodeList->size(), AnzKnoten);
fclose(fh);
write_fortschritt("DGM GRD laden beendet<-\n");
- if (NodeList->size() <= MaxNodesPerSlice) return (1);
- else return ((NodeList->size() - 1) / MaxNodesPerSlice + 1);
+ if (AnzKnoten <= MaxNodesPerSlice) return (1);
+ else return ((AnzKnoten - 1) / MaxNodesPerSlice + 1);
}
//---------------------------------------------------------------------------
-unsigned int LoadDGMXYZ(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug)
+unsigned int LoadDGMXYZ(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel)
{
write_fortschritt("->DGM XYZ laden\n");
@@ -467,14 +481,12 @@
line[sizeof(line)-1] = '\0';
unsigned int AnzZeilen = 1;
+ unsigned int AnzWerte = 0;
unsigned int AnzKnoten = 0;
while (0 != fgets (line, sizeof(line)-1, fh))
{
AnzZeilen ++;
- if (Debug && AnzZeilen % 10000 == 0) write_fortschritt("%d Zeilen gelesen\n", AnzZeilen);
- else if (AnzZeilen % 100000 == 0) write_fortschritt("%d Zeilen gelesen\n", AnzZeilen);
-
double X=0.0;
double Y=0.0;
double Z=0.0;
@@ -493,6 +505,13 @@
write_error(2297, "Konnte keine 3 Werte in der Datei '%s' in der Zeile %d lesen\n", FileName.c_str(), AnzZeilen);
}
+ AnzWerte++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzWerte % 10000 == 0) || (AnzWerte > 0 && AnzWerte % 100000 == 0))
+ {
+ write_fortschritt("%d Werte gelesen, %d von %d Knoten im Speicher\n", AnzWerte, NodeList->size(), AnzKnoten);
+ }
+
X = (long)(X * 100) / 100.0;
Y = (long)(Y * 100) / 100.0;
Z = (long)(Z * 100) / 100.0;
@@ -510,17 +529,18 @@
}
}
}
+ write_fortschritt("%d Werte gelesen, %d von %d Knoten im Speicher\n", AnzWerte, NodeList->size(), AnzKnoten);
fclose(fh);
write_fortschritt("DGM XYZ laden beendet<-\n");
- if (NodeList->size() <= MaxNodesPerSlice) return (1);
- else return ((NodeList->size() - 1) / MaxNodesPerSlice + 1);
+ if (AnzKnoten <= MaxNodesPerSlice) return (1);
+ else return ((AnzKnoten - 1) / MaxNodesPerSlice + 1);
}
//---------------------------------------------------------------------------
-unsigned int LoadDGMSHP(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug)
+unsigned int LoadDGMSHP(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel)
{
write_fortschritt("->DGM SHP laden\n");
@@ -552,13 +572,15 @@
if (RecordCount == 0)
{
+ DBFClose(hDBF);
SHPClose(hSHP);
-
write_error(2204, "Es sind keine Objekte in der Shapedatei '%s'\n", SHPFileName.c_str());
}
if (ShapeType != SHPT_POINT && ShapeType != SHPT_POINTZ && ShapeType != SHPT_POINTM)
{
+ DBFClose(hDBF);
+ SHPClose(hSHP);
write_error(2213, "Der Typ ('%s') der Shape-Datei '%s' ist nicht POINT, POINTZ oder POINTM.\nNur die genannten Typen sind für DGM-Daten zulässig.\n", ShapeTypeName(ShapeType), SHPFileName.c_str());
}
@@ -568,7 +590,6 @@
{
DBFClose(hDBF);
SHPClose(hSHP);
-
write_error(2204, "Es sind keine Objekte in der DBF-Datei '%s'\n", DBFFileName.c_str());
}
@@ -576,7 +597,6 @@
{
DBFClose(hDBF);
SHPClose(hSHP);
-
write_error(2205, "Shape-Datei '%s' und DBF-Datei '%s' enthalten verschieden viele Objekte\n", SHPFileName.c_str(), DBFFileName.c_str());
}
@@ -586,7 +606,6 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2206, "In der DBD-Datei %s' sind keine Attribute definiert\nEs muss aber mindestens das Attibute 'Z' definiert sein.\n", DBFFileName.c_str());
}
@@ -632,7 +651,6 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2207, "In der DBD-Datei %s' ist das Attribut 'Z' nicht definiert\nEs muss aber vorhanden sein.\n", DBFFileName.c_str());
}
@@ -644,7 +662,6 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2209, "In der DBD-Datei '%s' ist der Attribut-Typ des Attributes 'Z' nicht Double.\n", DBFFileName.c_str());
}
}
@@ -655,12 +672,10 @@
}
+ unsigned int AnzWerte = 0;
unsigned int AnzKnoten = 0;
for (int i = 0; i<RecordCount; i++)
{
- if (Debug && i % 10000 == 0) write_fortschritt("%d Objekte geladen %d Knoten geladen\n", i, NodeList->size());
- else if (i % 100000 == 0) write_fortschritt("%d Objekte geladen %d Knoten geladen\n", i, NodeList->size());
-
SHPObject *psCShape = SHPReadObject(hSHP, i);
int AnzVert = psCShape->nVertices;
@@ -682,6 +697,13 @@
Y = (long)(Y * 100) / 100.0;
Z = (long)(Z * 100) / 100.0;
+ AnzWerte++;
+
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzWerte % 10000 == 0) || (AnzWerte > 0 && AnzWerte % 100000 == 0))
+ {
+ write_fortschritt("%d von %d Objekten gelesen, %d von %d Knoten im Speicher\n", AnzWerte, RecordCount, NodeList->size(), AnzKnoten);
+ }
+
TInsideTyp InsideTyp = INSIDE;
if (XyList) InsideTyp = XyList->IsInsideXYList(X, Y);
if (InsideTyp == INSIDE || InsideTyp == ON_LINE)
@@ -698,18 +720,19 @@
SHPDestroyObject(psCShape);
}
+ write_fortschritt("%d von %d Objekten gelesen, %d von %d Knoten im Speicher\n", AnzWerte, RecordCount, NodeList->size(), AnzKnoten);
+
+ DBFClose(hDBF);
SHPClose(hSHP);
- write_fortschritt("%d Objekte geladen %d Knoten geladen %d Knoten insgesamt\n", RecordCount, NodeList->size(), AnzKnoten);
-
write_fortschritt("DGM SHP laden beendet<-\n");
- if (NodeList->size() <= MaxNodesPerSlice) return (1);
- else return ((NodeList->size() - 1) / MaxNodesPerSlice + 1);
+ if (AnzKnoten <= MaxNodesPerSlice) return (1);
+ else return ((AnzKnoten - 1) / MaxNodesPerSlice + 1);
}
//---------------------------------------------------------------------------
-unsigned int LoadDGM2DM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug)
+unsigned int LoadDGM2DM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel)
{
write_fortschritt("->DGM 2DM laden\n");
@@ -742,8 +765,10 @@
{
AnzZeilen++;
- if (Debug && AnzZeilen % 10000 == 0) write_fortschritt("%d Zeilen gelesen %d Knoten geladen %d Elemente gezählt\n", AnzZeilen, NodeList->size(), AnzElemente);
- else if (AnzZeilen % 100000 == 0) write_fortschritt("%d Zeilen gelesen %d Knoten geladen %d Elemente gezählt\n", AnzZeilen, NodeList->size(), AnzElemente);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzZeilen % 10000 == 0) || (AnzZeilen > 0 && AnzZeilen % 100000 == 0))
+ {
+ write_fortschritt("%d Zeilen gelesen %d Knoten geladen %d Elemente gezählt\n", AnzZeilen, NodeList->size(), AnzElemente);
+ }
if (strncmp (line, "E4Q", 3) == 0 || strncmp (line, "E3T", 3) == 0)
{
@@ -792,8 +817,10 @@
{
AnzZeilen++;
- if (Debug && AnzZeilen % 10000 == 0) write_fortschritt("%d Zeilen gelesen %d Knoten geladen %d Elemente geladen\n", AnzZeilen, NodeList->size(), ElementList->size());
- else if (AnzZeilen % 100000 == 0) write_fortschritt("%d Zeilen gelesen %d Knoten geladen %d Elemente geladen\n", AnzZeilen, NodeList->size(), ElementList->size());
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzZeilen % 10000 == 0) || (AnzZeilen > 0 && AnzZeilen % 100000 == 0))
+ {
+ write_fortschritt("%d Zeilen gelesen %d Knoten geladen %d Elemente geladen\n", AnzZeilen, NodeList->size(), ElementList->size());
+ }
int Nr;
int Node1Nr;
@@ -854,7 +881,7 @@
}
//---------------------------------------------------------------------
-bool LoadProfile(std::string FileName, TProfilList* ProfilList)
+bool LoadProfile(std::string FileName, TProfilList* ProfilList, int DebugLevel)
{
write_fortschritt("->Profilspuren werden geladen\n");
@@ -891,12 +918,13 @@
{
DBFClose(hDBF);
SHPClose(hSHP);
-
write_error(2204, "Es sind keine Objekte in der Shape-Datei '%s'\n", SHPFileName.c_str());
}
if (ShapeType != SHPT_ARC && ShapeType != SHPT_ARCZ && ShapeType != SHPT_ARCM)
{
+ DBFClose(hDBF);
+ SHPClose(hSHP);
write_error(2213, "Der Typ ('%s') der Shape-Datei '%s' ist nicht ARC, ARCZ oder ARCM.\nNur die genannten Typen sind für Profilspuren zulässig.\n", ShapeTypeName(ShapeType), SHPFileName.c_str());
}
@@ -906,7 +934,6 @@
{
DBFClose(hDBF);
SHPClose(hSHP);
-
write_error(2204, "Es sind keine Objekte in der DBF-Datei '%s'\n", DBFFileName.c_str());
}
@@ -914,7 +941,6 @@
{
DBFClose(hDBF);
SHPClose(hSHP);
-
write_error(2205, "Shape-Datei '%s' und DBF-Datei '%s' enthalten verschieden viele Objekte\n", SHPFileName.c_str(), DBFFileName.c_str());
}
@@ -926,12 +952,11 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2206, "In der DBD-Datei %s' sind keine Attribute definiert\nEs müssen aber mindestens die Attibute Z und STATION definiert sein.\n", DBFFileName.c_str());
}
std::string GewName = "GEW";
- int GewFieldIndex = DBFGetFieldIndex(hDBF, "GEW");
+ int GewFieldIndex = DBFGetFieldIndex(hDBF, GewName.c_str());
if (GewFieldIndex == -1)
{
GewName = "Gew";
@@ -962,7 +987,6 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2207, "In der DBD-Datei %s' ist das Attribut 'GEW' nicht definiert\nEs muss aber vorhanden sein.\n", DBFFileName.c_str());
}
@@ -1013,7 +1037,6 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2208, "In der DBD-Datei '%s' ist das Attribut 'STATION' nicht definiert\nEs muss aber vorhanden sein.\n", DBFFileName.c_str());
}
@@ -1023,7 +1046,6 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2209, "In der DBD-Datei '%s' ist der Attribut-Typ des Attributes '%s' nicht Text.\n", DBFFileName.c_str(), GewName.c_str());
}
@@ -1031,13 +1053,15 @@
{
SHPClose(hSHP);
DBFClose(hDBF);
-
write_error(2210, "In der DBD-Datei '%s' ist der Attribut-Typ des Attributes '%s' nicht Fliesskommazahl.\n", DBFFileName.c_str(), StationName.c_str());
}
for (int i = 0; i<RecordCount; i++)
{
- if (ProfilList->size() > 0 && ProfilList->size() % 100 == 0) write_fortschritt("%d Profilspuren geladen\n", ProfilList->size());
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && ProfilList->size() % 10 == 0) || (ProfilList->size() > 0 && ProfilList->size() % 100 == 0))
+ {
+ write_fortschritt("%d von %d Profilspuren geladen\n", ProfilList->size(), RecordCount);
+ }
std::string Gewaesser = DBFReadStringAttribute(hDBF, i, GewFieldIndex);
double S = DBFReadDoubleAttribute(hDBF, i, StationFieldIndex);
@@ -1078,7 +1102,7 @@
SHPDestroyObject(psCShape);
}
- write_fortschritt("%d Profilspuren geladen\n", ProfilList->size());
+ write_fortschritt("%d von %d Profilspuren geladen\n", ProfilList->size(), RecordCount);
DBFClose(hDBF);
SHPClose(hSHP);
@@ -1089,8 +1113,14 @@
TProfil* VorProfil = 0;
TProfil* NachProfil = 0;
+ int Count = 0;
for (TProfilList::iterator i = ProfilList->begin(); i != ProfilList->end(); i++)
{
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && Count % 10 == 0) || (Count > 0 && Count % 100 == 0))
+ {
+ write_fortschritt("%d von %d Profilspuren ausgerichtet\n", Count, ProfilList->size());
+ }
+
VorProfil = NachProfil;
NachProfil = *i;
@@ -1122,6 +1152,8 @@
// Hier ist ein echter Schnittpunkt gefunden
// Jetzt muss das NachProfil in seiner Reihenfolge vertauscht werden
+ Count++;
+
TProfil* ExChangeProfil = new TProfil(NachProfil->Gewaesser, NachProfil->Station);
for (TPointList::reverse_iterator j = NachProfil->PointList->rbegin(); j != NachProfil->PointList->rend(); j++)
{
@@ -1139,14 +1171,198 @@
}
}
+ write_fortschritt("%d von %d Profilspuren ausgerichtet\n", Count, ProfilList->size());
- write_fortschritt("Die Profilspuren sind nun ausgerichtet<-\n");
+ return (true);
+}
+//---------------------------------------------------------------------
+bool LoadLinien(std::string FileName, TProfilList* SperrenList, TProfilList* BruchList, int DebugLevel)
+{
+ write_fortschritt("->Linien Strukturen (Sperren und Brüche) werden geladen\n");
+
+ if (SperrenList == 0 || BruchList == 0)
+ {
+ dump_error(__FILE__, __LINE__, "Sperrenliste oder Bruchlist ist undefiniert\n");
+ }
+
+ std::string SHPFileName = ExchangeFileExt(FileName, ".SHP");
+ SHPHandle hSHP = SHPOpen(SHPFileName.c_str(), "rb");
+
+ if (hSHP == NULL)
+ {
+ write_error(2201, "Konnte '%s' nicht zum Lesen öffnen\n", SHPFileName.c_str());
+ }
+
+ std::string DBFFileName = ExchangeFileExt(FileName, ".DBF");
+ DBFHandle hDBF = DBFOpen(DBFFileName.c_str(), "rb");
+ if (hDBF == NULL)
+ {
+ SHPClose(hSHP);
+ write_error(2201, "Konnte '%s' nicht zum Lesen öffnen\n", DBFFileName.c_str());
+ return (false);
+ }
+
+ int SHPRecordCount = 0;
+ TShpType ShapeType = SHPT_NULL;
+ double Mins[4];
+ double Maxs[4];
+
+ SHPGetInfo(hSHP, &SHPRecordCount, &ShapeType, Mins, Maxs);
+
+ if (SHPRecordCount == 0)
+ {
+ DBFClose(hDBF);
+ SHPClose(hSHP);
+
+ write_error(2204, "Es sind keine Objekte in der Shape-Datei '%s'\n", SHPFileName.c_str());
+ }
+
+ if (ShapeType != SHPT_ARC && ShapeType != SHPT_ARCZ && ShapeType != SHPT_ARCM)
+ {
+ write_error(2213, "Der Typ ('%s') der Shape-Datei '%s' ist nicht ARC, ARCZ oder ARCM.\nNur die genannten Typen sind für Profilspuren zulässig.\n", ShapeTypeName(ShapeType), SHPFileName.c_str());
+ }
+
+ int DBFRecordCount = DBFGetRecordCount(hDBF);
+
+ if (DBFRecordCount == 0)
+ {
+ DBFClose(hDBF);
+ SHPClose(hSHP);
+
+ write_error(2204, "Es sind keine Objekte in der DBF-Datei '%s'\n", DBFFileName.c_str());
+ }
+
+ if (DBFRecordCount != SHPRecordCount)
+ {
+ DBFClose(hDBF);
+ SHPClose(hSHP);
+
+ write_error(2205, "Shape-Datei '%s' und DBF-Datei '%s' enthalten verschieden viele Objekte\n", SHPFileName.c_str(), DBFFileName.c_str());
+ }
+
+ int RecordCount = SHPRecordCount;
+
+ int FieldCount = DBFGetFieldCount(hDBF);
+
+ if (FieldCount == 0)
+ {
+ SHPClose(hSHP);
+ DBFClose(hDBF);
+
+ write_error(2206, "In der DBD-Datei %s' sind keine Attribute definiert\nEs muss aber mindestens das Attibute TYP definiert sein.\n", DBFFileName.c_str());
+ }
+
+ std::string TypName = "TYP";
+ int TypFieldIndex = DBFGetFieldIndex(hDBF, TypName.c_str());
+ if (TypFieldIndex == -1)
+ {
+ TypName = "Typ";
+ TypFieldIndex = DBFGetFieldIndex(hDBF, TypName.c_str());
+ }
+ if (TypFieldIndex == -1)
+ {
+ TypName = "typ";
+ TypFieldIndex = DBFGetFieldIndex(hDBF, TypName.c_str());
+ }
+ if (TypFieldIndex == -1)
+ {
+ TypName = "TYPE";
+ TypFieldIndex = DBFGetFieldIndex(hDBF, TypName.c_str());
+ }
+ if (TypFieldIndex == -1)
+ {
+ TypName = "Type";
+ TypFieldIndex = DBFGetFieldIndex(hDBF, TypName.c_str());
+ }
+ if (TypFieldIndex == -1)
+ {
+ TypName = "type";
+ TypFieldIndex = DBFGetFieldIndex(hDBF, TypName.c_str());
+ }
+
+ if (TypFieldIndex == -1)
+ {
+ SHPClose(hSHP);
+ DBFClose(hDBF);
+
+ write_error(2207, "In der DBD-Datei %s' ist das Attribut 'Typ' nicht definiert\nEs muss aber vorhanden sein.\n", DBFFileName.c_str());
+ }
+
+ int Width = 0;
+ int Decimals = 0;
+ if (DBFGetFieldInfo(hDBF, TypFieldIndex, NULL, &Width, &Decimals) != FTString)
+ {
+ SHPClose(hSHP);
+ DBFClose(hDBF);
+
+ write_error(2209, "In der DBD-Datei '%s' ist der Attribut-Typ des Attributes '%s' nicht Text.\n", DBFFileName.c_str(), TypName.c_str());
+ }
+
+ for (int i = 0; i<RecordCount; i++)
+ {
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && i % 10 == 0) || (i > 0 && i % 100 == 0))
+ {
+ write_fortschritt("%d von %d Liniensstrukturen geladen, %d Brüche und %d Sperren im Speicher\n", i, RecordCount, BruchList, SperrenList);
+ }
+
+ std::string Typ = DBFReadStringAttribute(hDBF, i, TypFieldIndex);
+
+ if (Typ == "SPERRE" || Typ == "Sperre" || Typ == "sperre")
+ {
+ Typ = "SPERRE";
+ }
+ else if (Typ == "BRUCH" || Typ == "Bruch" || Typ == "bruch")
+ {
+ Typ = "BRUCH";
+ }
+ else
+ {
+ write_warning(3112, "Das Attribut 'TYP' (%s) in der Datei '%s' darf nur die Werte 'SPERRE' oder 'BRUCH' haben.\nDas Linienobjekt wird ignoriert.\n", DBFFileName.c_str());
+ continue;
+ }
+
+
+ SHPObject *psCShape = SHPReadObject(hSHP, i);
+
+ int AnzVert = psCShape->nVertices;
+
+ if (AnzVert <= 0)
+ {
+ write_warning(2112, "In der SHP-Datei '%s' hat ein Linienobjekt keine Stützstellen.\nEs wird ignoriert.\n", SHPFileName.c_str());
+ continue;
+ }
+
+ // Der Wasserstand muss so hoch sein, damit später auch alle Knoten der Bruckkante erzeugt werden können
+ TProfil* Linie = new TProfil(Typ, i, 9999.9);
+
+ if (Typ == "SPERRE") SperrenList->insert(Linie);
+ else BruchList->insert(Linie);
+
+ for (int j=0; j < AnzVert; j++)
+ {
+ double X = psCShape->padfX[j];
+ double Y = psCShape->padfY[j];
+
+ X = (long)(X * 100.0 + 0.5) / 100.0;
+ Y = (long)(Y * 100.0 + 0.5) / 100.0;
+ Linie->AddPoint(X, Y);
+ }
+
+ SHPDestroyObject(psCShape);
+ }
+ write_fortschritt("%d von %d Liniensstrukturen geladen, %d Brüche und %d Sperren im Speicher\n", RecordCount, RecordCount, BruchList, SperrenList);
+
+ DBFClose(hDBF);
+ SHPClose(hSHP);
+
+ write_fortschritt("Das Laden der Liniensstrukturen wurde beendet<-\n");
+
return (true);
}
//---------------------------------------------------------------------
-bool LoadWsp(std::string FileName, TProfilList* ProfilList)
+bool LoadWsp(std::string FileName, TProfilList* ProfilList, int DebugLevel)
{
write_fortschritt("->Wasserstände werden geladen\n");
@@ -1156,11 +1372,11 @@
if (ToUpperCase(Ext) == ".DBF")
{
- Status = LoadWspDBF(FileName, ProfilList);
+ Status = LoadWspDBF(FileName, ProfilList, DebugLevel);
}
else
{
- Status = LoadWspTxt(FileName, ProfilList);
+ Status = LoadWspTxt(FileName, ProfilList, DebugLevel);
}
write_fortschritt("Wasserstände wurden geladen<-\n");
@@ -1169,7 +1385,7 @@
}
//---------------------------------------------------------------------
-bool LoadWspTxt(std::string FileName, TProfilList* ProfilList)
+bool LoadWspTxt(std::string FileName, TProfilList* ProfilList, int DebugLevel)
{
write_fortschritt("->Wasserstände im ASCII-Format werden geladen\n");
@@ -1193,10 +1409,13 @@
char line[1000];
while (fgets (line, sizeof (line)-1, fh))
{
- if (ProfilList->size() > 0 && ProfilList->size() % 100 == 0) write_fortschritt("%d Wasserstände geladen\n", ProfilList->size());
-
AktZeile++;
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AktZeile % 10 == 0) || (AktZeile > 0 && AktZeile % 100 == 0))
+ {
+ write_fortschritt("%d Zeilen und %d Wasserstände geladen\n", AktZeile, ProfilList->size());
+ }
+
line[sizeof(line)-1] = '\0';
if (strlen(line) > 0) line[strlen(line)-1] = '\0';
@@ -1279,7 +1498,7 @@
ProfilList->insert(Profil);
}
- write_fortschritt("%d Wasserstände geladen\n", ProfilList->size());
+ write_fortschritt("%d Zeilen und %d Wasserstände geladen\n", AktZeile, ProfilList->size());
fclose(fh);
@@ -1289,7 +1508,7 @@
}
//---------------------------------------------------------------------
-bool LoadWspDBF(std::string FileName, TProfilList* ProfilList)
+bool LoadWspDBF(std::string FileName, TProfilList* ProfilList, int DebugLevel)
{
write_fortschritt("->Wasserstände im DBF-Format werden geladen\n");
@@ -1471,7 +1690,10 @@
for (int i = 0; i<RecordCount; i++)
{
- if (ProfilList->size() > 0 && ProfilList->size() % 100 == 0) write_fortschritt("%d Wasserstände geladen\n", ProfilList->size());
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && i % 10 == 0) || (i > 0 && i % 100 == 0))
+ {
+ write_fortschritt("%d von %d Objekten gelesen, %d Wasserstände im Speicher\n", i, RecordCount, ProfilList->size());
+ }
std::string Gewaesser = DBFReadStringAttribute(hDBF, i, GewFieldIndex);
double S = DBFReadDoubleAttribute(hDBF, i, StationFieldIndex);
@@ -1494,7 +1716,7 @@
ProfilList->insert(Profil);
}
- write_fortschritt("%d Wasserstände geladen\n", ProfilList->size());
+ write_fortschritt("%d von %d Objekten gelesen, %d Wasserstände im Speicher\n", RecordCount, RecordCount, ProfilList->size());
DBFClose(hDBF);
@@ -1504,7 +1726,7 @@
}
//---------------------------------------------------------------------
-bool LoadAchse(std::string FileName, TGewaesserAchseList* GewaesserAchseList)
+bool LoadAchse(std::string FileName, TGewaesserAchseList* GewaesserAchseList, int DebugLevel)
{
write_fortschritt("->Gewässerachse wird geladen\n");
@@ -1628,7 +1850,10 @@
for (int i = 0; i<RecordCount; i++)
{
- if (GewaesserAchseList->size() > 0 && GewaesserAchseList->size() % 100 == 0) write_fortschritt("%d Gewässerachsen geladen\n", GewaesserAchseList->size());
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && i % 10 == 0) || (i > 0 && i % 100 == 0))
+ {
+ write_fortschritt("%d von %d Objekten gelesen, %d Gewässerachsen im Speicher\n", i, RecordCount, GewaesserAchseList->size());
+ }
std::string Gewaesser = DBFReadStringAttribute(hDBF, i, GewFieldIndex);
@@ -1659,7 +1884,7 @@
SHPDestroyObject(psCShape);
}
- write_fortschritt("%d Gewässerachsen geladen\n", GewaesserAchseList->size());
+ write_fortschritt("%d von %d Objekten gelesen, %d Gewässerachsen im Speicher\n", RecordCount, RecordCount, GewaesserAchseList->size());
DBFClose(hDBF);
SHPClose(hSHP);
@@ -1670,7 +1895,7 @@
}
//---------------------------------------------------------------------------
-bool SaveNet(std::string FileName, TNodeList *NodeList, TElementList *ElementList, bool Debug)
+bool SaveNet(std::string FileName, TNodeList *NodeList, TElementList *ElementList, int DebugLevel)
{
write_fortschritt("->2dM-Netz speichern\n");
@@ -1688,25 +1913,26 @@
for (unsigned int i=0; i<ElementList->size(); i++)
{
- if (Debug && i % 1000 == 0) write_fortschritt("%d Elemente gespeichert\n", i);
- else if (i % 10000 == 0) write_fortschritt("%d Elemente gespeichert\n", i);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && i % 5000 == 0) || (i > 0 && i % 50000 == 0))
+ {
+ write_fortschritt("%d von %d Elementen gespeichert\n", i, ElementList->size());
+ }
TElement *Element = (*ElementList)[i];
- TNodeList *NL = Element->NodeList;
- if (NL->size() != 3)
+ if (Element->Typ != TRI)
{
dump_error(__FILE__, __LINE__, "Ein Element hat nicht genau 3 Knoten\n");
}
- TNode *N1 = (*NL)[0];
- TNode *N2 = (*NL)[1];
- TNode *N3 = (*NL)[2];
+ TNode *N1 = Element->Node1;
+ TNode *N2 = Element->Node2;
+ TNode *N3 = Element->Node3;
fprintf(fh, "E3T %6d %6d %6d %6d %6d\n", i+1, N1->Nr, N2->Nr, N3->Nr, 1);
}
- write_fortschritt("%d Elemente gespeichert\n", ElementList->size());
+ write_fortschritt("%d von %d Elementen gespeichert\n", ElementList->size(), ElementList->size());
write_fortschritt("Elemente speichern beendet<-\n");
@@ -1714,19 +1940,21 @@
for (unsigned int i=0; i<NodeList->size(); i++)
{
- if (Debug && i % 1000 == 0) write_fortschritt("%d Knoten gespeichert\n", i);
- else if (i % 10000 == 0) write_fortschritt("%d Knoten gespeichert\n", i);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && i % 5000 == 0) || (i > 0 && i % 50000 == 0))
+ {
+ write_fortschritt("%d von %d Knoten gespeichert\n", i, NodeList->size());
+ }
TNode *Node = (*NodeList)[i];
fprintf(fh, "ND %6d %15.9e %15.9e %15.9e\n", Node->Nr, Node->X, Node->Y, Node->Z);
}
- write_fortschritt("%d Knoten gespeichert\n", NodeList->size());
+ write_fortschritt("%d von %d Knoten gespeichert\n", NodeList->size(), NodeList->size());
write_fortschritt("Knoten speichern beendet<-\n");
- write_fortschritt("->Parameter speichern\n");
+ write_fortschritt("->Modell-Parameter speichern\n");
fprintf(fh, "BEGPARAMDEF\n");
fprintf(fh, "GM HYDRO_AS-2D\n");
@@ -1765,7 +1993,7 @@
fprintf(fh, "END2DMBC\n");
- write_fortschritt("Parameter speichern beendet<-\n");
+ write_fortschritt("Modell-Parameter speichern beendet<-\n");
fclose (fh);
@@ -1775,7 +2003,7 @@
}
//---------------------------------------------------------------------------
-bool SaveProfile(std::string FileName, TProfilList *ProfilList, bool Debug)
+bool SaveProfile(std::string FileName, TProfilList *ProfilList, int DebugLevel)
{
write_fortschritt("->Profile speichern\n");
@@ -1848,10 +2076,12 @@
AnzProfil++;
- if (Debug && AnzProfil % 100 == 0) write_fortschritt("%d Profile gespeichert\n", AnzProfil);
- else if (0 && AnzProfil % 1000 == 0) write_fortschritt("%d Profile gespeichert\n", AnzProfil);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzProfil % 100 == 0) || (AnzProfil > 0 && AnzProfil % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Profile gespeichert\n", AnzProfil, ProfilList->size());
+ }
}
- write_fortschritt("%d Profile gespeichert\n", AnzProfil);
+ write_fortschritt("%d von %d Profile gespeichert\n", AnzProfil, ProfilList->size());
DBFClose(DBFHandle);
SHPClose(SHPHandle);
@@ -1862,7 +2092,7 @@
}
//---------------------------------------------------------------------------
-bool SavePolygon(std::string FileName, std::string Gewaesser, int Von, int Bis, TXYList *XyList)
+bool SavePolygon(std::string FileName, std::string Gewaesser, int Von, int Bis, TXYList *XyList, int DebugLevel)
{
write_fortschritt("->Polygon wird gespeichert\n");
@@ -1900,6 +2130,11 @@
int AnzPoint = 0;
for (TXYList::iterator i = XyList->begin(); i != XyList->end(); i++)
{
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzPoint % 1000 == 0) || (AnzPoint > 0 && AnzPoint % 10000 == 0))
+ {
+ write_fortschritt("%d von %d Stützstellen gespeichert\n", AnzPoint, XyList->size());
+ }
+
TXY* Xy = *i;
double X = Xy->X;
@@ -1939,13 +2174,15 @@
DBFClose(DBFHandle);
SHPClose(SHPHandle);
+ write_fortschritt("%d von %d Stützstellen gespeichert\n", AnzPoint, XyList->size());
+
write_fortschritt("Polygon gespeichert<-\n");
return (true);
}
//---------------------------------------------------------------------------
-bool SavePolygone(std::string FileName, TErgebnisPolygonList *ErgebnisPolygonList, bool Debug)
+bool SavePolygone(std::string FileName, TErgebnisPolygonList *ErgebnisPolygonList, int DebugLevel)
{
write_fortschritt("->Polygone werden gespeichert\n");
@@ -1979,7 +2216,7 @@
write_error(4204, "Kann bei Datei '%s' das Attribut 'BIS' nicht erzeugen\n", FileName.c_str());
}
- if (Debug)
+ if (DebugLevel)
{
for (TErgebnisPolygonList::iterator i = ErgebnisPolygonList->begin(); i != ErgebnisPolygonList->end(); i++)
{
@@ -2001,6 +2238,11 @@
TErgebnisPolygonList::iterator i = ErgebnisPolygonList->begin();
while (i != ErgebnisPolygonList->end())
{
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzPolygons % 100 == 0) || (AnzPolygons > 0 && AnzPolygons % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Polygonen gespeichert\n", AnzPolygons, ErgebnisPolygonList->size());
+ }
+
TErgebnisPolygon* ErgebnisPolygon = *i;
std::string AktGewaesser = ErgebnisPolygon->Gewaesser;
@@ -2083,7 +2325,7 @@
}
}
- if (Debug) write_fortschritt("%d. Polygon %d Teile %d Ecken.\n", AnzPolygons+1, AnzPolyParts, AnzPolyPoints);
+ if (DebugLevel) write_fortschritt("%d. Polygon %d Teile %d Ecken.\n", AnzPolygons+1, AnzPolyParts, AnzPolyPoints);
else write_fortschritt("\n");
if (AnzPolyParts > 0 && AnzPolyPoints > 0)
@@ -2125,6 +2367,8 @@
i = ErgebnisPolygonList->begin();
}
+ write_fortschritt("%d von %d Polygonen gespeichert\n", AnzPolygons, ErgebnisPolygonList->size());
+
DBFClose(DBFHandle);
SHPClose(SHPHandle);
@@ -2138,12 +2382,10 @@
{
if (Element->Typ == TRI)
{
- TNodeList *NL = Element->NodeList;
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
- TNode *Node1 = (*NL)[0];
- TNode *Node2 = (*NL)[1];
- TNode *Node3 = (*NL)[2];
-
double Wsp = 0.0;
double Depth = 0.0;
double Topo = 0.0;
@@ -2243,13 +2485,11 @@
}
else
{
- TNodeList *NL = Element->NodeList;
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ TNode *Node4 = Element->Node4;
- TNode *Node1 = (*NL)[0];
- TNode *Node2 = (*NL)[1];
- TNode *Node3 = (*NL)[2];
- TNode *Node4 = (*NL)[3];
-
TElement *TempElement = 0;
TempElement = new TElement(Node1, Node2, Node3);
@@ -2265,7 +2505,7 @@
}
//---------------------------------------------------------------------------
-bool SaveElements(std::string FileName, TElementList *ElementList, bool Debug)
+bool SaveElements(std::string FileName, TElementList *ElementList, int DebugLevel)
{
write_fortschritt("->Elemente speichern\n");
@@ -2298,14 +2538,16 @@
int AnzPolygone = 0;
for (TElementList::iterator i=ElementList->begin(); i != ElementList->end(); i++)
{
- if (Debug && AnzPolygone % 10000 == 0) write_fortschritt("%d Polygone gespeichert\n", AnzPolygone);
- else if (AnzPolygone % 100000 == 0) write_fortschritt("%d Polygone gespeichert\n", AnzPolygone);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzPolygone % 100 == 0) || (AnzPolygone > 0 && AnzPolygone % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Elementen (Polygone) gespeichert\n", AnzPolygone, ElementList->size());
+ }
TElement *Element = *i;
AnzPolygone = OutElement(AnzPolygone, Element, DBFHandle, SHPHandle);
}
- write_fortschritt("%d Polygone gespeichert\n", AnzPolygone);
+ write_fortschritt("%d von %d Elementen (Polygone) gespeichert\n", AnzPolygone, ElementList->size());
SHPClose(SHPHandle);
DBFClose(DBFHandle);
@@ -2316,7 +2558,7 @@
}
//---------------------------------------------------------------------------
-bool SaveNodes(std::string FileName, TNodeList *NodeList, bool Debug)
+bool SaveNodes(std::string FileName, TNodeList *NodeList, int DebugLevel)
{
write_fortschritt("->Knoten speichern\n");
@@ -2349,8 +2591,10 @@
int AnzNodes = 0;
for (TNodeList::iterator i=NodeList->begin(); i != NodeList->end(); i++)
{
- if (Debug && AnzNodes % 10000 == 0) write_fortschritt("%d Knoten gespeichert\n", AnzNodes);
- else if (AnzNodes % 100000 == 0) write_fortschritt("%d Knoten gespeichert\n", AnzNodes);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && AnzNodes % 100 == 0) || (AnzNodes > 0 && AnzNodes % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Knoten gespeichert\n", AnzNodes, NodeList->size());
+ }
TNode *Node = *i;
@@ -2368,7 +2612,7 @@
AnzNodes++;
}
- write_fortschritt("%d Knoten gespeichert\n", AnzNodes);
+ write_fortschritt("%d von %d Knoten gespeichert\n", AnzNodes, NodeList->size());
SHPClose(SHPHandle);
DBFClose(DBFHandle);
@@ -2379,7 +2623,7 @@
}
//---------------------------------------------------------------------------
-bool SaveEdges(std::string FileName, TEdgeList *EdgeList, bool Debug)
+bool SaveEdges(std::string FileName, TEdgeList *EdgeList, int DebugLevel)
{
write_fortschritt("->Kanten speichern\n");
@@ -2411,11 +2655,13 @@
z[0] = 0.0;
z[1] = 0.0;
- int RecordCount = 0;
+ int Count = 0;
for (TEdgeListNrSorted::iterator i = EdgeList->EdgeListNrSorted.begin(); i != EdgeList->EdgeListNrSorted.end(); i++)
{
- if (Debug && RecordCount % 10000 == 0) write_fortschritt("%d Kanten gespeichert\n", RecordCount);
- else if (RecordCount % 100000 == 0) write_fortschritt("%d Kanten gespeichert\n", RecordCount);
+ if (DebugLevel >= 9 && (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Kanten gespeichert\n", Count, EdgeList->EdgeListNrSorted.size());
+ }
TEdge* Edge = *i;
@@ -2434,11 +2680,12 @@
SHPWriteObject(SHPHandle, -1, psShape);
SHPDestroyObject(psShape);
- DBFWriteIntegerAttribute(DBFHandle, RecordCount, 0, Nr1);
- DBFWriteIntegerAttribute(DBFHandle, RecordCount, 1, Nr2);
+ DBFWriteIntegerAttribute(DBFHandle, Count, 0, Nr1);
+ DBFWriteIntegerAttribute(DBFHandle, Count, 1, Nr2);
- RecordCount++;
+ Count++;
}
+ write_fortschritt("%d von %d Kanten gespeichert\n", Count, EdgeList->EdgeListNrSorted.size());
DBFClose(DBFHandle);
SHPClose(SHPHandle);
Modified: trunk/src/file.h
===================================================================
--- trunk/src/file.h 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/file.h 2006-03-27 11:04:13 UTC (rev 40)
@@ -20,29 +20,30 @@
//----------------------------------------------------------------------------
bool LoadPar(std::string FileName, std::vector<std::string> *ParList);
-unsigned int LoadDGM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
-unsigned int LoadDGMTIN(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
-unsigned int LoadDGMGRD(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
-unsigned int LoadDGMXYZ(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
-unsigned int LoadDGMGRD(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
-unsigned int LoadDGMSHP(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
-unsigned int LoadDGM2DM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, bool Debug);
+unsigned int LoadDGM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
+unsigned int LoadDGMTIN(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
+unsigned int LoadDGMGRD(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
+unsigned int LoadDGMXYZ(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
+unsigned int LoadDGMGRD(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
+unsigned int LoadDGMSHP(std::string FileName, TNodeList *NodeList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
+unsigned int LoadDGM2DM(std::string FileName, TNodeList *NodeList, TElementList *ElementList, TXYList *XyList, unsigned int MaxNodesPerSlice, int DebugLevel);
-bool LoadProfile(std::string FileName, TProfilList* ProfilList);
+bool LoadProfile(std::string FileName, TProfilList* ProfilList, int DebugLevel);
+bool LoadLinien(std::string FileName, TProfilList* SperrenList, TProfilList* BruchList, int DebugLevel);
-bool LoadWsp(std::string FileName, TProfilList* ProfilList);
-bool LoadWspTxt(std::string FileName, TProfilList* ProfilList);
-bool LoadWspDBF(std::string FileName, TProfilList* ProfilList);
+bool LoadWsp(std::string FileName, TProfilList* ProfilList, int DebugLevel);
+bool LoadWspTxt(std::string FileName, TProfilList* ProfilList, int DebugLevel);
+bool LoadWspDBF(std::string FileName, TProfilList* ProfilList, int DebugLevel);
-bool LoadAchse(std::string FileName, TGewaesserAchseList* GewaesserAchseList);
+bool LoadAchse(std::string FileName, TGewaesserAchseList* GewaesserAchseList, int DebugLevel);
-bool SaveNet(std::string FileName, TNodeList *NodeList, TElementList *ElementList, bool Debug);
-bool SaveNodes(std::string FileName, TNodeList *NodeList, bool Debug);
-bool SaveElements(std::string FileName, TElementList *ElementList, bool Debug);
-bool SaveProfile(std::string FileName, TProfilList *ProfilList, bool Debug);
-bool SavePolygon(std::string FileName, std::string Gewaesser, int Von, int Bis, TXYList *XyList);
-bool SavePolygone(std::string FileName, TErgebnisPolygonList *ErgebnisPolygonList, bool Debug);
-bool SaveEdges(std::string FileName, TEdgeList *EdgeList, bool Debug);
+bool SaveNet(std::string FileName, TNodeList *NodeList, TElementList *ElementList, int DebugLevel);
+bool SaveNodes(std::string FileName, TNodeList *NodeList, int DebugLevel);
+bool SaveElements(std::string FileName, TElementList *ElementList, int DebugLevel);
+bool SaveProfile(std::string FileName, TProfilList *ProfilList, int DebugLevel);
+bool SavePolygon(std::string FileName, std::string Gewaesser, int Von, int Bis, TXYList *XyList, int DebugLevel);
+bool SavePolygone(std::string FileName, TErgebnisPolygonList *ErgebnisPolygonList, int DebugLevel);
+bool SaveEdges(std::string FileName, TEdgeList *EdgeList, int DebugLevel);
//----------------------------------------------------------------------------
#endif
Modified: trunk/src/parameter.cpp
===================================================================
--- trunk/src/parameter.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/parameter.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -21,7 +21,8 @@
{
write_fortschritt("->Die Kommandozeilen-Parameter werden ausgewertet\n");
- IsDebug = false;
+ IsSetDebug = false;
+ DebugLevel = 0;
IsSetPar = false;
FileNamePar = "";
@@ -85,14 +86,34 @@
write_fortschritt("Parameter -DEBUG erkannt.\n");
write_fortschritt("Es werden jetzt ausführliche Informationen ausgegeben.\n");
- IsDebug = true;
+ if (IsSetDebug)
+ {
+ write_warning(1106, "Der Parameter -DEBUG wurde mehrfach angegeben.\nEs wird der höchste Debuglevel verwendet\n");
+ }
+
+ IsSetDebug = true;
+
+ if (Parameter.substr(6, 1) != "=")
+ {
+ write_warning(1108, "Es wurden keine Argumente für -DEBUG übergeben.\nDebuglevel wird 9 (Alle Debuginfos).\n");
+ DebugLevel = 9;
+ continue;
+ }
+
+ int NewDebugLevel;
+ if (1 == sscanf(Parameter.substr(7).c_str(), "%d", &NewDebugLevel))
+ {
+ if (NewDebugLevel > DebugLevel) DebugLevel = NewDebugLevel;
+ }
+
+ write_fortschritt("DebugLevel: '%d'\n", DebugLevel);
}
else if (Parameter.substr(0, 4) == "-PAR" || Parameter.substr(0, 4) == "-par")
{
///////////////////////////////////////////////
// PAR
///////////////////////////////////////////////
- if (IsDebug) write_fortschritt("Parameter -PAR erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -PAR erkannt.\n");
if (IsSetPar)
{
@@ -112,7 +133,7 @@
IsSetPar = true;
- if (IsDebug) write_fortschritt("Parameterdatei: '%s'\n", FileNamePar.c_str());
+ if (IsSetDebug) write_fortschritt("Parameterdatei: '%s'\n", FileNamePar.c_str());
LoadPar(FileNamePar, &ParList);
AnzPar = ParList.size();
@@ -122,7 +143,7 @@
///////////////////////////////////////////////
// DELTA
///////////////////////////////////////////////
- if (IsDebug) write_fortschritt("Parameter -DELTA erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -DELTA erkannt.\n");
if (IsSetDelta)
{
@@ -170,7 +191,7 @@
IsSetDelta = true;
- if (IsDebug)
+ if (IsSetDebug)
{
write_fortschritt("Delta:");
if (IsSetVon) write_fortschritt(" Von = %.2f", Von);
@@ -188,7 +209,7 @@
///////////////////////////////////////////////
// GEL
///////////////////////////////////////////////
- if (IsDebug) write_fortschritt("Parameter -GEL erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -GEL erkannt.\n");
if (IsSetGel)
{
@@ -216,7 +237,7 @@
write_error(1214, "Es wurden weder SPERRE noch NOSPERRE mit -GEL verwendet.\nDas Format lautet korrekt -GEL=<SPERRE|NOSPERRE>.\n");
}
- if (IsDebug)
+ if (IsSetDebug)
{
if (!IsSetGel) write_fortschritt("<Standard:> ");
@@ -226,7 +247,7 @@
}
else if (Parameter.substr(0, 4) == "-DGM" || Parameter.substr(0, 4) == "-dgm")
{
- if (IsDebug) write_fortschritt("Parameter -DGM erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -DGM erkannt.\n");
if (IsSetDgm)
{
@@ -246,11 +267,11 @@
IsSetDgm = true;
- if (IsDebug) write_fortschritt("DGM-Datei: '%s'\n", FileNameDgm.c_str());
+ if (IsSetDebug) write_fortschritt("DGM-Datei: '%s'\n", FileNameDgm.c_str());
}
else if (Parameter.substr(0, 4) == "-PRO" || Parameter.substr(0, 4) == "-pro")
{
- if (IsDebug) write_fortschritt("Parameter -PRO erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -PRO erkannt.\n");
if (IsSetPro)
{
@@ -270,11 +291,11 @@
IsSetPro = true;
- if (IsDebug) write_fortschritt("Profillagen-Datei: '%s'\n", FileNamePro.c_str());
+ if (IsSetDebug) write_fortschritt("Profillagen-Datei: '%s'\n", FileNamePro.c_str());
}
else if (Parameter.substr(0, 4) == "-WSP" || Parameter.substr(0, 4) == "-wsp")
{
- if (IsDebug) write_fortschritt("Parameter -WSP erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -WSP erkannt.\n");
if (IsSetWsp)
{
@@ -294,13 +315,13 @@
IsSetWsp = true;
- if (IsDebug) write_fortschritt("WSP-Datei: '%s'\n", FileNameWsp.c_str());
+ if (IsSetDebug) write_fortschritt("WSP-Datei: '%s'\n", FileNameWsp.c_str());
continue;
}
else if (Parameter.substr(0, 4) == "-LIN" || Parameter.substr(0, 4) == "-LIN")
{
- if (IsDebug) write_fortschritt("Parameter -LIN erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -LIN erkannt.\n");
if (IsSetLin)
{
@@ -320,11 +341,11 @@
IsSetLin = true;
- if (IsDebug) write_fortschritt("Bruch- und Sperr-Datei: '%s'\n", FileNameLin.c_str());
+ if (IsSetDebug) write_fortschritt("Bruch- und Sperr-Datei: '%s'\n", FileNameLin.c_str());
}
else if (Parameter.substr(0, 6) == "-ACHSE" || Parameter.substr(0, 6) == "-achse")
{
- if (IsDebug) write_fortschritt("Parameter -ACHSE erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -ACHSE erkannt.\n");
if (IsSetAchse)
{
@@ -344,13 +365,13 @@
IsSetAchse = true;
- if (IsDebug) write_fortschritt("Gewässerachse: '%s'\n", FileNameAchse.c_str());
+ if (IsSetDebug) write_fortschritt("Gewässerachse: '%s'\n", FileNameAchse.c_str());
continue;
}
else if (Parameter.substr(0, 8) == "-AUSGABE" || Parameter.substr(0, 8) == "-ausgabe")
{
- if (IsDebug) write_fortschritt("Parameter -AUSGABE erkannt.\n");
+ if (IsSetDebug) write_fortschritt("Parameter -AUSGABE erkannt.\n");
if (IsSetAusgabe)
{
@@ -370,7 +391,7 @@
IsSetAusgabe = true;
- if (IsDebug) write_fortschritt("Ausgabe-Datei: '%s'\n", FileNameAusgabe.c_str());
+ if (IsSetDebug) write_fortschritt("Ausgabe-Datei: '%s'\n", FileNameAusgabe.c_str());
}
else
{
@@ -448,6 +469,11 @@
write_warning(1121, "Der Parameter -DELTA oder sein Argument <Diff> wurden nicht angegeben.\nEs wird <Diff> als (<Bis> minus <Von>) geteilt durch 10 angenommen.\n");
}
+ if (true == IsSetAchse && false == Sperre)
+ {
+ write_warning(1123, "Parameter -ACHSE wird ignoriert, da der Parameter -SPERRE den Wert NOSPERRE hat\n");
+ }
+
write_fortschritt("Die Kommandozeilen-Parameter wurden ausgewertet<-\n");
}
Modified: trunk/src/parameter.h
===================================================================
--- trunk/src/parameter.h 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/parameter.h 2006-03-27 11:04:13 UTC (rev 40)
@@ -24,7 +24,8 @@
public:
TParameter(int argc, char **argv);
- bool IsDebug;
+ bool IsSetDebug;
+ int DebugLevel;
bool IsSetPar;
std::string FileNamePar;
Modified: trunk/src/test_file.cpp
===================================================================
--- trunk/src/test_file.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/test_file.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -61,7 +61,7 @@
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
- LoadDGM(DGMTINFILE, NodeList, ElementList, 0, 100000, true);
+ LoadDGM(DGMTINFILE, NodeList, ElementList, 0, 100000, 9);
printf("Anzahl Knoten: %d\n", NodeList->size());
for (unsigned int i=0; i<NodeList->size(); i++)
@@ -74,15 +74,23 @@
for (unsigned int j=0; j<ElementList->size(); j++)
{
TElement *Element = (*ElementList)[j];
- TNodeList *NL = Element->NodeList;
printf("Knoten die das Element %d bilden:", j);
- for (unsigned int i = 0; i < NL->size(); i++)
+ if (Element->Typ == TRI)
{
- TNode *Node = (*NL)[i];
- printf(" %d", Node->Nr);
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
}
- printf("\n");
+ else
+ {
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ TNode *Node4 = Element->Node4;
+ printf(" %d %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr, Node4->Nr);
+ }
}
NodeList->Clear();
@@ -92,7 +100,7 @@
////////////////////////////////////////
////////////////////////////////////////
- LoadDGM(DGMXYZFILE, NodeList, ElementList, 0, 100000, true);
+ LoadDGM(DGMXYZFILE, NodeList, ElementList, 0, 100000, 9);
printf("Anzahl Knoten: %d\n", NodeList->size());
for (unsigned int i=0; i<NodeList->size(); i++)
@@ -105,15 +113,23 @@
for (unsigned int j=0; j<ElementList->size(); j++)
{
TElement *Element = (*ElementList)[j];
- TNodeList *NL = Element->NodeList;
printf("Knoten die das Element %d bilden:", j);
- for (unsigned int i = 0; i < NL->size(); i++)
+ if (Element->Typ == TRI)
{
- TNode *Node = (*NL)[i];
- printf(" %d", Node->Nr);
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
}
- printf("\n");
+ else
+ {
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ TNode *Node4 = Element->Node4;
+ printf(" %d %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr, Node4->Nr);
+ }
}
////////////////////////////////////////
@@ -122,7 +138,7 @@
NodeList->Clear();
ElementList->Clear();
- LoadDGM(DGMXYZFILE2, NodeList, ElementList, 0, 100000, true);
+ LoadDGM(DGMXYZFILE2, NodeList, ElementList, 0, 100000, 9);
printf("Anzahl Knoten: %d\n", NodeList->size());
printf("Anzahl Elemente in Elementliste: %d\n", ElementList->size());
@@ -154,7 +170,7 @@
TProfilList *ProfilList = new TProfilList();
- LoadProfile(PROFILFILE, ProfilList);
+ LoadProfile(PROFILFILE, ProfilList, 9);
int Anz = 0;
for (TProfilList::iterator i = ProfilList->begin(); i != ProfilList->end(); i++)
@@ -174,7 +190,7 @@
ProfilList->clear();
- LoadProfile(PROFILZFILE, ProfilList);
+ LoadProfile(PROFILZFILE, ProfilList, 9);
Anz = 0;
for (TProfilList::iterator i = ProfilList->begin(); i != ProfilList->end(); i++)
Modified: trunk/src/test_tri.cpp
===================================================================
--- trunk/src/test_tri.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/test_tri.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -50,15 +50,23 @@
for (unsigned int j=0; j<EL->size(); j++)
{
TElement *Element = (*EL)[j];
- TNodeList *NL = Element->NodeList;
printf("Knoten die das Element %d bilden:", j);
- for (unsigned int i = 0; i < NL->size(); i++)
+ if (Element->Typ == TRI)
{
- TNode *Node = (*NL)[i];
- printf(" %d", Node->Nr);
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
}
- printf("\n");
+ else
+ {
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ TNode *Node4 = Element->Node4;
+ printf(" %d %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr, Node4->Nr);
+ }
}
TNode *N04 = new TNode(4, 1.0, 9.0, 0.0);
@@ -89,18 +97,26 @@
for (unsigned int j=0; j<EL->size(); j++)
{
TElement *Element = (*EL)[j];
- TNodeList *NL = Element->NodeList;
printf("Knoten die das Element %d bilden:", j);
- for (unsigned int i = 0; i < NL->size(); i++)
+ if (Element->Typ == TRI)
{
- TNode *Node = (*NL)[i];
- printf(" %d", Node->Nr);
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
}
- printf("\n");
+ else
+ {
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ TNode *Node4 = Element->Node4;
+ printf(" %d %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr, Node4->Nr);
+ }
}
- SaveNet("test_tri.2dm", NL, EL, true);
+ SaveNet("test_tri.2dm", NL, EL, 9);
delete EL;
Modified: trunk/src/test_xy.cpp
===================================================================
--- trunk/src/test_xy.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/test_xy.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -671,133 +671,25 @@
for (unsigned int j=0; j<ElL->size(); j++)
{
TElement *Element = (*ElL)[j];
- TNodeList *NL = Element->NodeList;
printf("Knoten die das Element %d bilden:", j);
- for (unsigned int i = 0; i < NL->size(); i++)
+ if (Element->Typ == TRI)
{
- TNode *Node = (*NL)[i];
- printf(" %d", Node->Nr);
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
}
- printf("\n");
+ else
+ {
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+ TNode *Node4 = Element->Node4;
+ printf(" %d %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr, Node4->Nr);
+ }
}
- printf("\nÜberprüfen, ob ein Punkt innerhalb oder ausserhalb eines Elements liegt\n\n");
-
- TElement *Element = (*ElL)[0];
- TNodeList *NL = Element->NodeList;
-
- printf("Knoten die das Element %d bilden:\n", 0);
- for (unsigned int i = 0; i < NL->size(); i++)
- {
- TNode *Node = (*NL)[i];
- printf(" %d (%.3f,%.3f,%.3f)\n", Node->Nr, Node->X, Node->Y, Node->Z);
- }
- printf("\n");
-
- double X = 6.0;
- double Y = 3.0;
- try
- {
- TInsideTyp IsInside = Element->IsInsideElement(X, Y);
-
- if (INSIDE == IsInside) printf("(%.3f, %.3f) ist im Element\n", X, Y);
- else if (ON_LINE == IsInside) printf("(%.3f, %.3f) ist auf dem Rand des Elementes\n", X, Y);
- else if (NOT_INSIDE == IsInside) printf("(%.3f, %.3f) ist nicht im Element\n", X, Y);
- else dump_error(__FILE__, __LINE__, "InsideTyp %d ist unbekannt", IsInside);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
-
- X = 3.0;
- Y = 6.0;
- try
- {
- TInsideTyp IsInside = Element->IsInsideElement(X, Y);
-
- if (INSIDE == IsInside) printf("(%.3f, %.3f) ist im Element\n", X, Y);
- else if (ON_LINE == IsInside) printf("(%.3f, %.3f) ist auf dem Rand des Elementes\n", X, Y);
- else if (NOT_INSIDE == IsInside) printf("(%.3f, %.3f) ist nicht im Element\n", X, Y);
- else dump_error(__FILE__, __LINE__, "InsideTyp %d ist unbekannt", IsInside);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
-
- X = 6.0;
- Y = 6.0;
- try
- {
- TInsideTyp IsInside = Element->IsInsideElement(X, Y);
-
- if (INSIDE == IsInside) printf("(%.3f, %.3f) ist im Element\n", X, Y);
- else if (ON_LINE == IsInside) printf("(%.3f, %.3f) ist auf dem Rand des Elementes\n", X, Y);
- else if (NOT_INSIDE == IsInside) printf("(%.3f, %.3f) ist nicht im Element\n", X, Y);
- else dump_error(__FILE__, __LINE__, "InsideTyp %d ist unbekannt", IsInside);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
- X = 1.0;
- Y = 1.0;
- try
- {
- TInsideTyp IsInside = Element->IsInsideElement(X, Y);
-
- if (INSIDE == IsInside) printf("(%.3f, %.3f) ist im Element\n", X, Y);
- else if (ON_LINE == IsInside) printf("(%.3f, %.3f) ist auf dem Rand des Elementes\n", X, Y);
- else if (NOT_INSIDE == IsInside) printf("(%.3f, %.3f) ist nicht im Element\n", X, Y);
- else dump_error(__FILE__, __LINE__, "InsideTyp %d ist unbekannt", IsInside);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
- X = 9.0;
- Y = 9.0;
- try
- {
- TInsideTyp IsInside = Element->IsInsideElement(X, Y);
-
- if (INSIDE == IsInside) printf("(%.3f, %.3f) ist im Element\n", X, Y);
- else if (ON_LINE == IsInside) printf("(%.3f, %.3f) ist auf dem Rand des Elementes\n", X, Y);
- else if (NOT_INSIDE == IsInside) printf("(%.3f, %.3f) ist nicht im Element\n", X, Y);
- else dump_error(__FILE__, __LINE__, "InsideTyp %d ist unbekannt", IsInside);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
- // Hier wird die umgekehrte Orientierung eines Elementes getestet
- // vergleiche Element 0 und Element 1 bei der Erzeugung oben
-
- Element = (*ElL)[1];
-
- X = 6.0;
- Y = 3.0;
- try
- {
- TInsideTyp IsInside = Element->IsInsideElement(X, Y);
-
- if (INSIDE == IsInside) printf("(%.3f, %.3f) ist im Element\n", X, Y);
- else if (ON_LINE == IsInside) printf("(%.3f, %.3f) ist auf dem Rand des Elementes\n", X, Y);
- else if (NOT_INSIDE == IsInside) printf("(%.3f, %.3f) ist nicht im Element\n", X, Y);
- else dump_error(__FILE__, __LINE__, "InsideTyp %d ist unbekannt", IsInside);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
delete ElL;
delete NL1;
Modified: trunk/src/tools.cpp
===================================================================
--- trunk/src/tools.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/tools.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -212,7 +212,7 @@
//---------------------------------------------------------------------------
void* SfRealloc(void *pMem, int nNewSize)
{
- if( pMem == NULL ) return(malloc(nNewSize));
+ if (pMem == NULL) return(malloc(nNewSize));
else return(realloc(pMem, nNewSize));
}
//---------------------------------------------------------------------------
@@ -250,7 +250,7 @@
Bytes[1] = Bytes[6];
Bytes[6] = Temp;
- Temp = Bytes[2];
+ Temp = Bytes[2];
Bytes[2] = Bytes[5];
Bytes[5] = Temp;
@@ -349,84 +349,79 @@
}
//---------------------------------------------------------------------------
-size_t CheckMemory(bool Debug)
+long CheckSpeed(int DebugLevel)
{
- write_fortschritt("->Ermitteln der Speicherauslastung\n");
+ write_fortschritt("->Ermitteln der Geschwindigkeit\n");
- size_t MaxMemSize = 2UL * 1024UL * 1024UL * 1024UL;
- if (Debug) MaxMemSize = 200000000;
+ long Duration = 10 * 1000;
- while (MaxMemSize > 0)
+ unsigned long MemSegSize = 0;
+ long DiffMSec = 0;
+
+ if (DebugLevel >= 8)
{
- void* Mem = malloc(MaxMemSize);
+ // Dies ist nur für reproduzierbare Debug-Ergebnisse auf
+ // verschiedenen Computern drin
- if (Mem)
- {
- free(Mem);
- break;
- }
- else
- {
- if (Debug)
- {
- write_fortschritt("%d MB stehen NICHT zur Verfügung\n", MaxMemSize / 1024 / 1024);
- }
- }
- MaxMemSize = MaxMemSize - (10 * 1024 * 1024);
+ MemSegSize = 300 * 1024 * 1024;
+ DiffMSec = Duration;
}
+ else
+ {
+ struct timeb Start;
+ ftime (&Start);
+
long StartMSec = Start.time * 1000 + Start.millitm;
- write_fortschritt("%d MB stehen zur Verfügung\n", MaxMemSize / 1024 / 1024);
+ struct timeb Now;
+ ftime (&Now);
+
long NowMSec = Now.time * 1000 + Now.millitm;
+
+
unsigned long MemSegSizeInc = 50 * 1024 * 1024; // 20 MB Blöcke
+ MemSegSize = MemSegSizeInc;
+ unsigned long *Mem = 0;
- write_fortschritt("Ermitteln der Speicherauslastung beendet<-\n");
+ DiffMSec = NowMSec - StartMSec;
+ while (DiffMSec < Duration)
+ {
+ write_fortschritt("%.2f von %.2f Sekunden getestet\n", DiffMSec / 1000.0, Duration / 1000.0);
- return (MaxMemSize);
-}
+ Mem = (unsigned long *)SfRealloc(Mem, MemSegSize);
-//---------------------------------------------------------------------------
-long CheckSpeed(bool Debug)
-{
- write_fortschritt("->Ermitteln der Geschwindigkeit\n");
+ for (unsigned long i = 0L; i < MemSegSize / sizeof(*Mem); i=i+sizeof(*Mem))
+ {
+ Mem[i] = i;
- struct timeb Now;
- ftime (&Now);
+ if (i % 100000 == 0)
+ {
+ ftime (&Now);
+ NowMSec = Now.time * 1000 + Now.millitm;
+ DiffMSec = NowMSec - StartMSec;
- long StartMSec = Now.time * 1000 + Now.millitm;
+ if (DiffMSec > Duration) break;
+ }
+ }
- long DiffMSec = 0L;
+ MemSegSize = MemSegSize + MemSegSizeInc;
- long Flops = 0;
-
- double Dummy = 0.0;
-
- do
- {
- if (Debug)
- {
- if (Flops % 100000 == 0) write_fortschritt("%d Flops berechnet\n", Flops);
+ ftime (&Now);
+ NowMSec = Now.time * 1000 + Now.millitm;
+ DiffMSec = NowMSec - StartMSec;
}
- Dummy = Flops * 123.355 / 0.023;
+ write_fortschritt("Gebe %.2f MB Speicher wieder frei\n", MemSegSize / 1024.0 / 1024.0);
- Flops = Flops + 1;
+ free(Mem);
- struct timeb Now;
ftime (&Now);
-
- int NowMSec = Now.time * 1000 + Now.millitm;
-
+ NowMSec = Now.time * 1000 + Now.millitm;
DiffMSec = NowMSec - StartMSec;
+ }
- } while (DiffMSec < 2000);
+ write_fortschritt("%.2f MB Speicher in %.2f sec bearbeitet (%.2f MB/s)\n", MemSegSize / 1024.0 / 1024.0, DiffMSec / 1000.0, MemSegSize / 1024.0 / 1024.0 / (DiffMSec / 1000.0));
- if (Debug) Flops = 1840000;
-
- write_fortschritt("%.3f MFlops berechnet\n", Flops / 1000.0 / 1000.0);
-
- if (DiffMSec > 10000) write_fortschritt("%d Dummy\n", Dummy);
-
write_fortschritt("Ermitteln der Geschwindigkeit beendet<-\n");
- return (Flops);
+ return (MemSegSize / DiffMSec);
}
//---------------------------------------------------------------------------
@@ -496,14 +491,17 @@
}
//---------------------------------------------------------------------------
-void InterpolateWsp(TProfilList *ProfilList, TProfilList *WspProfilList, bool Debug)
+void InterpolateWsp(TProfilList *ProfilList, TProfilList *WspProfilList, int DebugLevel)
{
write_fortschritt ("->Wasserstände werden interpoliert\n");
- int Anz = 0;
+ int Count = 0;
for (TProfilList::iterator i=ProfilList->begin(); i != ProfilList->end(); i++)
{
- if (Anz > 0 && Anz % 100 == 0) write_fortschritt ("%d Profile bearbeitet\n", Anz);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10 == 0) || (Count > 0 && Count % 100 == 0))
+ {
+ write_fortschritt ("%d Profile bearbeitet\n", Count);
+ }
TProfil *Profil = *i;
@@ -525,31 +523,31 @@
if (UnderProfil->Station == Profil->Station)
{
Profil->Wsp = UnderProfil->Wsp;
- if (Debug) write_fortschritt("Für das Profil %.4f konnte der Wasserstand %.2f übernommen werden\n", Profil->Station / 10000.0, Profil->Wsp);
+ if (DebugLevel >= 2) write_fortschritt("Für das Profil %.4f konnte der Wasserstand %.2f übernommen werden\n", Profil->Station / 10000.0, Profil->Wsp);
}
else if (OverProfil->Station == Profil->Station)
{
Profil->Wsp = OverProfil->Wsp;
- if (Debug) write_fortschritt("Für das Profil %.4f konnte der Wasserstand %.2f übernommen werden ßn", Profil->Station / 10000.0, Profil->Wsp);
+ if (DebugLevel >= 2) write_fortschritt("Für das Profil %.4f konnte der Wasserstand %.2f übernommen werden ßn", Profil->Station / 10000.0, Profil->Wsp);
}
else if (UnderProfil->Station <= Profil->Station && OverProfil->Station >= Profil->Station)
{
Profil->Wsp = UnderProfil->Wsp + (OverProfil->Wsp - UnderProfil->Wsp) * (Profil->Station - UnderProfil->Station) / (OverProfil->Station - UnderProfil->Station);
- if (Debug) write_fortschritt("Für das Profil %.4f konnte der Wasserstand %.2f interpoliert werden\n", Profil->Station / 10000.0, Profil->Wsp);
+ if (DebugLevel >= 2) write_fortschritt("Für das Profil %.4f konnte der Wasserstand %.2f interpoliert werden\n", Profil->Station / 10000.0, Profil->Wsp);
}
else
{
write_error(2203, "Für das Profil %.4f konnte kein Wasserstand interpoliert werden\n", Profil->Station / 10000.0);
}
- Anz++;
+ Count++;
}
- write_fortschritt ("%d Profile bearbeitet\n", Anz);
+ write_fortschritt ("%d Profile bearbeitet\n", Count);
write_fortschritt ("Wasserstände wurden interpoliert<-\n");
}
//---------------------------------------------------------------------------
-TProfilMap BuildGewaesserListen(TProfilList *ProfilList, bool Debug)
+TProfilMap BuildGewaesserListen(TProfilList *ProfilList, int DebugLevel)
{
write_fortschritt ("->Gewässerlisten werden erzeugt\n");
@@ -577,7 +575,7 @@
}
}
- if (Debug)
+ if (DebugLevel >= 3)
{
for (TProfilMap::iterator i = ProfilMap.begin(); i != ProfilMap.end(); i++)
{
@@ -599,7 +597,7 @@
}
//---------------------------------------------------------------------------
-void BuildPolygon(TProfilList *ProfilList, TXYList *XyList, bool Debug)
+void BuildPolygon(TProfilList *ProfilList, TXYList *XyList, int DebugLevel)
{
write_fortschritt ("->Begrenzungspolygon wird erzeugt\n");
@@ -614,8 +612,10 @@
TProfilList::iterator ProfilIter = ProfilList->begin();
for (unsigned int i = 0; i < ProfilList->size()-1; i++)
{
- if (Debug && Count % 100 == 0) write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
- else if (Count % 1000 == 0) write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
+ }
TProfil* Profil = *ProfilIter;
@@ -639,8 +639,10 @@
TProfilList::reverse_iterator RProfilIter = ProfilList->rbegin();
for (unsigned int i = ProfilList->size()-1; i > 0; i--)
{
- if (Debug && Count % 100 == 0) write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
- else if (Count % 1000 == 0) write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
+ }
TProfil* Profil = *RProfilIter;
@@ -662,8 +664,7 @@
}
write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
-/*
- if (Debug)
+ if (DebugLevel >= 3)
{
write_fortschritt("Polygon:\n");
for (TXYList::iterator j = XyList->begin(); j != XyList->end(); j++)
@@ -672,13 +673,12 @@
write_fortschritt("%.3f %.3f\n", Xy->X, Xy->Y);
}
}
-*/
write_fortschritt ("Begrenzungspolygon wurde erzeugt<-\n");
}
//---------------------------------------------------------------------------
-void CheckForDuplicates(TNodeList *NodeList, bool Debug)
+void CheckForDuplicates(TNodeList *NodeList, int DebugLevel)
{
write_fortschritt ("->Doppelte Knoten werden gesucht\n");
@@ -717,7 +717,7 @@
if (Dx < 0.01 && Dx > -0.01 && Dy < 0.01 && Dy > -0.01)
{
- if (Debug)
+ if (DebugLevel >= 3)
{
write_fortschritt("Lösche Knoten %d (%.2f, %.2f)\Er ist ident mit Knoten %d (%.2f, %.2f)\n", FirstNode->Nr, FirstNode->X, FirstNode->Y, NextNode->Nr, NextNode->X, NextNode->Y);
}
@@ -727,15 +727,13 @@
}
}
- write_fortschritt ("%d Knoten gelöscht\n", AnzDeleted);
+ write_fortschritt ("%d Knoten gelöscht, %d Knoten vorhanden\n", AnzDeleted, NodeList->size());
- write_fortschritt ("%d Knoten vorhanden\n", NodeList->size());
-
write_fortschritt ("Doppelte Knoten wurden gesucht<-\n");
}
//---------------------------------------------------------------------------
-void BuildEdgeList(TEdgeList* EdgeList, TElementList* ElementList, bool Debug)
+void BuildEdgeList(TEdgeList* EdgeList, TElementList* ElementList, int DebugLevel)
{
write_fortschritt ("->Kanten werden erzeugt\n");
@@ -747,26 +745,28 @@
int Count = 0;
for (TElementList::iterator i=ElementList->begin(); i!=ElementList->end(); i++)
{
- if (Debug && Count % 10000 == 0) write_fortschritt("%d von %d Elementen bearbeitert, %d Kanten erzeugt.\n", Count, ElementList->size(), EdgeList->Anz);
- else if (Count % 100000 == 0) write_fortschritt("%d von %d Elementen bearbeitert, %d Kanten erzeugt.\n", Count, ElementList->size(), EdgeList->Anz);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 1000 == 0) || (Count > 0 && Count % 10000 == 0))
+ {
+ write_fortschritt("%d von %d Elementen bearbeitet, %d Kanten erzeugt.\n", Count, ElementList->size(), EdgeList->Anz);
+ }
TElement *Element = *i;
- TNodeList::iterator N3 = Element->NodeList->begin();
- TNodeList::iterator N1 = N3++;
- TNodeList::iterator N2 = N3++;
+ TNode* N1 = Element->Node1;
+ TNode* N2 = Element->Node2;
+ TNode* N3 = Element->Node3;
- AntiEdge = EdgeList->Find((*N2)->Nr, (*N1)->Nr);
+ AntiEdge = EdgeList->Find(N2->Nr, N1->Nr);
if (AntiEdge == 0)
{
// Im moment gehe ich mal davon aus, dass es eine neue Randkante ist
- NewEdge = EdgeList->Add(*N1, *N2);
+ NewEdge = EdgeList->Add(N1, N2);
NewEdge->IsBoundary = true;
}
else
{
// Mal sehen welche ich behalte
- if ((*N1)->Nr > (*N2)->Nr)
+ if (N1->Nr > N2->Nr)
{
// die alte ist besser, aber keine Randkante
AntiEdge->IsBoundary = false;
@@ -775,22 +775,22 @@
{
// Die neue ist besser, aber keine Randkante
EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(*N1, *N2);
+ NewEdge = EdgeList->Add(N1, N2);
NewEdge->IsBoundary = false;
}
}
- AntiEdge = EdgeList->Find((*N3)->Nr, (*N2)->Nr);
+ AntiEdge = EdgeList->Find(N3->Nr, N2->Nr);
if (AntiEdge == 0)
{
// Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(*N2, *N3);
+ NewEdge = EdgeList->Add(N2, N3);
NewEdge->IsBoundary = true;
}
else
{
// Mal sehen welche ich behalte
- if ((*N2)->Nr > (*N3)->Nr)
+ if (N2->Nr > N3->Nr)
{
// die alte ist besser, aber keine Randkante
AntiEdge->IsBoundary = false;
@@ -799,24 +799,24 @@
{
// Die neue ist besser, aber keine Randkante
EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(*N2, *N3);
+ NewEdge = EdgeList->Add(N2, N3);
NewEdge->IsBoundary = false;
}
}
if (Element->Typ == TRI)
{
- AntiEdge = EdgeList->Find((*N1)->Nr, (*N3)->Nr);
+ AntiEdge = EdgeList->Find(N1->Nr, N3->Nr);
if (AntiEdge == 0)
{
// Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(*N3, *N1);
+ NewEdge = EdgeList->Add(N3, N1);
NewEdge->IsBoundary = true;
}
else
{
// Mal sehen welche ich behalte
- if ((*N3)->Nr > (*N1)->Nr)
+ if (N3->Nr > N1->Nr)
{
// die alte ist besser, aber keine Randkante
AntiEdge->IsBoundary = false;
@@ -825,27 +825,26 @@
{
// Die neue ist besser, aber keine Randkante
EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(*N3, *N1);
+ NewEdge = EdgeList->Add(N3, N1);
NewEdge->IsBoundary = false;
}
}
}
else
{
- TNodeList::iterator N4 = N3;
- N4++;
+ TNode* N4 = Element->Node4;
- AntiEdge = EdgeList->Find((*N4)->Nr, (*N3)->Nr);
+ AntiEdge = EdgeList->Find(N4->Nr, N3->Nr);
if (AntiEdge == 0)
{
// Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(*N3, *N4);
+ NewEdge = EdgeList->Add(N3, N4);
NewEdge->IsBoundary = true;
}
else
{
// Mal sehen welche ich behalte
- if ((*N3)->Nr > (*N4)->Nr)
+ if (N3->Nr > N4->Nr)
{
// die alte ist besser, aber keine Randkante
AntiEdge->IsBoundary = false;
@@ -854,22 +853,22 @@
{
// Die neue ist besser, aber keine Randkante
EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(*N3, *N4);
+ NewEdge = EdgeList->Add(N3, N4);
NewEdge->IsBoundary = false;
}
}
- AntiEdge = EdgeList->Find((*N1)->Nr, (*N4)->Nr);
+ AntiEdge = EdgeList->Find(N1->Nr, N4->Nr);
if (AntiEdge == 0)
{
// Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(*N4, *N1);
+ NewEdge = EdgeList->Add(N4, N1);
NewEdge->IsBoundary = true;
}
else
{
// Mal sehen welche ich behalte
- if ((*N4)->Nr > (*N1)->Nr)
+ if (N4->Nr > N1->Nr)
{
// die alte ist besser, aber keine Randkante
AntiEdge->IsBoundary = false;
@@ -878,23 +877,25 @@
{
// Die neue ist besser, aber keine Randkante
EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(*N4, *N1);
+ NewEdge = EdgeList->Add(N4, N1);
NewEdge->IsBoundary = false;
}
}
}
Count++;
}
- write_fortschritt("%d von %d Elementen bearbeitert, %d Kanten erzeugt.\n", Count, ElementList->size(), EdgeList->Anz);
+ write_fortschritt("%d von %d Elementen bearbeitet, %d Kanten erzeugt.\n", Count, ElementList->size(), EdgeList->Anz);
- if (Debug)
+ if (DebugLevel >= 8)
{
Count = 0;
TEdgeListNrSorted::iterator i = EdgeList->EdgeListNrSorted.begin();
while (i != EdgeList->EdgeListNrSorted.end())
{
- if (Debug && Count % 10000 == 0) write_fortschritt("%d Kanten getestet\n", Count);
- else if (Count % 100000 == 0) write_fortschritt("%d Kanten getestet\n", Count);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
+ {
+ write_fortschritt("%d von %d Kanten getestet\n", Count, EdgeList->EdgeListNrSorted.size());
+ }
TEdge *Edge = *i++;
@@ -913,14 +914,14 @@
Count++;
}
- write_fortschritt("%d Kanten getestet\n", Count);
+ write_fortschritt("%d von %d Kanten getestet\n", Count, EdgeList->EdgeListNrSorted.size());
}
write_fortschritt ("Kanten wurden erzeugt<-\n");
}
//---------------------------------------------------------------------------
-void BuildProfilNodeList(TProfilList *ProfilList, TNodeList *NodeList, TGewaesserAchseList *GewaesserAchseList, TNodeList *ProfilNodeList, double AvgDistance, bool Sperre, bool Debug)
+void BuildProfilNodeList(TProfilList *ProfilList, TNodeList *NodeList, TGewaesserAchseList *GewaesserAchseList, TNodeList *ProfilNodeList, double AvgDistance, bool Sperre, int DebugLevel)
{
write_fortschritt ("->Knotenliste wird aus den Profilspuren generiert\n");
@@ -929,12 +930,13 @@
ProfilNodeList->Clear();
int NodeNr = 0;
-
int Count = 0;
for (TProfilList::iterator i = ProfilList->begin(); i != ProfilList->end(); i++)
{
- if (Debug && Count % 10 == 0) write_fortschritt("%d Profile getestet %d Knoten erzeugt\n", Count, NodeNr);
- else if (Count % 100 == 0) write_fortschritt("%d Profile getestet %d Knoten erzeugt\n", Count, NodeNr);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Profilen getestet, %d Knoten erzeugt\n", Count, ProfilList->size(), NodeNr);
+ }
TProfil* Profil = *i;
@@ -972,8 +974,10 @@
if (false == Found)
{
// Dies bedeutet, die Profile ragen aus dem DGM raus oder die Punkte sind lokal sehr weit auseinander
-
- // if (Debug) write_warning(9999, "Es konnte für einen Profilpunkt keine Höhe interpoliert werden\n");
+ if (DebugLevel >= 8)
+ {
+ write_warning(9999, "Es konnte für den Profilpunkt (%.2f, %.2f) keine Höhe interpoliert werden\n", X, Y);
+ }
continue;
}
@@ -1008,7 +1012,10 @@
{
// Dies bedeutet, die Profile ragen aus dem DGM raus oder die Punkte sind lokal sehr weit auseinander
- // if (Debug) write_warning(9999, "Es konnte für einen Profilpunkt keine Höhe interpoliert werden");
+ if (DebugLevel >= 8)
+ {
+ write_warning(9999, "Es konnte für den Profilpunkt (%.2f, %.2f) keine Höhe interpoliert werden\n", X, Y);
+ }
continue;
}
@@ -1027,13 +1034,13 @@
}
Count++;
}
- write_fortschritt("%d Profile getestet %d Knoten erzeugt\n", Count, NodeNr);
+ write_fortschritt("%d von %d Profilen getestet, %d Knoten erzeugt\n", Count, ProfilList->size(), NodeNr);
write_fortschritt ("Knotenliste wurde aus den Profilspuren generiert<-\n");
}
//---------------------------------------------------------------------------
-void TransferWsp(TNodeList *ProfilNodeList, TNodeList *NodeList, double AvgDistance, bool Debug)
+void TransferWsp(TNodeList *ProfilNodeList, TNodeList *NodeList, double AvgDistance, int DebugLevel)
{
write_fortschritt ("->Wasserstände werden übertragen\n");
@@ -1043,8 +1050,10 @@
int Count = 0;
for (TNodeList::iterator i = NodeList->begin(); i != NodeList->end(); i++)
{
- if (Debug && Count % 1000 == 0) write_fortschritt("%d Knoten getestet, %d Wasserstände übertragen\n", Count, WspCount);
- else if (Count % 10000 == 0) write_fortschritt("%d Knoten getestet, %d Wasserstände übertragen\n", Count, WspCount);
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 1000 == 0) || (Count > 0 && Count % 10000 == 0))
+ {
+ write_fortschritt("%d von %d Knoten getestet, %d Wasserstände übertragen\n", Count, NodeList->size(), WspCount);
+ }
TNode* Node = *i;
@@ -1065,12 +1074,61 @@
}
Count++;
}
- write_fortschritt("%d Knoten getestet, %d Wasserstände übertragen\n", Count, WspCount);
+ write_fortschritt("%d von %d Knoten getestet, %d Wasserstände übertragen\n", Count, NodeList->size(), WspCount);
write_fortschritt ("Wasserstände wurden übertragen<-\n");
}
//---------------------------------------------------------------------------
+void GetWspFromNodeList(TProfilList* BruchList, TNodeList* NodeList, double AvgDistance, int DebugLevel)
+{
+ write_fortschritt ("->Wasserstände für Brüche werden ermittelt\n");
+
+ int Count = 0;
+ for (TProfilList::iterator i = BruchList->begin(); i != BruchList->end(); i++)
+ {
+ TProfil* Bruch = *i;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("Für Bruch %d von %d wird der Wasserstand ermittelt\n", Count, BruchList->size());
+ }
+
+ double MaxWsp = 0.0;
+ int WspCount = 0;
+ for (TPointList::iterator j = Bruch->PointList->begin(); j != Bruch->PointList->end(); j++)
+ {
+ TPoint* Point = *j;
+
+ double X = Point->X;
+ double Y = Point->Y;
+
+ double ZDummy = 0.0;
+ double Wsp = 0.0;
+ bool Found = NodeList->Interpolate(X, Y, AvgDistance, &ZDummy, &Wsp);
+
+ if (Found)
+ {
+ if (WspCount == 0 || MaxWsp < Wsp)
+ {
+ MaxWsp = Wsp;
+ if (DebugLevel >= 3) write_fortschritt("Für Bruch %d ist der bisher höchste Wasserstand (%.3f) ermittelt worden.\n", Count, MaxWsp);
+ }
+ WspCount++;
+ }
+ }
+
+ if (WspCount > 0) Bruch->Wsp = MaxWsp;
+ else Bruch->Wsp = -9999.9;
+
+ Count++;
+ }
+ write_fortschritt("Für Bruch %d von %d wird der Wasserstand ermittelt\n", Count, BruchList->size());
+
+ write_fortschritt ("->Wasserstände für Brüche wurden ermittelt\n");
+}
+
+//---------------------------------------------------------------------------
double TwoToWin (double x0, double y0, double x1, double y1)
{
double Win;
@@ -1392,12 +1450,11 @@
}
//---------------------------------------------------------------------------
-void NassTrockenBerechnung(std::string FileName, TNodeList *NodeList, TEdgeList *EdgeList, TErgebnisPolygonList* ErgebnisPolygone, double Von, double Bis, double Diff, bool Debug)
+void NassTrockenBerechnung(TNodeList *NodeList, TEdgeList *EdgeList, TErgebnisPolygonList* ErgebnisPolygone, double Von, double Bis, double Diff, int DebugLevel)
{
write_fortschritt("->Überschwemmungsgrenzen werden ermittelt.\n");
- TNodeList *SaveNodeList = new TNodeList;
- SaveNodeList = NodeList->Copy();
+ TNodeList *SaveNodeList = NodeList->Copy();
if (Diff <= 0.0)
{
@@ -1451,7 +1508,7 @@
}
*/
- if (Debug) write_fortschritt("Maximaler Wasserstand wird ermittelt.\n");
+ if (DebugLevel >= 2) write_fortschritt("Maximaler Wasserstand wird ermittelt.\n");
// Maximalen Wasserstand ermitteln
double MaxWsp = 0.0;
@@ -1462,7 +1519,7 @@
if (i == NodeList->begin() || MaxWsp < Node->Wsp) MaxWsp = Node->Wsp;
}
- if (Debug) write_fortschritt("Sicher trockene Knoten werden ermittelt.\n");
+ if (DebugLevel >=2) write_fortschritt("Sicher trockene Knoten werden ermittelt.\n");
// Anzahl der Knoten bestimmen, die höher als der maximale Wassrstand sind
// oder die schon einen Wasserstand haben
@@ -1474,7 +1531,7 @@
if (Node->Wsp > -9999 || Node->Z > MaxWsp) Ready++;
}
- if (Debug) write_fortschritt("Die ersten Kanten ermitteln, an denen ein Nass/Trocken-Übergng stattfindet.\n");
+ if (DebugLevel >= 2) write_fortschritt("Die ersten Kanten ermitteln, an denen ein Nass/Trocken-Übergng stattfindet.\n");
// Die Kanten bestimmen, die an einem Ende einen nassen und am anderen Ende einen trockenen Knoten haben
// Dies ist die Anfangskanten
@@ -1493,12 +1550,15 @@
}
}
- if (Debug) write_fortschritt("Jetzt die Wasserstände weitertragen.\n");
+ if (DebugLevel >= 2) write_fortschritt("Jetzt die Wasserstände weitertragen.\n");
TEdgeList *TempEdgeList = new TEdgeList();
int Changed = 0;
+ int Run = 0;
do
{
+ write_fortschritt("Durchlauf %d\n", ++Run);
+
// Hier nur die Verwaltungsinformationen, aber nicht die richtigen Kanten löschen
// Es waren nur geliehene Kanten
TempEdgeList->Empty();
@@ -1622,7 +1682,7 @@
Edge->Ready = false;
}
- if (Debug) write_fortschritt("Jetzt die Nass/Trocken-Überganänge auf den Kanten bestimmen.\n");
+ if (DebugLevel >= 2) write_fortschritt("Jetzt die Nass/Trocken-Übergänge auf den Kanten bestimmen.\n");
// Jetzt die Nass/Trocken Übergänge bestimmen
int FoundWetDry = 0;
@@ -1679,9 +1739,8 @@
// Jetzt sind alle Nass/Trockenübergänge bestimmt
+ if (DebugLevel >= 2) write_fortschritt("Jetzt die Nass/Trocken-Übergänge verbinden.\n");
- if (Debug) write_fortschritt("Jetzt die Nass/Trocken-Überganänge verbinden.\n");
-
// Jetzt muss man sie nur noch verbinden
bool FoundStartChangeEdge = false;
@@ -1727,6 +1786,9 @@
} while (FoundStartChangeEdge);
}
+
+ delete SaveNodeList;
+
write_fortschritt("Überschwemmungsgrenzen wurden ermittelt.<-\n");
}
Modified: trunk/src/tools.h
===================================================================
--- trunk/src/tools.h 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/tools.h 2006-03-27 11:04:13 UTC (rev 40)
@@ -54,21 +54,21 @@
std::string ToUpperCase(std::string InString);
double CrossProduct(TNode *n1, TNode *n2, TNode *n3);
bool CircumCircle(TNode *n1, TNode *n2, TNode *n3, double *x, double *y, double *r);
-size_t CheckMemory(bool IsDebug);
-long CheckSpeed(bool IsDebug);
+long CheckSpeed(int DebugLevel);
const char* ShapeTypeName(TShpType ShapeType);
const char* ShapePartTypeName(TPartType PartType);
char* SkipSpaces(char* P);
char* GetCol(char* P);
-void InterpolateWsp(TProfilList *ProfilList, TProfilList *WspProfilList, bool Debug);
-TProfilMap BuildGewaesserListen(TProfilList *ProfilList, bool Debug);
-void BuildPolygon(TProfilList *ProfilList, TXYList *XyList, bool Debug);
+void InterpolateWsp(TProfilList *ProfilList, TProfilList *WspProfilList, int DebugLevel);
+TProfilMap BuildGewaesserListen(TProfilList *ProfilList, int DebugLevel);
+void BuildPolygon(TProfilList *ProfilList, TXYList *XyList, int DebugLevel);
void EqualizeProfil(TProfil *ProfilOne, TProfil *ProfilTwo);
-void CheckForDuplicates(TNodeList *NodeList, bool Debug);
-void BuildEdgeList(TEdgeList* EdgeList, TElementList* ElementList, bool Debug);
-void BuildProfilNodeList(TProfilList *ProfilList, TNodeList *NodeList, TGewaesserAchseList *GewaesserAchseList, TNodeList *ProfilNodeList, double AvgDistance, bool Sperre, bool Debug);
-void TransferWsp(TNodeList *ProfilNodeList, TNodeList *NodeList, double AvgDistance, bool Debug);
-void NassTrockenBerechnung(std::string FileName, TNodeList *NodeList, TEdgeList *edgelist, TErgebnisPolygonList* ErgebnisPolygone, double Von, double Bis, double Diff, bool Debug);
+void CheckForDuplicates(TNodeList *NodeList, int DebugLevel);
+void BuildEdgeList(TEdgeList* EdgeList, TElementList* ElementList, int DebugLevel);
+void BuildProfilNodeList(TProfilList *ProfilList, TNodeList *NodeList, TGewaesserAchseList *GewaesserAchseList, TNodeList *ProfilNodeList, double AvgDistance, bool Sperre, int DebugLevel);
+void TransferWsp(TNodeList *ProfilNodeList, TNodeList *NodeList, double AvgDistance, int DebugLevel);
+void GetWspFromNodeList(TProfilList* BruchList, TNodeList* NodeList, double AvgDistance, int DebugLevel);
+void NassTrockenBerechnung(TNodeList *NodeList, TEdgeList *edgelist, TErgebnisPolygonList* ErgebnisPolygone, double Von, double Bis, double Diff, int DebugLevel);
double TwoToWin (double x0, double y0, double x1, double y1);
double ThreeToWin (double x0, double y0, double x1, double y1, double x2, double y2, int turn);
bool Calc2Schnitt (double P0x, double P0y, double P1x, double P1y, double S0x, double S0y, double S1x, double S1y, double *x, double *y, double *lambdap, double *lambdas);
Modified: trunk/src/tri.cpp
===================================================================
--- trunk/src/tri.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/tri.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -20,12 +20,10 @@
#include "tools.h"
#include "tri.h"
-TNodeList* FoundNodeList = new TNodeList();
-TNode* TestNode = new TNode(1, 0.0, 0.0, 0.0);
+TNode TestNode(1, 0.0, 0.0, 0.0);
double cx = 0;
double cy = 0;
double cr = 0;
-TEdge *Edge = 0;
double MinWin = 360.0;
double MaxWin = 0.0;
@@ -86,7 +84,7 @@
// This function is a bit long and may be better split.
//
//---------------------------------------------------------------------
-void CompleteFacet(TNodeList* NodeList, TElementList* ElementList, TEdgeList *TodoEdgeList, TEdgeList *ReadyEdgeList)
+void CompleteFacet(TNodeList* NodeList, TElementList* ElementList, TEdgeList *TodoEdgeList, TEdgeList *ReadyEdgeList, int DebugLevel)
{
TEdge* AktEdge = TodoEdgeList->First();
@@ -108,6 +106,7 @@
int MaxTestAnz = 5;
int TestAnz = 0;
+ TNodeList* FoundNodeList = 0;
do
{
TestAnz++;
@@ -115,12 +114,12 @@
double SX = X - TestAnz * TestAnz * Dy;
double SY = Y + TestAnz * TestAnz * Dx;
- TestNode->X = SX;
- TestNode->Y = SY;
+ TestNode.X = SX;
+ TestNode.Y = SY;
- CircumCircle(Node1, Node2, TestNode, &cx, &cy, &cr);
+ CircumCircle(Node1, Node2, &TestNode, &cx, &cy, &cr);
- NodeList->FindAllByXY(FoundNodeList, cx, cy, sqrt(cr)+0.01);
+ FoundNodeList = NodeList->FindAllByXY(cx, cy, sqrt(cr)+0.01);
if (FoundNodeList->size() <= 2)
{
@@ -160,21 +159,24 @@
double Win = ThreeToWin(X2, Y2, X3, Y3, X1, Y1, 1);
- if (MinWin > Win)
+ if (DebugLevel >= 8)
{
- MinWin = Win;
- write_fortschritt("Minimaler Winkel bisher: %.3f\n", MinWin);
- }
+ if (MinWin > Win)
+ {
+ MinWin = Win;
+ write_fortschritt("Minimaler Winkel bisher: %7.3f, Maximaler Winkel bisher: %7.3f\n", MinWin, MaxWin);
+ }
- if (MaxWin < Win)
- {
- MaxWin = Win;
- write_fortschritt("Maximaler Winkel bisher: %.3f\n", MaxWin);
+ if (MaxWin < Win)
+ {
+ MaxWin = Win;
+ write_fortschritt("Minimaler Winkel bisher: %7.3f, Maximaler Winkel bisher: %7.3f\n", MinWin, MaxWin);
+ }
}
if (Win > 177)
{
- dump_error(__FILE__, __LINE__, "Winkel zu groß");
+ write_warning(9197, "Der Winkel zwischen den Kanten ist zu groß\n");
}
if (Win < 3)
@@ -203,38 +205,19 @@
NewNode = 0;
TNodeList::iterator i = FoundNodeList->begin();
-
- while (i != FoundNodeList->end())
+ if (i != FoundNodeList->end())
{
- TNode* Node = *i++;
-
- double CP = CrossProduct(Node1, Node2, Node);
-
- if (CP > 0.0000001)
- {
- NewNode = Node;
-
- if (NewNode->Nr == Node1->Nr || NewNode->Nr == Node2->Nr)
- {
- dump_error(__FILE__, __LINE__, "Der erste gefundene Knoten ist einer der Kanteknoten");
- }
-
- break;
- }
- else
- {
- dump_error(__FILE__, __LINE__, "Der erste gefundene Knoten ist auf der falschen Seite");
- }
+ NewNode = *i++;
}
if (NewNode)
{
// Find best point to form a triangle
- CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
-
while (i != FoundNodeList->end())
{
+ CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
+
TNode* Node = *i;
if (Node->Nr == Node1->Nr || Node->Nr == Node2->Nr)
@@ -242,54 +225,62 @@
dump_error(__FILE__, __LINE__, "Einer der gefundenen Knoten ist einer der beiden Kantenknoten");
}
- if (Node->Nr != NewNode->Nr)
+ if (DebugLevel >= 8)
{
double CP = CrossProduct(Node1, Node2, Node);
- if (CP > 0.0000001)
+ if (CP < 0.0000001)
{
- double X = Node->X;
- double Y = Node->Y;
+ dump_error(__FILE__, __LINE__, "Einer der gefundenen Knoten ist auf der falschen Seite");
+ }
+ }
- double Dx = cx - X;
- double Dy = cy - Y;
+ if (Node->Nr != NewNode->Nr)
+ {
+ double X = Node->X;
+ double Y = Node->Y;
- if (sqrt(Dx * Dx + Dy * Dy) < sqrt(cr) - 0.01)
- {
- NewNode = Node;
- CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
- }
- else if (sqrt(Dx * Dx + Dy * Dy) > sqrt(cr) + 0.01)
- {
- // Do nothing
- }
- else
- {
- // Die beiden Knoten sind gleich oder wenigstens fast gleich gut
- // Dann hilft nur eine andere Art der Unterscheidung
+ double Dx = cx - X;
+ double Dy = cy - Y;
- Edge = TodoEdgeList->Find(Node, Node1);
+ // Liegt er im Umkreis ?
+ if (sqrt(Dx * Dx + Dy * Dy) < sqrt(cr) - 0.01)
+ {
+ NewNode = Node;
+ i++;
+ continue;
+ }
- if (Edge)
- {
- NewNode = Node;
- CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
- }
- else
- {
- Edge = TodoEdgeList->Find(Node2, Node);
+ if (sqrt(Dx * Dx + Dy * Dy) > sqrt(cr) + 0.01)
+ {
+ // Er ist weiter weg, also brauchen wir ihn nicht weiter zu beachten
+ i++;
+ continue;
+ }
- if (Edge)
- {
- NewNode = Node;
- CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
- }
- }
- }
+ // Die beiden Knoten sind gleich oder wenigstens fast gleich gut
+ // Dann hilft nur eine andere Art der Unterscheidung
+
+ // Gab es schon eine Kante zu dem neuen Knoten ?
+ TEdge* Edge = TodoEdgeList->Find(Node, Node1);
+
+ if (Edge)
+ {
+ // Dann müssen wir ihn nehmen
+ NewNode = Node;
+ i++;
+ continue;
}
- else
+
+ // Gab es schon eine Kante zu dem neuen Knoten ?
+ Edge = TodoEdgeList->Find(Node2, Node);
+
+ // Dann müssen wir ihn nehmen
+ if (Edge)
{
- dump_error(__FILE__, __LINE__, "Einer der gefundenen Knoten ist auf der falschen Seite");
+ NewNode = Node;
+ i++;
+ continue;
}
}
i++;
@@ -298,34 +289,42 @@
if (NewNode)
{
- Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
+ // Wenn eine neue Kante schon als Aussenkante definiert wurde, dann
+ // Bleibt das auch so
+
+ TEdge* Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
if (Edge && Edge->IsBoundary)
{
NewNode = 0;
}
- else
+ }
+
+ if (NewNode)
+ {
+ // Wenn eine neue Kante schon als Aussenkante definiert wurde, dann
+ // Bleibt das auch so
+
+ TEdge* Edge = ReadyEdgeList->FindWithIndex(NewNode, Node2);
+ if (Edge && Edge->IsBoundary)
{
- Edge = ReadyEdgeList->FindWithIndex(NewNode, Node2);
- if (Edge && Edge->IsBoundary)
- {
- NewNode = 0;
- }
+ NewNode = 0;
}
}
if (NewNode)
{
-/*
- TEdge* Edge1 = ReadyEdgeList->FindWithIndex(Node1, Node2);
- TEdge* Edge2 = ReadyEdgeList->FindWithIndex(Node2, NewNode);
- TEdge* Edge3 = ReadyEdgeList->FindWithIndex(NewNode, Node1);
+ if (DebugLevel >= 8)
+ {
+ TEdge* Edge1 = ReadyEdgeList->FindWithIndex(Node1, Node2);
+ TEdge* Edge2 = ReadyEdgeList->FindWithIndex(Node2, NewNode);
+ TEdge* Edge3 = ReadyEdgeList->FindWithIndex(NewNode, Node1);
- if (Edge1 || Edge2 || Edge3)
- {
- write_fortschritt("%d Anzahl fertiger Kanten\n", ReadyEdgeList->Anz);
- dump_error(__FILE__, __LINE__, "Kante war schon fertig");
+ if (Edge1 || Edge2 || Edge3)
+ {
+ write_fortschritt("%d Anzahl fertiger Kanten\n", ReadyEdgeList->Anz);
+ dump_error(__FILE__, __LINE__, "Kante war schon fertig");
+ }
}
-*/
ReadyEdgeList->AddWithIndex(Node1, Node2);
ReadyEdgeList->AddWithIndex(Node2, NewNode);
@@ -342,7 +341,7 @@
// Diese Richtung ist jetzt fertig
// Falls sie also in der Todo-Liste war -> raus
- Edge = TodoEdgeList->Find(Node2, NewNode);
+ TEdge* Edge = TodoEdgeList->Find(Node2, NewNode);
if (Edge)
{
// In Todo Gefunden
@@ -351,18 +350,19 @@
}
else
{
- // Wenn diese Richtung nicht in der Todo-Liste war,
- // so kann die Gegenrichtung noch nicht fertig sein
- Edge = ReadyEdgeList->FindWithIndex(NewNode, Node2);
- if (0 == Edge)
+ if (DebugLevel >= 8)
{
- Edge = new TEdge(NewNode, Node2);
- TodoEdgeList->Add(Edge);
+ // Wenn diese Richtung nicht in der Todo-Liste war,
+ // so kann die Gegenrichtung noch nicht fertig sein
+ Edge = ReadyEdgeList->FindWithIndex(NewNode, Node2);
+ if (Edge)
+ {
+ dump_error(__FILE__, __LINE__, "Eine fertige Kante sollte noch mal eingetragen werden");
+ }
}
- else
- {
- dump_error(__FILE__, __LINE__, "Eine fertige Kante sollte noch mal eingetragen werden");
- }
+
+ Edge = new TEdge(NewNode, Node2);
+ TodoEdgeList->Add(Edge);
}
// Richtung: Ist schon fertig
@@ -375,22 +375,23 @@
}
else
{
- Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
- if (0 == Edge)
+ if (DebugLevel >= 8)
{
- Edge = new TEdge(Node1, NewNode);
- TodoEdgeList->Add(Edge);
+ Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
+ if (Edge)
+ {
+ dump_error(__FILE__, __LINE__, "Eine fertige Kante sollte noch mal eingetragen werden");
+ }
}
- else
- {
- dump_error(__FILE__, __LINE__, "Eine fertige Kante sollte noch mal eingetragen werden");
- }
+
+ Edge = new TEdge(Node1, NewNode);
+ TodoEdgeList->Add(Edge);
}
}
else
{
// Wenn diese Kante nichts war, so ist die andere Richtung eine Aussenkante
- Edge = ReadyEdgeList->FindWithIndex(Node2, Node1);
+ TEdge* Edge = ReadyEdgeList->FindWithIndex(Node2, Node1);
if (Edge) Edge->IsBoundary = true;
}
@@ -399,7 +400,7 @@
}
//---------------------------------------------------------------------
-bool Triangulate(TNodeList *NodeList, TElementList *ElementList, bool Debug)
+bool Triangulate(TNodeList *NodeList, TElementList *ElementList, int DebugLevel)
{
write_fortschritt("->Netz wird trianguliert\n");
@@ -431,20 +432,18 @@
TodoEdgeList->Add(SeedEdge2);
+ int TimeDiff = 5000;
+ if (DebugLevel >= 2) TimeDiff = 1000;
+
struct timeb Now;
ftime (&Now);
int StartMSec = Now.time * 1000 + Now.millitm;
+ int NextMSec = StartMSec + TimeDiff;
- int Anz = 0;
while (TodoEdgeList->Anz > 0)
{
- CompleteFacet(NodeList, ElementList, TodoEdgeList, ReadyEdgeList);
-
-
-
-if (Debug)
-{
+ CompleteFacet(NodeList, ElementList, TodoEdgeList, ReadyEdgeList, DebugLevel);
/*
#include "file.h"
if (ReadyEdgeList->Anz > 618)
@@ -453,24 +452,25 @@
SaveNet("tmp.2dm", NodeList, ElementList, true);
}
*/
-}
+ ftime (&Now);
+ int NowMSec = Now.time * 1000 + Now.millitm;
- Anz++;
+ if (NowMSec > NextMSec)
+ {
+ NextMSec = NowMSec + TimeDiff;
- if (Anz % 5000 == 0)
- {
- ftime (&Now);
- int NowMSec = Now.time * 1000 + Now.millitm;
int DiffMSec = NowMSec - StartMSec;
- write_fortschritt("%d von ca. %d Elementen erzeugt\n", ElementList->size(), NodeList->size() * 2);
- if (Debug) write_fortschritt("%.2f sec -> %.4f sec pro Kante\n", DiffMSec / 1000.0, DiffMSec / 1000.0 / Anz);
+ double RestMSec = DiffMSec * (NodeList->size() * 2.0 - ElementList->size()) / ElementList->size();
+
+ write_fortschritt("%d von ca. %d Elementen erzeugt (%d Kanten)\n", ElementList->size(), NodeList->size() * 2, ReadyEdgeList->Anz);
+ write_fortschritt("%.2f sec -> %.4f sec pro Element, Dauer noch ca. %.0f sec\n", DiffMSec / 1000.0, DiffMSec / 1000.0 / ElementList->size(), RestMSec / 1000.0);
}
}
delete TodoEdgeList;
- ReadyEdgeList->Empty();
+ ReadyEdgeList->Clear();
delete ReadyEdgeList;
write_fortschritt("Netz wurde trianguliert<-\n");
Modified: trunk/src/tri.h
===================================================================
--- trunk/src/tri.h 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/tri.h 2006-03-27 11:04:13 UTC (rev 40)
@@ -22,7 +22,7 @@
typedef enum { SUNDEFINED, SLEFT, SRIGHT, SUNIVERSE } TSide;
//---------------------------------------------------------------------------
-bool Triangulate(TNodeList* NodeList, TElementList *ElementList, bool Debug);
+bool Triangulate(TNodeList* NodeList, TElementList *ElementList, int DebugLevel);
//---------------------------------------------------------------------------
#endif
Modified: trunk/src/wsplgen.cpp
===================================================================
--- trunk/src/wsplgen.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/wsplgen.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -10,6 +10,20 @@
// Read the file COPYING coming with WSPLGEN for details.
//
+// DebugLevel
+//
+// 0 Keine Debug Informationen
+// 1 Kurze Zwischeninformationen und mehr Fortschrittanzeigen
+// 2 Mehr Zwischeninformationen und mehr Fortschrittanzeigen
+// 3 Noch mehr Zwischeninformationen
+//
+//
+// 5 Nur die wichtigsten Testausgabedateien
+// 6 Alle wichtigen Testausgabedateien
+// 7 Alle Testausgabedateien
+// 8 Alle Informationen und Tests
+// 9 Alle Informationenn und ALLE Fortschrittanzeigen (nicht für größere Netze geeignet)
+
#ifdef __BORLANDC__
#pragma hdrstop
#endif
@@ -31,28 +45,42 @@
int ReturnCode = 0;
//---------------------------------------------------------------------------
+#define NOSTDOUTPUT 0
+
+//---------------------------------------------------------------------------
int main(int argc, char **argv)
{
-/*
+#if NOSTDOUTPUT == 1
char StaFileName[] = "C:\\WSPLGEN\\WSPLGEN.STA";
char LogFileName[] = "C:\\WSPLGEN\\WSPLGEN.LOG";
- int newstdout = open (StaFileName, O_WRONLY | O_CREAT | O_TRUNC | O_TEXT, S_IWRITE);
- int newstderr = open (LogFileName, O_WRONLY | O_CREAT | O_TRUNC | O_TEXT, S_IWRITE);
+ int newstdlog = open (LogFileName, O_WRONLY | O_CREAT | O_TRUNC | O_TEXT, S_IWRITE);
+ int newstderr = open (StaFileName, O_WRONLY | O_CREAT | O_TRUNC | O_TEXT, S_IWRITE);
dup2 (newstdout, fileno(stdout));
dup2 (newstderr, fileno(stderr));
close (newstdout);
close (newstderr);
-*/
+#endif
write_fortschritt ("->WSPLGEN wurde gestartet\n");
-
// Hier werden alle Profile drin verwaltet
TProfilList ProfilList;
+
+ // Hier werden die Knoten verwaltet, die aus den Profilen generiert werden
+ TNodeList ProfilNodeList;
+
+ // Hier werden alle Sperren und Brüche drin verwaltet
+ TProfilList SperrenList;
+ TProfilList BruchList;
+
+ // Hier werden die Knoten verwaltet, die aus den Profilen generiert werden
+ // TNodeList SperrenNodeList;
+ TNodeList BruchNodeList;
+
// Hier wird das aktuelle Begrenzungspolygon für den aktuellen Bereich drin verwaltet
TXYList Bereichspolygon;
@@ -69,24 +97,25 @@
// Hier werden die Gewaesserachsen drin verwaltet
TGewaesserAchseList GewaesserAchseList;
- // Hier werden die Knoten verwaltet, die aus den Profilen generiert werden
- TNodeList ProfilNodeList;
+ // Hier werden die Knoten verwaltet, die aus den Linien generiert werden
+ TNodeList LinienNodeList;
// Hier drin werden die Ergebnis Polygone drin verwaltet
TErgebnisPolygonList ErgebnisPolygonList;
// Dies dient nur dazu mal kurz ein Netz zu triangulieren
-// LoadDGM("test_daten\\dgm.shp", &NodeList, &ElementList, 0, 99999999, true);
-// LoadDGM("test_daten\\dgm.xyz", &NodeList, &ElementList, 0, 99999999, true);
-// LoadDGM("test_daten\\dgm.grd", &NodeList, &ElementList, 0, 99999999, true);
-// LoadDGM("test_daten\\testdgm.shp", &NodeList, &ElementList, 0, 99999999, true);
-// LoadDGM("test_daten\\testdgm2.shp", &NodeList, &ElementList, 0, 99999999, true);
-// LoadDGM("test_daten\\dgm_riesig.shp", &NodeList, &ElementList, 0, 99999999, true);
+// LoadDGM("debug_output\\dgm.shp", &NodeList, &ElementList, 0, 99999999, true);
+// LoadDGM("debug_output\\dgm.xyz", &NodeList, &ElementList, 0, 99999999, true);
+// LoadDGM("debug_output\\dgm.grd", &NodeList, &ElementList, 0, 99999999, true);
+// LoadDGM("debug_output\\testdgm.shp", &NodeList, &ElementList, 0, 99999999, true);
+// LoadDGM("debug_output\\testdgm2.shp", &NodeList, &ElementList, 0, 99999999, true);
+// LoadDGM("debug_output\\dgm_riesig.shp", &NodeList, &ElementList, 0, 99999999, true);
// SaveNodes("tmp_ori_nodes.shp", &NodeList, true);
-// Triangulate (&NodeList, &ElementList, true);
+// Triangulate (&NodeList, &ElementList, 9);
// SaveElements("tmp_elements.shp", &ElementList, true);
// return(0);
+
try
{
// Zuerst Parameter auswerten
@@ -95,59 +124,52 @@
// Jetzt die Profile einlesen
// Dabei wird die Stationierung in km in cm umgerechnet
- LoadProfile(Parameter.FileNamePro, &ProfilList);
+ LoadProfile(Parameter.FileNamePro, &ProfilList, Parameter.DebugLevel);
if (ProfilList.size() < 2)
{
write_error(3204, "Es liegen nur %d Querprofilspuren vor\nEs werden aber mindestens 2 Querprofilspuren benötigt.", ProfilList.size());
}
+ if (Parameter.DebugLevel >= 7) SaveProfile("debug_output\\01_Profile_ORIGINAL.shp", &ProfilList, Parameter.DebugLevel);
-if (Parameter.IsDebug) SaveProfile("test_daten\\Profile_ORIGINAL.shp", &ProfilList, Parameter.IsDebug);
-
// Jetzt die Waserstände einlesen und
// anschliessend gleich auf die Profile interpolieren
// Dabei wird die Stationierung von km in cm umgerechnet
- TProfilList *WspProfilList = new TProfilList; // (ja, die Klasse TProfile wird jier kurz zweckentfremdet)
- LoadWsp(Parameter.FileNameWsp, WspProfilList);
- InterpolateWsp(&ProfilList, WspProfilList, Parameter.IsDebug);
+ TProfilList *WspProfilList = new TProfilList; // (ja, die Klasse TProfile wird hier kurz zweckentfremdet)
+ LoadWsp(Parameter.FileNameWsp, WspProfilList, Parameter.DebugLevel);
+ InterpolateWsp(&ProfilList, WspProfilList, Parameter.DebugLevel);
delete WspProfilList;
WspProfilList = 0;
-if (Parameter.IsDebug) SaveProfile("test_daten\\Profile_ORIGINAL_mit_WSP.shp", &ProfilList, Parameter.IsDebug);
+ if (Parameter.DebugLevel >= 6) SaveProfile("debug_output\\02_Profile_ORIGINAL_mit_WSP.shp", &ProfilList, Parameter.DebugLevel);
// Jetzt die Gewässerachse einlesen, wenn es notwendig ist
if (Parameter.Sperre)
{
- LoadAchse(Parameter.FileNameAchse, &GewaesserAchseList);
+ LoadAchse(Parameter.FileNameAchse, &GewaesserAchseList, Parameter.DebugLevel);
}
- else if (false == Parameter.Sperre && true == Parameter.IsSetAchse)
+
+ // Jetzt die Brüche und Dämme einlesen, wenn es notwendig ist
+ if (Parameter.IsSetLin)
{
- write_warning(1123, "Parameter -ACHSE wird ignoriert, da der Parameter -SPERRE den Wert NOSPERRE hat\n");
+ LoadLinien(Parameter.FileNameLin, &SperrenList, &BruchList, Parameter.DebugLevel);
}
-
// Jetzt die Profile nach Gewaessern trennen
- TProfilMap ProfilMap = BuildGewaesserListen(&ProfilList, Parameter.IsDebug);
+ TProfilMap ProfilMap = BuildGewaesserListen(&ProfilList, Parameter.DebugLevel);
- // Ungefähren Speicher ermitteln, als Grundlage für die Entscheidung
- // Ob in Scheiben gearbeitet werden soll
- size_t MaxMem = CheckMemory(Parameter.IsDebug);
+ // Ab jetzt werden die Profile nur noch über die GewProfilList verwaltet
+ ProfilList.clear();
// Ungefähre Geschwindigkeit ermitteln, als Grundlage für die Entscheidung
// ob in Scheiben gearbeitet werden soll
- int KFlops = CheckSpeed(Parameter.IsDebug) / 1000;
+ long Speed = CheckSpeed(Parameter.DebugLevel);
+ write_fortschritt("->Ermitteln der maximalen DGM-Knotenanzahl\n");
// Eine rein empirische Formel
- // geteilt durch 2 Man bracht auch Speicher für was anderes
- // geteilt durch 8 Byte per double
- // geteilt durch x, y, z, und wsp
- // geteilt durch 4, da man auch mal was anderes im Speicher braucht.
- // ein Wert von 10000 ist ok, wenn Flops kleiner ist so sollten weniger Knoten verarbeitet werden ->
- // geteilt durch (10000 / KFlops).
-
- write_fortschritt("->Ermitteln der maximalen DGM-Knotenanzahl\n");
- int MaxNodesPerSlice = (MaxMem / 6) / (8 * 4 * 4) / (10000 / KFlops);
+ int MaxNodesPerSlice = Speed * 10;
+MaxNodesPerSlice = 257805;
write_fortschritt("Es können nur ca. %d DGM-Punkte eingelesen werden\n", MaxNodesPerSlice);
write_fortschritt("Ermitteln der maximalen DGM-Knotenanzahl beendet<-\n");
@@ -173,14 +195,14 @@
}
// Mal wieder Zwischenergebnisse produzieren
-if (Parameter.IsDebug) SaveProfile("test_daten\\" + Gewaesser + "_Profile_100" + ".shp", GewProfilList, Parameter.IsDebug);
+ if (Parameter.DebugLevel >= 6) SaveProfile("debug_output\\03_" + Gewaesser + "_Profile_100" + ".shp", GewProfilList, Parameter.DebugLevel);
// Jetzt ein Polygon bilden, das die Profile begrenzt
- BuildPolygon(GewProfilList, &Bereichspolygon, Parameter.IsDebug);
+ BuildPolygon(GewProfilList, &Bereichspolygon, Parameter.DebugLevel);
-if (Parameter.IsDebug) SavePolygon("test_daten\\" + Gewaesser + "_Polygon" + ".shp", Gewaesser, 0, 0, &Bereichspolygon);
+ if (Parameter.DebugLevel >= 5) SavePolygon("debug_output\\04_" + Gewaesser + "_Polygon" + ".shp", Gewaesser, 0, 0, &Bereichspolygon, Parameter.DebugLevel);
- unsigned int AnzScheiben = LoadDGM(Parameter.FileNameDgm, &NodeList, &ElementList, &Bereichspolygon, MaxNodesPerSlice, Parameter.IsDebug);
+ unsigned int AnzScheiben = LoadDGM(Parameter.FileNameDgm, &NodeList, &ElementList, &Bereichspolygon, MaxNodesPerSlice, Parameter.DebugLevel);
// Wenn LoadDGM eine Scheibenanzahl von mehr als 1 ergeben hat, ist das DGM nicht geladen,
// es muss jetzt mit Scheiben gearbeitet werden.
@@ -223,11 +245,11 @@
}
// Jetzt das Polygon bilden, das die Profile begrenzen
- BuildPolygon(TempProfilList, &Bereichspolygon, Parameter.IsDebug);
+ BuildPolygon(TempProfilList, &Bereichspolygon, Parameter.DebugLevel);
-if (Parameter.IsDebug) SavePolygon("test_daten\\" + Gewaesser + "_Polygon_" + VC + NC + ".shp", Gewaesser, 0, 0, &Bereichspolygon);
+ if (Parameter.DebugLevel >= 5) SavePolygon("debug_output\\05_" + Gewaesser + "_Polygon_" + VC + NC + ".shp", Gewaesser, 0, 0, &Bereichspolygon, Parameter.DebugLevel);
- LoadDGM(Parameter.FileNameDgm, &NodeList, &ElementList, &Bereichspolygon, 99999999, Parameter.IsDebug);
+ LoadDGM(Parameter.FileNameDgm, &NodeList, &ElementList, &Bereichspolygon, 99999999, Parameter.DebugLevel);
delete TempProfilList;
}
@@ -235,14 +257,14 @@
// Wenn die Elementliste noch leer ist, müssen die Knoten noch trianguliert werden.
if (ElementList.size() == 0)
{
- if (false == Triangulate (&NodeList, &ElementList, Parameter.IsDebug)) return (false);
+ if (false == Triangulate (&NodeList, &ElementList, Parameter.DebugLevel)) return (false);
}
NodeList.SortByNr();
-if (Parameter.IsDebug) SaveNet("test_daten\\" + Gewaesser + "_Net_" + VC + NC + ".2dm", &NodeList, &ElementList, true);
-if (Parameter.IsDebug) SaveNodes("test_daten\\" + Gewaesser + "_Nodes_" + VC + NC + ".shp", &NodeList, true);
-if (Parameter.IsDebug) SaveElements("test_daten\\" + Gewaesser + "_Elements_" + VC + NC + ".shp", &ElementList, true);
+ if (Parameter.DebugLevel >= 8) SaveNet("debug_output\\06_" + Gewaesser + "_Net_" + VC + NC + ".2dm", &NodeList, &ElementList, true);
+ if (Parameter.DebugLevel >= 7) SaveNodes("debug_output\\07_" + Gewaesser + "_Nodes_" + VC + NC + ".shp", &NodeList, true);
+ if (Parameter.DebugLevel >= 6) SaveElements("debug_output\\08_" + Gewaesser + "_Elements_" + VC + NC + ".shp", &ElementList, true);
// Aus den Elementen werden nun die Kanten gebildet
// Hier ist noch Optimierungspotential
@@ -252,20 +274,20 @@
// Hier werden die Kanten drin verwaltet
// Die Kanten werden im Moment noch aus den Elementen generiert
- // Dieser Umweg ist eingetlich nocht notwendig
+ // Dieser Umweg ist eingendlich nicht notwendig
TEdgeList* EdgeList = new TEdgeList;
- BuildEdgeList(EdgeList, &ElementList, Parameter.IsDebug);
+ BuildEdgeList(EdgeList, &ElementList, Parameter.DebugLevel);
// Die Elemete werden nun nicht mehr gebraucht
ElementList.Clear();
-if (Parameter.IsDebug) SaveEdges("test_daten\\" + Gewaesser + "_Edges_" + VC + NC + ".shp", EdgeList, Parameter.IsDebug);
+ if (Parameter.DebugLevel >= 5) SaveEdges("debug_output\\09_" + Gewaesser + "_Edges_" + VC + NC + ".shp", EdgeList, Parameter.DebugLevel);
// Nachdem die durchschnittliche Kantenlänge bekannt ist,
// wird sie für die spätere Verwendung zwischengespeichert
double AvgDistance = EdgeList->AvgDistance;
- if (Parameter.IsDebug) write_fortschritt("Die mittlere Kantenlänge beträgt %.2f.\n", AvgDistance);
+ write_fortschritt("Die mittlere Kantenlänge beträgt %.2f.\n", AvgDistance);
// Nachdem die durchschnittliche Kantenlänge bekannt ist,
// werden die Profile entsprechend fein interpoliert
@@ -274,31 +296,49 @@
GewProfilList->InterpoliereProfile(AvgDistance * 10);
// Mal wieder Zwischenergebnisse produzieren
-if (Parameter.IsDebug) SaveProfile("test_daten\\" + Gewaesser + "_Profile_all_" + VC + NC + ".shp", GewProfilList, Parameter.IsDebug);
+ if (Parameter.DebugLevel >= 6) SaveProfile("debug_output\\10_" + Gewaesser + "_Profile_all_" + VC + NC + ".shp", GewProfilList, Parameter.DebugLevel);
// Jetzt die Stützstellen auffüllen
- GewProfilList->FillProfile(AvgDistance, Parameter.IsDebug);
+ GewProfilList->FillProfile(AvgDistance, -1, Parameter.DebugLevel);
// Mal wieder Zwischenergebnisse produzieren
-if (Parameter.IsDebug) SaveProfile("test_daten\\" + Gewaesser + "_Profile_fill_" + VC + NC + ".shp", GewProfilList, Parameter.IsDebug);
+ if (Parameter.DebugLevel >= 8) SaveProfile("debug_output\\11_" + Gewaesser + "_Profile_fill_" + VC + NC + ".shp", GewProfilList, Parameter.DebugLevel);
// Jetzt eine neue Knotenliste aus den Profilen generienen
- BuildProfilNodeList(GewProfilList, &NodeList, &GewaesserAchseList, &ProfilNodeList, AvgDistance, Parameter.Sperre, Parameter.IsDebug);
+ BuildProfilNodeList(GewProfilList, &NodeList, &GewaesserAchseList, &ProfilNodeList, AvgDistance, Parameter.Sperre, Parameter.DebugLevel);
-if (Parameter.IsDebug) SaveNodes("test_daten\\" + Gewaesser + "_ProfilNodes_" + VC + NC + ".shp", &ProfilNodeList, true);
+ if (Parameter.DebugLevel >= 5) SaveNodes("debug_output\\12_" + Gewaesser + "_ProfilNodes_" + VC + NC + ".shp", &ProfilNodeList, true);
// Jetzt die Wasserstände übertragen
- TransferWsp(&ProfilNodeList, &NodeList, AvgDistance, Parameter.IsDebug);
+ TransferWsp(&ProfilNodeList, &NodeList, AvgDistance, Parameter.DebugLevel);
+ if (BruchList.size() > 0)
+ {
+ // Mit Stützstellen auffüllen
+ BruchList.FillProfile(AvgDistance, -1, Parameter.DebugLevel);
+
+ // Jetzt eine neue Knotenliste aus den Brüchen generienen
+ GetWspFromNodeList(&BruchList, &NodeList, AvgDistance, Parameter.DebugLevel);
+
+ if (Parameter.DebugLevel >= 8) SaveProfile("debug_output\\13_" + Gewaesser + "_Bruch_ohne_Wsp_" + VC + NC + ".shp", &BruchList, Parameter.DebugLevel);
+
+ BuildProfilNodeList(&BruchList, &NodeList, &GewaesserAchseList, &BruchNodeList, AvgDistance, false, Parameter.DebugLevel);
+
+ if (Parameter.DebugLevel >= 7) SaveNodes("debug_output\\14_" + Gewaesser + "_Bruch_mit_Wsp_" + VC + NC + ".shp", &BruchNodeList, true);
+
+ // Jetzt die Wasserstände übertragen
+ TransferWsp(&BruchNodeList, &NodeList, AvgDistance, Parameter.DebugLevel);
+ }
+
ProfilNodeList.Clear();
-if (Parameter.IsDebug) SaveNodes("test_daten\\" + Gewaesser + "_Nodes_mitWSP_" + VC + NC + ".shp", &NodeList, true);
+ if (Parameter.DebugLevel >= 5) SaveNodes("debug_output\\15_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".shp", &NodeList, true);
// Wurde der Wert für das Argument 'Bis' beim Parameter -DELTA nicht gesetzt
// so ist jetzt die Zeit das nachzuholen
if (false == Parameter.IsSetBis)
{
- Parameter.Bis = NodeList.GetMaxDepth(Parameter.IsDebug);
+ Parameter.Bis = NodeList.GetMaxDepth(Parameter.DebugLevel);
}
// Nachdem nun 'Bis' sicher gesetzt ist, kann nun auch Diff bestimmt werden,
@@ -335,7 +375,7 @@
EdgeList->BuildEdgeIndex();
TErgebnisPolygonList* TempErgebnisPolygone = new TErgebnisPolygonList;
- NassTrockenBerechnung(Parameter.FileNameAusgabe + Gewaesser + VC + NC + ".shp", &NodeList, EdgeList, TempErgebnisPolygone, Parameter.Von, Parameter.Bis, Parameter.Diff, Parameter.IsDebug);
+ NassTrockenBerechnung(&NodeList, EdgeList, TempErgebnisPolygone, Parameter.Von, Parameter.Bis, Parameter.Diff, Parameter.DebugLevel);
for (TErgebnisPolygonList::iterator i = TempErgebnisPolygone->begin(); i != TempErgebnisPolygone->end(); i++)
{
@@ -346,13 +386,11 @@
ErgebnisPolygon->BisKm = BisProfil->Station / 10000.0;
}
-/*
-if (Parameter.IsDebug) SavePolygone(Parameter.FileNameAusgabe, &TempErgebnisPolygone, Parameter.IsDebug);
-*/
+// if (Parameter.DebugLevel >= 9) SavePolygone(Parameter.FileNameAusgabe, TempErgebnisPolygone, Parameter.DebugLevel);
ErgebnisPolygonList.Append(TempErgebnisPolygone);
- if (Parameter.IsDebug)
+ if (Parameter.DebugLevel >= 8)
{
for (TErgebnisPolygonList::iterator i = ErgebnisPolygonList.begin(); i != ErgebnisPolygonList.end(); i++)
{
@@ -372,26 +410,19 @@
// Löscht nur die Verwaltung und nicht die Knoten der Kanten,
// die Knoten waren nur geliehen
- EdgeList->Empty();
+ delete EdgeList;
write_fortschritt("Der Bereich von %.4f bis %.4f wurde bei Gewässer %s bearbeitet\n", VonProfil->Station / 10000.0, BisProfil->Station / 10000.0, Gewaesser.c_str());
}
}
// Speichern der Ergebnispolygone
- SavePolygone(Parameter.FileNameAusgabe, &ErgebnisPolygonList, Parameter.IsDebug);
+ SavePolygone(Parameter.FileNameAusgabe, &ErgebnisPolygonList, Parameter.DebugLevel);
+ // Die Profile wieder freigeben
for (TProfilMap::iterator i = ProfilMap.begin(); i != ProfilMap.end(); i++)
{
TProfilList* GewProfilList = i->second;
- // Hier muss ich das kleingeschriebene clear benutzen, da ich sonst die
- // Profile selbst mit löschen würde
- // Sie sind aber nur geliehen, um sie anders zu sortieren.
- // Der Speicher darf nicht freigegeben werden.
- // Der Speicher für die Verwaltung der ProfilList muss aber freigegeben werden !
- // Deshalb erst alle Profile rausschmeissen (clear) und DANN ProfilList löschen (delete)
- // Das ProfilMap wird automatisch am Ende zerstört, da es nur lokal war
- GewProfilList->clear();
delete GewProfilList;
}
}
@@ -410,10 +441,11 @@
write_fortschritt ("WSPLGEN wird beendet<-\n");
-/*
+
+#if NOSTDOUTPUT == 1
close (fileno(stdout));
close (fileno(stderr));
-*/
+#endif
return (ReturnCode);
}
Modified: trunk/src/xy.cpp
===================================================================
--- trunk/src/xy.cpp 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/xy.cpp 2006-03-27 11:04:13 UTC (rev 40)
@@ -190,28 +190,24 @@
//---------------------------------------------------------------------
//---------------------------------------------------------------------
-TElement::TElement(TNode* Node1, TNode* Node2, TNode* Node3)
+TElement::TElement(TNode* node1, TNode* node2, TNode* node3)
{
Typ = TRI;
- NodeList = new TNodeList();
-
- NodeList->push_back(Node1);
- NodeList->push_back(Node2);
- NodeList->push_back(Node3);
+ Node1 = node1;
+ Node2 = node2;
+ Node3 = node3;
}
//---------------------------------------------------------------------
-TElement::TElement(TNode* Node1, TNode* Node2, TNode* Node3, TNode* Node4)
+TElement::TElement(TNode* node1, TNode* node2, TNode* node3, TNode* node4)
{
Typ = QUAD;
- NodeList = new TNodeList();
-
- NodeList->push_back(Node1);
- NodeList->push_back(Node2);
- NodeList->push_back(Node3);
- NodeList->push_back(Node4);
+ Node1 = node1;
+ Node2 = node2;
+ Node3 = node3;
+ Node4 = node4;
}
//---------------------------------------------------------------------
@@ -219,39 +215,13 @@
{
Typ = element->Typ;
- for (TNodeList::iterator i = element->NodeList->begin(); i != element->NodeList->end(); i++)
- {
- NodeList->push_back(*i);
- }
+ Node1 = element->Node1;
+ Node2 = element->Node2;
+ Node3 = element->Node3;
+ Node4 = element->Node4;
}
//---------------------------------------------------------------------
-TElement::~TElement(void)
-{
- // Hier muss man das kleine clear verwenden da
- // die Knoten alle nur geliehen sind
- // und sonst mit zerstört würden
- NodeList->clear();
- delete NodeList;
-}
-
-//---------------------------------------------------------------------
-TInsideTyp TElement::IsInsideElement(double X, double Y)
-{
-
- int alpha = IsInside(NodeList, X, Y);
-
- if (alpha == 0) return (NOT_INSIDE);
- if (alpha == 4) return (INSIDE);
- if (alpha == -4) return (INSIDE);
- if (alpha == -1) return (ON_LINE);
-
- dump_error(__FILE__, __LINE__, "Alpha (%d) ungültig\n", alpha);
-
- return (UNDEFINED);
-}
-
-//---------------------------------------------------------------------
// TXYList
//---------------------------------------------------------------------
@@ -577,6 +547,7 @@
TNodeList::TNodeList(void)
{
XYKombiIndex = 0;
+ SearchNodeList = 0;
}
//---------------------------------------------------------------------------
@@ -588,9 +559,19 @@
//---------------------------------------------------------------------
void TNodeList::Clear(void)
{
- if (XYKombiIndex) delete XYKombiIndex;
- XYKombiIndex = 0;
+ if (XYKombiIndex)
+ {
+ delete XYKombiIndex;
+ XYKombiIndex = 0;
+ }
+ if (SearchNodeList)
+ {
+ SearchNodeList->clear();
+ delete SearchNodeList;
+ SearchNodeList = 0;
+ }
+
for (unsigned int i=0; i<size(); i++)
{
TNode *Node = (*this)[i];
@@ -711,7 +692,7 @@
return (0);
}
*/
-
+
if (Index < 0) return (0);
TNode *Node = (* this)[Index];
@@ -720,20 +701,21 @@
}
//---------------------------------------------------------------------
-void TNodeList::FindAllByXY(TNodeList *SearchNodeList, double X, double Y, double R)
+TNodeList* TNodeList::FindAllByXY(double X, double Y, double R)
{
// Wichtig ist das kleingeschriebene clear
// In dieser Nodelist sind villeicht Knoten drin, die nur geliehen sind.
// Die Knoten selbst sollen nicht gelöscht werden
- SearchNodeList->clear();
+ if (SearchNodeList) SearchNodeList->clear();
+ else SearchNodeList = new TNodeList;
if (size() != XYKombiIndex->Anzahl)
{
dump_error(__FILE__, __LINE__, "Knotenanzahl (%d) und XYKombiIndex-Anzahl (%d) stimmen nicht überein", size(), XYKombiIndex->Anzahl);
}
- if (size() <= 0) return;
+ if (size() <= 0) return(SearchNodeList);
std::vector<int> NodeIndexList;
@@ -746,19 +728,19 @@
SearchNodeList->push_back(Node);
}
+
+ return (SearchNodeList);
}
//---------------------------------------------------------------------
bool TNodeList::Interpolate(double X, double Y, double R, double *ZWert, double *WspWert)
{
- TNodeList *SearchNodeList = new TNodeList;
-
if (size() != XYKombiIndex->Anzahl)
{
dump_error(__FILE__, __LINE__, "Knotenanzahl (%d) und XYKombiIndex-Anzahl (%d) stimmen nicht überein", size(), XYKombiIndex->Anzahl);
}
- FindAllByXY(SearchNodeList, X, Y, R);
+ TNodeList *SearchNodeList = FindAllByXY(X, Y, R);
TNode* TLNode = 0;
double TLD = 0.0;
@@ -993,6 +975,42 @@
}
//---------------------------------------------------------------------
+double TNodeList::GetMaxWsp(bool Debug)
+{
+ write_fortschritt("->Maximaler Wasserstand wird ermittelt\n");
+
+ double MaxWsp = 0.0;
+ int Count = 0;
+ for (iterator i = begin(); i != end(); i++)
+ {
+ if (Debug && Count % 10000 == 0) write_fortschritt("Knoten %d von %d wird untersucht.\n", Count, size());
+ else if (Count > 0 && Count % 100000 == 0) write_fortschritt("Knoten %d von %d wird untersucht.\n", Count, size());
+
+ TNode* Node = *i;
+
+ if (Node->Wsp > 9999) continue;
+
+ double Wsp = Node->Wsp;
+
+ if (Wsp < 0.0)
+ {
+ dump_error(__FILE__, __LINE__, "Der Wasserstand ist negative");
+ }
+
+ if (Count == 0 || Wsp > MaxWsp) MaxWsp = Wsp;
+
+ Count++;
+ }
+ write_fortschritt("Knoten %d von %d wird untersucht.\n", Count, size());
+
+ write_fortschritt("Maximaler Wasserstand: %.3f.\n", MaxWsp);
+
+ write_fortschritt("Maximaler Wasserstand ermittelt<-\n");
+
+ return (MaxWsp);
+}
+
+//---------------------------------------------------------------------
// TElementList
//---------------------------------------------------------------------
@@ -1825,17 +1843,18 @@
NextProfil = *i;
}
+ double Diff = NextProfil->Station - FirstProfil->Station;
+ int Anz = (int)(Diff / SollAbstand + 0.5) - 1;
+ if (Anz <= 0) continue;
+
+ double Abstand = Diff / (Anz + 1);
+
TProfil *FirstProfilNeu = new TProfil(FirstProfil);
TProfil *NextProfilNeu = new TProfil(NextProfil);
FirstProfilNeu->EqualizeProfil(NextProfil);
NextProfilNeu->EqualizeProfil(FirstProfil);
- double Diff = NextProfil->Station - FirstProfil->Station;
- int Anz = (int)(Diff / SollAbstand + 0.5) - 1;
- if (Anz < 0) Anz = 0;
- double Abstand = Diff / (Anz + 1);
-
for (int j=1; j<=Anz; j++)
{
double Prozent = j * Abstand / Diff;
@@ -1865,10 +1884,12 @@
}
//---------------------------------------------------------------------
-void TProfilList::FillProfile(double SollAbstand, bool Debug)
+void TProfilList::FillProfile(double SollAbstand, int SollAnz, bool Debug)
{
write_fortschritt("->Die Profile werden mit Stützstellen aufgefüllt\n");
+ double Abstand = 1.0;
+
int Count = 0;
for (iterator i = begin(); i != end(); i++)
{
@@ -1877,6 +1898,19 @@
TProfil* Profil = *i;
+ TPoint* LastPoint = *Profil->PointList->rbegin();
+ double Laenge = LastPoint->Meter;
+
+ if (SollAnz >= 0)
+ {
+ Abstand = Laenge / SollAnz;
+ }
+ else
+ {
+ Abstand = SollAbstand;
+ }
+
+
TPoint* FirstPoint = 0;
TPoint* NextPoint = 0;
for (TPointList::iterator j = Profil->PointList->begin(); j != Profil->PointList->end(); j++)
@@ -1893,7 +1927,9 @@
}
double Diff = NextPoint->Meter - FirstPoint->Meter;
- int Anz = (int)(Diff / SollAbstand + 0.5) - 1;
+
+
+ int Anz = (int)(Diff / Abstand + 0.5) - 1;
if (Anz < 0) Anz = 0;
double Abstand = Diff / (Anz + 1);
Modified: trunk/src/xy.h
===================================================================
--- trunk/src/xy.h 2006-03-21 00:53:11 UTC (rev 39)
+++ trunk/src/xy.h 2006-03-27 11:04:13 UTC (rev 40)
@@ -119,15 +119,15 @@
class TElement
{
public:
- TElementTyp Typ;
- TNodeList *NodeList;
+ TElementTyp Typ;
+ TNode* Node1;
+ TNode* Node2;
+ TNode* Node3;
+ TNode* Node4;
- TElement(TNode *Node1, TNode *Node2, TNode *Node3);
- TElement(TNode *Node1, TNode *Node2, TNode *Node3, TNode *Node4);
- TElement(TElement *Element);
- ~TElement(void);
-
- TInsideTyp IsInsideElement(double X, double Y);
+ TElement(TNode *Node1, TNode *Node2, TNode *Node3);
+ TElement(TNode *Node1, TNode *Node2, TNode *Node3, TNode *Node4);
+ TElement(TElement *Element);
};
//----------------------------------------------------------------------------
@@ -437,6 +437,7 @@
{
private:
TXYKombiIndex<TNodeList, TNode> *XYKombiIndex;
+ TNodeList* SearchNodeList;
public:
TNodeList(void);
@@ -448,11 +449,12 @@
void SortByXY(void);
void SortByNr(void);
TNode* FindByXY(double X, double Y, double Eps = 0.01);
- void FindAllByXY(TNodeList *NodeList, double X, double Y, double Eps = 0.01);
+ TNodeList* FindAllByXY(double X, double Y, double Eps = 0.01);
TNode* FindByNr(int Nr);
bool Interpolate(double X, double Y, double R, double *Z, double *Wsp);
void ClearEdgeIndex(void);
double GetMaxDepth(bool Debug);
+ double GetMaxWsp(bool Debug);
};
//----------------------------------------------------------------------------
@@ -604,7 +606,7 @@
void Clear(void);
TProfil* Find(std::string Gewaesser, int Station);
void InterpoliereProfile(double SollAbstand);
- void FillProfile(double SollAbstand, bool Debug);
+ void FillProfile(double SollAbstand, int SollAnz, bool Debug);
double GetMaxWsp(bool Debug);
};
More information about the Wsplgen-commits
mailing list