[Wsplgen-commits] r48 - in trunk: bin bin/test_results src
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Thu May 11 23:32:45 CEST 2006
Author: mrchip
Date: 2006-05-11 23:32:40 +0200 (Thu, 11 May 2006)
New Revision: 48
Modified:
trunk/bin/start_test
trunk/bin/start_test.bat
trunk/bin/test_results/test.txt
trunk/src/Makefile
trunk/src/file.cpp
trunk/src/file.h
trunk/src/parameter.cpp
trunk/src/parameter.h
trunk/src/shape.cpp
trunk/src/test_file.cpp
trunk/src/test_nodes.cpp
trunk/src/test_tools.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/wsplgen.cpp
trunk/src/wsplgen.h
trunk/src/xy.cpp
trunk/src/xy.h
Log:
Diverse Kleinigkeiten: Rundungsfehler, kleine Optimierungen und eine erneute ?\195?\156berarbeitung der Triangulierung.
Modified: trunk/bin/start_test
===================================================================
--- trunk/bin/start_test 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/bin/start_test 2006-05-11 21:32:40 UTC (rev 48)
@@ -1,2 +1,8 @@
#! /bin/sh
-test.exe file 2>test_results/test.txt
+
+test.exe file 2>test_results/test.txt
+test.exe tools 2>test_results/test.txt
+test.exe xy 2>test_results/test.txt
+# test.exe profil 2>test_results/test.txt
+test.exe nodes 2>test_results/test.txt
+test.exe tri 2>test_results/test.txt
Modified: trunk/bin/start_test.bat
===================================================================
--- trunk/bin/start_test.bat 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/bin/start_test.bat 2006-05-11 21:32:40 UTC (rev 48)
@@ -1,3 +1,8 @@
@echo off
-test.exe file 2>test_results/test.txt
+test.exe file 2>test_results/test.txt
+test.exe tools 2>test_results/test.txt
+test.exe xy 2>test_results/test.txt
+rem test.exe profil 2>test_results/test.txt
+test.exe nodes 2>test_results/test.txt
+test.exe tri 2>test_results/test.txt
Modified: trunk/bin/test_results/test.txt
===================================================================
--- trunk/bin/test_results/test.txt 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/bin/test_results/test.txt 2006-05-11 21:32:40 UTC (rev 48)
@@ -1,241 +1,108 @@
-23:41:14: ->Auswertung der Kommandozeilen-Parameter gestartet
-23:41:14: ->Laden der Parameterdatei 'test_daten\test.par' gestartet
-23:41:14: <-Laden der Parameterdatei 'test_daten\test.par' beendet
-23:41:14: <-Auswertung der Kommandozeilen-Parameter beendet
-23:41:14: ->Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' gestartet
-23:41:14: ->Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' als TIN gestartet
-23:41:14: ->Laden der Knoten gestartet
-23:41:14: 118 Werten gelesen, 114 von 114 Knoten im Speicher
-23:41:14: <-Laden der Knoten beendet
-23:41:14: ->Laden der Elemente gestartet
-23:41:14: 230 Werte geladen, 218 von 230 Elementen im Speicher
-23:41:14: <-Laden der Elemente beendet
-23:41:14: <-Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' als TIN beendet
-23:41:14: ->Suche nach doppelten Knoten gestartet
-23:41:14: 114 Knoten und 218 Elemente vorhanden
-23:41:14: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:14: <-Suche nach doppelten Knoten beendet
-23:41:14: <-Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' beendet
-23:41:14: ->Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' gestartet
-23:41:14: ->Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' als TIN gestartet
-23:41:14: ->Laden der Knoten gestartet
-23:41:14: 118 Werten gelesen, 52 von 52 Knoten im Speicher
-23:41:14: <-Laden der Knoten beendet
-23:41:14: ->Laden der Elemente gestartet
-23:41:14: 230 Werte geladen, 72 von 230 Elementen im Speicher
-23:41:14: <-Laden der Elemente beendet
-23:41:14: <-Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' als TIN beendet
-23:41:14: ->Suche nach doppelten Knoten gestartet
-23:41:14: 52 Knoten und 72 Elemente vorhanden
-23:41:14: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:14: <-Suche nach doppelten Knoten beendet
-23:41:14: <-Laden des DGM in Datei 'test_daten/dgmtin/tnxy.adf' beendet
-23:41:14: ->Laden des DGM in Datei 'test_daten/dgm.grd' gestartet
-23:41:14: ->Laden des DGM in Datei 'test_daten/dgm.grd' als GRD gestartet
-23:41:14: 10000 von 71250 Werten gelesen, 0 von 0 Knoten im Speicher
-23:41:14: 20000 von 71250 Werten gelesen, 5130 von 5130 Knoten im Speicher
-23:41:14: 30000 von 71250 Werten gelesen, 11135 von 11135 Knoten im Speicher
-23:41:14: 40000 von 71250 Werten gelesen, 17145 von 17145 Knoten im Speicher
-23:41:14: 50000 von 71250 Werten gelesen, 23155 von 23155 Knoten im Speicher
-23:41:15: 60000 von 71250 Werten gelesen, 24624 von 24624 Knoten im Speicher
-23:41:15: 70000 von 71250 Werten gelesen, 24624 von 24624 Knoten im Speicher
-23:41:15: 71250 von 71250 Werten gelesen, 24624 von 24624 Knoten im Speicher
-23:41:15: <-Laden des DGM in Datei 'test_daten/dgm.grd' als GRD beendet
-23:41:15: ->Suche nach doppelten Knoten gestartet
-23:41:15: 24624 Knoten und keine Elemente vorhanden
-23:41:15: 10000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:15: 20000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:15: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:15: <-Suche nach doppelten Knoten beendet
-23:41:15: <-Laden des DGM in Datei 'test_daten/dgm.grd' beendet
-23:41:15: ->Laden des DGM in Datei 'test_daten/dgm.xyz' gestartet
-23:41:15: ->Laden des DGM in Datei 'test_daten/dgm.xyz' als XYZ gestartet
-23:41:15: 10 Werte gelesen, 10 von 10 Knoten im Speicher
-23:41:15: <-Laden des DGM in Datei 'test_daten/dgm.xyz' als XYZ beendet
-23:41:15: ->Suche nach doppelten Knoten gestartet
-23:41:15: 10 Knoten und keine Elemente vorhanden
-23:41:15: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:15: <-Suche nach doppelten Knoten beendet
-23:41:15: <-Laden des DGM in Datei 'test_daten/dgm.xyz' beendet
-23:41:15: ->Laden des DGM in Datei 'test_daten/dgm_gross.xyz' gestartet
-23:41:15: ->Laden des DGM in Datei 'test_daten/dgm_gross.xyz' als XYZ gestartet
-23:41:15: 1126 Werte gelesen, 1126 von 1126 Knoten im Speicher
-23:41:15: <-Laden des DGM in Datei 'test_daten/dgm_gross.xyz' als XYZ beendet
-23:41:15: ->Suche nach doppelten Knoten gestartet
-23:41:15: 1126 Knoten und keine Elemente vorhanden
-23:41:15: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:15: <-Suche nach doppelten Knoten beendet
-23:41:15: <-Laden des DGM in Datei 'test_daten/dgm_gross.xyz' beendet
-23:41:15: ->Laden des DGM in Datei 'test_daten/dgm_ziemlich_gross.xyz' gestartet
-23:41:15: ->Laden des DGM in Datei 'test_daten/dgm_ziemlich_gross.xyz' als XYZ gestartet
-23:41:15: 10000 Werte gelesen, 9999 von 9999 Knoten im Speicher
-23:41:15: 20000 Werte gelesen, 19999 von 19999 Knoten im Speicher
-23:41:15: 30000 Werte gelesen, 29999 von 29999 Knoten im Speicher
-23:41:16: 40000 Werte gelesen, 39999 von 39999 Knoten im Speicher
-23:41:16: 43332 Werte gelesen, 43332 von 43332 Knoten im Speicher
-23:41:16: <-Laden des DGM in Datei 'test_daten/dgm_ziemlich_gross.xyz' als XYZ beendet
-23:41:16: ->Suche nach doppelten Knoten gestartet
-23:41:16: 43332 Knoten und keine Elemente vorhanden
-23:41:16: 10000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:16: 20000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:16: 30000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:16: 40000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:16: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:16: <-Suche nach doppelten Knoten beendet
-23:41:16: <-Laden des DGM in Datei 'test_daten/dgm_ziemlich_gross.xyz' beendet
-23:41:16: ->Laden des DGM in Datei 'test_daten/dgm_sehr_gross.xyz' gestartet
-23:41:16: ->Laden des DGM in Datei 'test_daten/dgm_sehr_gross.xyz' als XYZ gestartet
-23:41:17: 10000 Werte gelesen, 9999 von 9999 Knoten im Speicher
-23:41:17: 20000 Werte gelesen, 19999 von 19999 Knoten im Speicher
-23:41:17: 30000 Werte gelesen, 29999 von 29999 Knoten im Speicher
-23:41:17: 40000 Werte gelesen, 39999 von 39999 Knoten im Speicher
-23:41:17: 50000 Werte gelesen, 49999 von 49999 Knoten im Speicher
-23:41:18: 60000 Werte gelesen, 59999 von 59999 Knoten im Speicher
-23:41:18: 70000 Werte gelesen, 69999 von 69999 Knoten im Speicher
-23:41:18: 80000 Werte gelesen, 79999 von 79999 Knoten im Speicher
-23:41:18: 90000 Werte gelesen, 89999 von 89999 Knoten im Speicher
-23:41:18: 98636 Werte gelesen, 98636 von 98636 Knoten im Speicher
-23:41:18: <-Laden des DGM in Datei 'test_daten/dgm_sehr_gross.xyz' als XYZ beendet
-23:41:18: ->Suche nach doppelten Knoten gestartet
-23:41:18: 98636 Knoten und keine Elemente vorhanden
-23:41:19: 10000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:19: 20000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:19: 30000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:19: 40000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:19: 50000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:19: 60000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:20: 70000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:20: 80000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:20: 90000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:20: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:20: <-Suche nach doppelten Knoten beendet
-23:41:20: <-Laden des DGM in Datei 'test_daten/dgm_sehr_gross.xyz' beendet
-23:41:20: ->Laden des DGM in Datei 'test_daten/dgm.shp' gestartet
-23:41:20: ->Laden des DGM in Datei 'test_daten/dgm.shp' als SHP gestartet
-23:41:20: 114 von 114 Objekten gelesen, 114 von 114 Knoten im Speicher
-23:41:20: <-Laden des DGM in Datei 'test_daten/dgm.shp' als SHP beendet
-23:41:20: ->Suche nach doppelten Knoten gestartet
-23:41:20: 114 Knoten und keine Elemente vorhanden
-23:41:20: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:20: <-Suche nach doppelten Knoten beendet
-23:41:20: <-Laden des DGM in Datei 'test_daten/dgm.shp' beendet
-23:41:20: ->Laden des DGM in Datei 'test_daten/dgm2.shp' gestartet
-23:41:20: ->Laden des DGM in Datei 'test_daten/dgm2.shp' als SHP gestartet
-23:41:20: 10000 von 156249 Objekten gelesen, 9247 von 9247 Knoten im Speicher
-23:41:21: 20000 von 156249 Objekten gelesen, 11875 von 11875 Knoten im Speicher
-23:41:21: 30000 von 156249 Objekten gelesen, 11875 von 11875 Knoten im Speicher
-23:41:21: 40000 von 156249 Objekten gelesen, 11875 von 11875 Knoten im Speicher
-23:41:21: 50000 von 156249 Objekten gelesen, 11875 von 11875 Knoten im Speicher
-23:41:21: 60000 von 156249 Objekten gelesen, 11875 von 11875 Knoten im Speicher
-23:41:21: 70000 von 156249 Objekten gelesen, 12088 von 12088 Knoten im Speicher
-23:41:21: 80000 von 156249 Objekten gelesen, 13793 von 13793 Knoten im Speicher
-23:41:22: 90000 von 156249 Objekten gelesen, 15747 von 15747 Knoten im Speicher
-23:41:22: 100000 von 156249 Objekten gelesen, 17727 von 17727 Knoten im Speicher
-23:41:22: 110000 von 156249 Objekten gelesen, 19707 von 19707 Knoten im Speicher
-23:41:22: 120000 von 156249 Objekten gelesen, 21687 von 21687 Knoten im Speicher
-23:41:22: 130000 von 156249 Objekten gelesen, 23667 von 23667 Knoten im Speicher
-23:41:22: 140000 von 156249 Objekten gelesen, 25482 von 25482 Knoten im Speicher
-23:41:23: 150000 von 156249 Objekten gelesen, 27462 von 27462 Knoten im Speicher
-23:41:23: 156249 von 156249 Objekten gelesen, 28287 von 28287 Knoten im Speicher
-23:41:23: <-Laden des DGM in Datei 'test_daten/dgm2.shp' als SHP beendet
-23:41:23: ->Suche nach doppelten Knoten gestartet
-23:41:23: 28287 Knoten und keine Elemente vorhanden
-23:41:23: 10000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:23: 20000 von 0 Knoten durchsucht, 0 Knoten gelöscht
-23:41:23: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:23: <-Suche nach doppelten Knoten beendet
-23:41:23: <-Laden des DGM in Datei 'test_daten/dgm2.shp' beendet
-23:41:23: ->Laden des DGM in Datei 'test_daten/dgm.2dm' gestartet
-23:41:23: ->Laden des DGM in Datei 'test_daten/dgm.2dm' als 2DM gestartet
-23:41:23: 2225 Elemente, 1126 Knoten geladen, 1126 Knoten insgesamt
-23:41:23: <-Laden des DGM in Datei 'test_daten/dgm.2dm' als 2DM beendet
-23:41:23: ->Suche nach doppelten Knoten gestartet
-23:41:23: 1126 Knoten und 2225 Elemente vorhanden
-23:41:23: 0 Knoten gelöscht, 0 Elemente gelöscht
-23:41:23: <-Suche nach doppelten Knoten beendet
-23:41:23: <-Laden des DGM in Datei 'test_daten/dgm.2dm' beendet
-23:41:23: ->Laden der Profilspuren gestartet
-23:41:23: 8 von 8 Objekten geladen, 8 Profilspuren im Speicher
-23:41:23: <-Laden der Profilspuren beendet
-23:41:23: ->Ausrichten der Profilspuren gestartet
-23:41:23: 8 von 8 Profilspuren ausgerichtet, 3 gedreht
-23:41:23: <-Ausrichten der Profilspuren beendet
-23:41:23: ->Laden der Profilspuren gestartet
-23:41:23: 5 von 5 Objekten geladen, 5 Profilspuren im Speicher
-23:41:23: <-Laden der Profilspuren beendet
-23:41:23: ->Ausrichten der Profilspuren gestartet
-23:41:23: 5 von 5 Profilspuren ausgerichtet, 0 gedreht
-23:41:23: <-Ausrichten der Profilspuren beendet
-23:41:23: ->Laden der Linien Strukturen (Sperren und Brüche) gestartet
-23:41:23: 9 von 9 Liniensstrukturen geladen, 4 Brüche und 5 Sperren im Speicher
-23:41:23: <-Laden der Linien Strukturen (Sperren und Brüche) beendet
-23:41:23: ->Laden der Wasserstände gestartet
-23:41:23: ->Laden der Wasserstände im ASCII-Format gestartet
-23:41:23: 100 Zeilen geladen, 99 Wasserstände im Speicher
-23:41:23: 200 Zeilen geladen, 199 Wasserstände im Speicher
-23:41:23: 300 Zeilen geladen, 299 Wasserstände im Speicher
-23:41:23: 400 Zeilen geladen, 399 Wasserstände im Speicher
-23:41:23: 500 Zeilen geladen, 499 Wasserstände im Speicher
-23:41:23: 600 Zeilen geladen, 599 Wasserstände im Speicher
-23:41:23: 700 Zeilen geladen, 699 Wasserstände im Speicher
-23:41:23: 800 Zeilen geladen, 799 Wasserstände im Speicher
-23:41:23: 900 Zeilen geladen, 899 Wasserstände im Speicher
-23:41:23: 1000 Zeilen geladen, 999 Wasserstände im Speicher
-23:41:23: 1100 Zeilen geladen, 1099 Wasserstände im Speicher
-23:41:23: 1200 Zeilen geladen, 1199 Wasserstände im Speicher
-23:41:23: 1300 Zeilen geladen, 1299 Wasserstände im Speicher
-23:41:23: 1400 Zeilen geladen, 1399 Wasserstände im Speicher
-23:41:23: 1500 Zeilen geladen, 1499 Wasserstände im Speicher
-23:41:23: 1600 Zeilen geladen, 1599 Wasserstände im Speicher
-23:41:23: 1700 Zeilen geladen, 1699 Wasserstände im Speicher
-23:41:23: 1800 Zeilen geladen, 1799 Wasserstände im Speicher
-23:41:23: 1900 Zeilen geladen, 1899 Wasserstände im Speicher
-23:41:23: 2000 Zeilen geladen, 1999 Wasserstände im Speicher
-23:41:23: 2100 Zeilen geladen, 2099 Wasserstände im Speicher
-23:41:23: 2200 Zeilen geladen, 2199 Wasserstände im Speicher
-23:41:23: 2300 Zeilen geladen, 2299 Wasserstände im Speicher
-23:41:23: 2400 Zeilen geladen, 2399 Wasserstände im Speicher
-23:41:23: 2500 Zeilen geladen, 2499 Wasserstände im Speicher
-23:41:23: 2600 Zeilen geladen, 2599 Wasserstände im Speicher
-23:41:23: 2700 Zeilen geladen, 2699 Wasserstände im Speicher
-23:41:23: 2800 Zeilen geladen, 2799 Wasserstände im Speicher
-23:41:23: 2900 Zeilen geladen, 2899 Wasserstände im Speicher
-23:41:23: 3000 Zeilen geladen, 2999 Wasserstände im Speicher
-23:41:23: 3100 Zeilen geladen, 3099 Wasserstände im Speicher
-23:41:23: 3200 Zeilen geladen, 3199 Wasserstände im Speicher
-23:41:23: 3300 Zeilen geladen, 3299 Wasserstände im Speicher
-23:41:23: 3400 Zeilen geladen, 3399 Wasserstände im Speicher
-23:41:23: 3500 Zeilen geladen, 3499 Wasserstände im Speicher
-23:41:23: 3600 Zeilen geladen, 3599 Wasserstände im Speicher
-23:41:23: 3700 Zeilen geladen, 3699 Wasserstände im Speicher
-23:41:23: 3800 Zeilen geladen, 3799 Wasserstände im Speicher
-23:41:23: 3900 Zeilen geladen, 3899 Wasserstände im Speicher
-23:41:23: 4000 Zeilen geladen, 3999 Wasserstände im Speicher
-23:41:23: 4100 Zeilen geladen, 4099 Wasserstände im Speicher
-23:41:23: 4200 Zeilen geladen, 4199 Wasserstände im Speicher
-23:41:23: 4300 Zeilen geladen, 4299 Wasserstände im Speicher
-23:41:23: 4400 Zeilen geladen, 4399 Wasserstände im Speicher
-23:41:23: 4500 Zeilen geladen, 4499 Wasserstände im Speicher
-23:41:23: 4600 Zeilen geladen, 4599 Wasserstände im Speicher
-23:41:23: 4700 Zeilen geladen, 4699 Wasserstände im Speicher
-23:41:23: 4800 Zeilen geladen, 4799 Wasserstände im Speicher
-23:41:23: 4900 Zeilen geladen, 4899 Wasserstände im Speicher
-23:41:23: 5000 Zeilen geladen, 4999 Wasserstände im Speicher
-23:41:23: 5100 Zeilen geladen, 5099 Wasserstände im Speicher
-23:41:23: 5200 Zeilen geladen, 5199 Wasserstände im Speicher
-23:41:23: 5300 Zeilen geladen, 5299 Wasserstände im Speicher
-23:41:24: 5400 Zeilen geladen, 5399 Wasserstände im Speicher
-23:41:24: 5500 Zeilen geladen, 5499 Wasserstände im Speicher
-23:41:24: 5600 Zeilen geladen, 5599 Wasserstände im Speicher
-23:41:24: 5669 Zeilen geladen, 5668 Wasserstände im Speicher
-23:41:24: <-Laden der Wasserstände im ASCII-Format beendet
-23:41:24: <-Laden der Wasserstände beendet
-23:41:24: ->Laden der Wasserstände gestartet
-23:41:24: ->Laden der Wasserstände im DBF-Format gestartet
-23:41:24: 42 von 42 Objekten gelesen, 42 Wasserstände im Speicher
-23:41:24: <-Laden der Wasserstände im DBF-Format beendet
-23:41:24: <-Laden der Wasserstände beendet
-23:41:24: ->Laden der Gewässerachsen gestartet
-23:41:24: 10 von 14 Objekten gelesen, 10 Gewässerachsen im Speicher
-23:41:24: 14 von 14 Objekten gelesen, 14 Gewässerachsen im Speicher
-23:41:24: <-Laden der Gewässerachsen beendet
+23:29:42: ->Triangulierung der Knoten gestartet
+23:29:42: ->Sortien Knoten gestartet
+23:29:42: <-Sortien der Knoten beendet
+23:29:42: ->Löschen des Knoten/Kanten-Index gestartet
+23:29:42: <-Löschen des Knoten/Kanten-Index beendet
+23:29:42: ->Suchen der Startkante gestartet
+23:29:42: Kante: 1 - 2 als Startkante
+23:29:42: <-Suchen der Startkante beendet
+23:29:42: <-Triangulierung der Knoten beendet
+23:29:42: ->Triangulierung der Knoten gestartet
+23:29:42: ->Sortien Knoten gestartet
+23:29:42: <-Sortien der Knoten beendet
+23:29:42: ->Löschen des Knoten/Kanten-Index gestartet
+23:29:42: <-Löschen des Knoten/Kanten-Index beendet
+23:29:42: ->Suchen der Startkante gestartet
+23:29:42: Kante: 1 - 4 als Startkante
+23:29:42: <-Suchen der Startkante beendet
+23:29:42: <-Triangulierung der Knoten beendet
+23:29:42: ->Laden des DGM in Datei 'test_daten/dgm2.shp' gestartet
+23:29:42: ->Laden des DGM in Datei 'test_daten/dgm2.shp' als SHP gestartet
+23:29:43: 10000 von 156249 Objekten gelesen, 9999 von 9999 Knoten im Speicher
+23:29:43: 20000 von 156249 Objekten gelesen, 19999 von 19999 Knoten im Speicher
+23:29:43: 30000 von 156249 Objekten gelesen, 29999 von 29999 Knoten im Speicher
+23:29:43: 40000 von 156249 Objekten gelesen, 39999 von 39999 Knoten im Speicher
+23:29:44: 50000 von 156249 Objekten gelesen, 49999 von 49999 Knoten im Speicher
+23:29:44: 60000 von 156249 Objekten gelesen, 59999 von 59999 Knoten im Speicher
+23:29:45: 70000 von 156249 Objekten gelesen, 69999 von 69999 Knoten im Speicher
+23:29:45: 80000 von 156249 Objekten gelesen, 79999 von 79999 Knoten im Speicher
+23:29:45: 90000 von 156249 Objekten gelesen, 89999 von 89999 Knoten im Speicher
+23:29:46: 100000 von 156249 Objekten gelesen, 99999 von 99999 Knoten im Speicher
+23:29:46: 110000 von 156249 Objekten gelesen, 109999 von 109999 Knoten im Speicher
+23:29:47: 120000 von 156249 Objekten gelesen, 119999 von 119999 Knoten im Speicher
+23:29:47: 130000 von 156249 Objekten gelesen, 129999 von 129999 Knoten im Speicher
+23:29:47: 140000 von 156249 Objekten gelesen, 139999 von 139999 Knoten im Speicher
+23:29:48: 150000 von 156249 Objekten gelesen, 149999 von 149999 Knoten im Speicher
+23:29:48: 156249 von 156249 Objekten gelesen, 156249 von 156249 Knoten im Speicher
+23:29:48: <-Laden des DGM in Datei 'test_daten/dgm2.shp' als SHP beendet
+23:29:48: ->Suche nach doppelten Knoten gestartet
+23:29:48: 156249 Knoten und keine Elemente vorhanden
+23:29:49: 10000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:50: 20000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:50: 30000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:50: 40000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:51: 50000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:51: 60000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:52: 70000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:52: 80000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:52: 90000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:53: 100000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:53: 110000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:54: 120000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:54: 130000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:55: 140000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:55: 150000 von 156249 Knoten, 0 Knoten gelöscht
+23:29:55: 0 Knoten gelöscht, 0 Elemente gelöscht
+23:29:55: <-Suche nach doppelten Knoten beendet
+23:29:55: <-Laden des DGM in Datei 'test_daten/dgm2.shp' beendet
+23:29:55: ->Triangulierung der Knoten gestartet
+23:29:55: ->Sortien Knoten gestartet
+23:29:56: <-Sortien der Knoten beendet
+23:29:56: ->Löschen des Knoten/Kanten-Index gestartet
+23:29:56: <-Löschen des Knoten/Kanten-Index beendet
+23:29:56: ->Suchen der Startkante gestartet
+23:29:56: Kante: 44106 - 44107 als Startkante
+23:29:56: <-Suchen der Startkante beendet
+23:30:01: 19942 von ca. 312498 Elementen erzeugt (59826 Kanten)
+23:30:01: 5.02 sec -> 0.0003 sec pro Element, Dauer noch ca. 147 sec
+23:30:06: 39854 von ca. 312498 Elementen erzeugt (119562 Kanten)
+23:30:06: 10.05 sec -> 0.0003 sec pro Element, Dauer noch ca. 137 sec
+23:30:11: 59765 von ca. 312498 Elementen erzeugt (179295 Kanten)
+23:30:11: 15.06 sec -> 0.0003 sec pro Element, Dauer noch ca. 127 sec
+23:30:16: 79742 von ca. 312498 Elementen erzeugt (239226 Kanten)
+23:30:16: 20.11 sec -> 0.0003 sec pro Element, Dauer noch ca. 117 sec
+23:30:21: 97722 von ca. 312498 Elementen erzeugt (293166 Kanten)
+23:30:21: 25.16 sec -> 0.0003 sec pro Element, Dauer noch ca. 111 sec
+23:30:26: 117782 von ca. 312498 Elementen erzeugt (353346 Kanten)
+23:30:26: 30.22 sec -> 0.0003 sec pro Element, Dauer noch ca. 100 sec
+23:30:31: 135931 von ca. 312498 Elementen erzeugt (407793 Kanten)
+23:30:31: 35.27 sec -> 0.0003 sec pro Element, Dauer noch ca. 92 sec
+23:30:37: 155207 von ca. 312498 Elementen erzeugt (465621 Kanten)
+23:30:37: 40.31 sec -> 0.0003 sec pro Element, Dauer noch ca. 82 sec
+23:30:42: 174463 von ca. 312498 Elementen erzeugt (523389 Kanten)
+23:30:42: 45.33 sec -> 0.0003 sec pro Element, Dauer noch ca. 72 sec
+23:30:47: 191206 von ca. 312498 Elementen erzeugt (573618 Kanten)
+23:30:47: 50.34 sec -> 0.0003 sec pro Element, Dauer noch ca. 64 sec
+23:30:52: 208584 von ca. 312498 Elementen erzeugt (625752 Kanten)
+23:30:52: 55.41 sec -> 0.0003 sec pro Element, Dauer noch ca. 55 sec
+23:30:57: 226062 von ca. 312498 Elementen erzeugt (678186 Kanten)
+23:30:57: 60.42 sec -> 0.0003 sec pro Element, Dauer noch ca. 46 sec
+23:31:02: 242154 von ca. 312498 Elementen erzeugt (726462 Kanten)
+23:31:02: 65.45 sec -> 0.0003 sec pro Element, Dauer noch ca. 38 sec
+23:31:07: 259695 von ca. 312498 Elementen erzeugt (779085 Kanten)
+23:31:07: 70.47 sec -> 0.0003 sec pro Element, Dauer noch ca. 29 sec
+23:31:12: 275837 von ca. 312498 Elementen erzeugt (827511 Kanten)
+23:31:12: 75.52 sec -> 0.0003 sec pro Element, Dauer noch ca. 20 sec
+23:31:17: 293874 von ca. 312498 Elementen erzeugt (881622 Kanten)
+23:31:17: 80.53 sec -> 0.0003 sec pro Element, Dauer noch ca. 10 sec
+23:31:22: 309504 von ca. 312498 Elementen erzeugt (928512 Kanten)
+23:31:22: 85.55 sec -> 0.0003 sec pro Element, Dauer noch ca. 2 sec
+23:31:27: 311043 von ca. 312498 Elementen erzeugt (933129 Kanten)
+23:31:27: 90.64 sec -> 0.0003 sec pro Element, Dauer noch ca. 1 sec
+23:31:32: 311183 von ca. 312498 Elementen erzeugt (933549 Kanten)
+23:31:32: 95.67 sec -> 0.0003 sec pro Element, Dauer noch ca. 1 sec
+23:31:37: 311287 von ca. 312498 Elementen erzeugt (933861 Kanten)
+23:31:37: 100.69 sec -> 0.0003 sec pro Element, Dauer noch ca. 1 sec
+23:31:42: 311380 von ca. 312498 Elementen erzeugt (934140 Kanten)
+23:31:42: 105.72 sec -> 0.0003 sec pro Element, Dauer noch ca. 1 sec
+23:31:54: <-Triangulierung der Knoten beendet
Modified: trunk/src/Makefile
===================================================================
--- trunk/src/Makefile 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/Makefile 2006-05-11 21:32:40 UTC (rev 48)
@@ -8,7 +8,6 @@
CPPFLAGS=-O2
LDFLAGS=
LIBS=-lstdc++
-OUTPUT_OPTIONS=
PROJECT=wsplgen.exe
TEST=test.exe
@@ -23,9 +22,12 @@
../bin/wsplgen.exe: wsplgen.o $(OBJFILES)
$(CC) $(LDFLAGS) -o ../bin/wsplgen.exe wsplgen.o $(OBJFILES) $(LIBS)
-.cpp.o:
- $(CC) -Wall -c $(CPPFLAGS) $*.cpp $(OUTPUT_OPTIONS)
+%.o: %.cpp %.h
+ $(CC) -Wall -c $(CPPFLAGS) $*.cpp
+%.o: %.cpp
+ $(CC) -Wall -c $(CPPFLAGS) $*.cpp
+
clean:
rm -f *.o
Modified: trunk/src/file.cpp
===================================================================
--- trunk/src/file.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/file.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -144,9 +144,9 @@
while (1 == fread(&X, sizeof(X), 1, fhxy) && fread(&Y, sizeof(Y), 1, fhxy) && 1 == fread(&Z, sizeof(Z), 1, fhz))
{
- Swap8Bytes((byte *)&X);
- Swap8Bytes((byte *)&Y);
- Swap4Bytes((byte *)&Z);
+ Swap8Bytes(&X);
+ Swap8Bytes(&Y);
+ Swap4Bytes(&Z);
AnzWerte++;
@@ -767,7 +767,7 @@
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);
+ write_fortschritt("%d Zeilen, %d Knoten geladen %d Elemente gezählt\n", AnzZeilen, NodeList->size(), AnzElemente);
}
if (strncmp (line, "E4Q", 3) == 0 || strncmp (line, "E3T", 3) == 0)
@@ -819,7 +819,7 @@
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());
+ write_fortschritt("%d Zeilen, %d Knoten geladen %d Elemente geladen\n", AnzZeilen, NodeList->size(), ElementList->size());
}
int Nr;
@@ -872,7 +872,8 @@
fclose(fh);
- write_fortschritt("%d Elemente, %d Knoten geladen, %d Knoten insgesamt\n", ElementList->size(), NodeList->size(), AnzKnoten);
+ write_fortschritt("%d Elemente und %d Knoten geladen\n", ElementList->size(), NodeList->size());
+ write_fortschritt("%d Knoten insgesamt\n", AnzKnoten);
write_fortschritt("<-Laden des DGM in Datei '%s' als 2DM beendet\n", FileName.c_str());
@@ -881,10 +882,14 @@
}
//---------------------------------------------------------------------
-bool LoadProfile(std::string FileName, TProfilList* ProfilList, int DebugLevel)
+bool LoadProfile(std::string FileName, TProfilList* ProfilList, double VonKm, double BisKm, int DebugLevel)
{
write_fortschritt("->Laden der Profilspuren gestartet\n");
+ if (VonKm > -9999 && BisKm > -9999) write_fortschritt("Nur Profile von Station %.4f bis %.4f werden geladen\n", VonKm, BisKm);
+ else if (VonKm > -9999) write_fortschritt("Nur Profile mit einer Station größer als %.4f werden geladen\n", VonKm);
+ else if (BisKm > -9999) write_fortschritt("Nur Profile mit einer Station kleiner als %.4f werden geladen\n", BisKm);
+
if (ProfilList == 0)
{
dump_error(__FILE__, __LINE__, "ProfilListe ist undefiniert\n");
@@ -1065,38 +1070,41 @@
int Station = (int)(S * 10000.0 + 0.5);
if (S < 0) Station = (int)(S * 10000.0 - 0.5);
- if (ProfilList->Find(Gewaesser, Station))
+ if (Station >= VonKm * 10000 && Station <= BisKm * 10000)
{
- write_warning(2111, "In der DBD-Datei '%s' kommt das Profil ('%s',%.4f) mehrfach vor.\nEs wird nur die erste Definition berücksichtigt.\n", DBFFileName.c_str(), Gewaesser.c_str(), Station / 10000.0);
- continue;
- }
+ if (ProfilList->Find(Gewaesser, Station))
+ {
+ write_warning(2111, "In der DBD-Datei '%s' kommt das Profil ('%s',%.4f) mehrfach vor.\nEs wird nur die erste Definition berücksichtigt.\n", DBFFileName.c_str(), Gewaesser.c_str(), Station / 10000.0);
+ continue;
+ }
- SHPObject *psCShape = SHPReadObject(hSHP, i);
+ SHPObject *psCShape = SHPReadObject(hSHP, i);
- int AnzVert = psCShape->nVertices;
+ int AnzVert = psCShape->nVertices;
- if (AnzVert <= 0)
- {
- write_warning(2112, "In der DBD-Datei '%s' hat das Profil ('%s',%.4f) keine Stützstellen.\nEs wird ignoriert.\n", DBFFileName.c_str(), Gewaesser.c_str(), Station / 10000.0);
- continue;
- }
+ if (AnzVert <= 0)
+ {
+ write_warning(2112, "In der DBD-Datei '%s' hat das Profil ('%s',%.4f) keine Stützstellen.\nEs wird ignoriert.\n", DBFFileName.c_str(), Gewaesser.c_str(), Station / 10000.0);
+ continue;
+ }
- TProfil* Profil = new TProfil(Gewaesser, Station);
+ TProfil* Profil = new TProfil(Gewaesser, Station);
- ProfilList->insert(Profil);
+ ProfilList->insert(Profil);
- for (int j=0; j < AnzVert; j++)
- {
- double X = psCShape->padfX[j];
- double Y = psCShape->padfY[j];
+ 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;
- Profil->AddPoint(X, Y);
+ X = (long)(X * 100.0 + 0.5) / 100.0;
+ Y = (long)(Y * 100.0 + 0.5) / 100.0;
+ Profil->AddPoint(X, Y);
+ }
+
+ SHPDestroyObject(psCShape);
}
- SHPDestroyObject(psCShape);
-
Count++;
if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10 == 0) || (Count > 0 && Count % 100 == 0))
@@ -1167,6 +1175,20 @@
double NEx = NachEnde->X;
double NEy = NachEnde->Y;
+ double ADx = NAx - VAx;
+ double ADy = NAy - VAy;
+ if (fabs(ADx) < 0.00000001 && fabs(ADy) < 0.00000001)
+ {
+ write_error(3207, "Profil-Punkteabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", VAx, VAy, NAx, NAy);
+ }
+
+ double EDx = NEx - VEx;
+ double EDy = NEy - VEy;
+ if (fabs(EDx) < 0.00000001 && fabs(EDy) < 0.00000001)
+ {
+ write_error(3207, "Profil-Punkteabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", VEx, VEy, NEx, NEy);
+ }
+
double X = 0.0;
double Y = 0.0;
double LambdaA = -1;
@@ -1207,13 +1229,13 @@
}
//---------------------------------------------------------------------
-bool LoadLinien(std::string FileName, TProfilList* SperrenList, TProfilList* BruchList, int DebugLevel)
+bool LoadLinien(std::string FileName, TProfilList* SperrenList, TProfilList* GrabenList, TProfilList* RohreList, int DebugLevel)
{
- write_fortschritt("->Laden der Linien Strukturen (Sperren und Brüche) gestartet\n");
+ write_fortschritt("->Laden der Linien Strukturen (Sperren, Gräben und Rohre) gestartet\n");
- if (SperrenList == 0 || BruchList == 0)
+ if (SperrenList == 0 || GrabenList == 0 || RohreList == 0)
{
- dump_error(__FILE__, __LINE__, "Sperrenliste oder Bruchlist ist undefiniert\n");
+ dump_error(__FILE__, __LINE__, "Sperrenliste oder Grabenliste oder Rohreliste ist undefiniert\n");
}
std::string SHPFileName = ExchangeFileExt(FileName, ".SHP");
@@ -1338,10 +1360,26 @@
{
Typ = "SPERRE";
}
+ else if (Typ == "DAMM" || Typ == "Damm" || Typ == "damm")
+ {
+ // Der Typ 'DAMM' wurde noch nicht benutzt und wird immer schon mal unterstützt
+ write_warning(9999, "Der Typ 'Damm' wurde in der Datei '%s' benutzt.\nEr wird noch nicht offiziell unterstützt.\n", DBFFileName.c_str());
+ Typ = "SPERRE";
+ }
+ else if (Typ == "GRABEN" || Typ == "Graben" || Typ == "graben")
+ {
+ Typ = "GRABEN";
+ }
else if (Typ == "BRUCH" || Typ == "Bruch" || Typ == "bruch")
{
- Typ = "BRUCH";
+ // Der Typ 'BRUCH' wurde früher benutzt und wird immer noch unterstützt
+ write_warning(9999, "Der Typ 'Bruch' wurde in der Datei '%s' benutzt.\nEr wird nur noch ubergangweise unterstützt.\nBitte ändern sie ihn in 'GRABEN'.\n", DBFFileName.c_str());
+ Typ = "GRABEN";
}
+ else if (Typ == "ROHR" || Typ == "Rohr" || Typ == "rohr")
+ {
+ Typ = "ROHR";
+ }
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", Typ.c_str(), DBFFileName.c_str());
@@ -1362,8 +1400,10 @@
// 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);
+ if (Typ == "SPERRE") SperrenList->insert(Linie);
+ else if (Typ == "GRABEN") GrabenList->insert(Linie);
+ else if (Typ == "ROHR") RohreList->insert(Linie);
+ else dump_error(__FILE__, __LINE__, "Unbekannter Typ '%s' in der Datei '%s'\n", Typ.c_str(), DBFFileName.c_str());
for (int j=0; j < AnzVert; j++)
{
@@ -1381,15 +1421,15 @@
if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10 == 0) || (Count > 0 && Count % 100 == 0))
{
- write_fortschritt("%d von %d Liniensstrukturen geladen, %d Brüche und %d Sperren im Speicher\n", Count, RecordCount, BruchList->size(), SperrenList->size());
+ write_fortschritt("%d von %d Liniensstrukturen geladen, %d Sperren, %d Gräben, %d Rohre\n", Count, RecordCount, SperrenList->size(), GrabenList->size(), RohreList->size());
}
}
- write_fortschritt("%d von %d Liniensstrukturen geladen, %d Brüche und %d Sperren im Speicher\n", Count, RecordCount, BruchList->size(), SperrenList->size());
+ write_fortschritt("%d von %d Liniensstrukturen geladen, %d Sperren, %d Gräben, %d Rohre\n", Count, RecordCount, SperrenList->size(), GrabenList->size(), RohreList->size());
DBFClose(hDBF);
SHPClose(hSHP);
- write_fortschritt("<-Laden der Linien Strukturen (Sperren und Brüche) beendet\n");
+ write_fortschritt("<-Laden der Linien Strukturen (Sperren, Gräben und Rohre) beendet\n");
return (true);
}
@@ -1936,7 +1976,7 @@
//---------------------------------------------------------------------------
bool SaveNet(std::string FileName, TNodeList *NodeList, TElementList *ElementList, int DebugLevel)
{
- write_fortschritt("->2dM-Netz speichern\n");
+ write_fortschritt("->Speichern des 2DM-Netzes gestartet\n");
if (NodeList == 0) dump_error(__FILE__, __LINE__, "Die Knotenliste ist nicht definiert\n");
@@ -1948,40 +1988,43 @@
fprintf(fh, "MESH2D\n");
- write_fortschritt("->Elemente speichern\n");
+ if (ElementList && ElementList->size() > 0)
+ {
+ write_fortschritt("->Speichern der Elemente gestartet\n");
- for (unsigned int i=0; i<ElementList->size(); i++)
- {
- if (DebugLevel >= 9 || (DebugLevel >= 1 && i % 5000 == 0) || (i > 0 && i % 50000 == 0))
+ for (unsigned int i=0; i<ElementList->size(); i++)
{
- write_fortschritt("%d von %d Elementen gespeichert\n", i, ElementList->size());
- }
+ 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];
+ TElement *Element = (*ElementList)[i];
- if (Element->Typ == NO_ELEMENT)
- {
- continue;
- }
+ if (Element->Typ == NO_ELEMENT)
+ {
+ continue;
+ }
- if (Element->Typ != TRI)
- {
- dump_error(__FILE__, __LINE__, "Ein Element hat nicht genau 3 Knoten\n");
+ if (Element->Typ != TRI)
+ {
+ dump_error(__FILE__, __LINE__, "Ein Element hat nicht genau 3 Knoten\n");
+ }
+
+ 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);
}
- TNode *N1 = Element->Node1;
- TNode *N2 = Element->Node2;
- TNode *N3 = Element->Node3;
+ write_fortschritt("%d von %d Elementen gespeichert\n", ElementList->size(), ElementList->size());
- fprintf(fh, "E3T %6d %6d %6d %6d %6d\n", i+1, N1->Nr, N2->Nr, N3->Nr, 1);
+ write_fortschritt("<-Speichern der Elemente beendet\n");
}
- write_fortschritt("%d von %d Elementen gespeichert\n", ElementList->size(), ElementList->size());
+ write_fortschritt("->Speichern der Knoten gestartet\n");
- write_fortschritt("Elemente speichern beendet\n");
-
- write_fortschritt("->Knoten speichern\n");
-
for (unsigned int i=0; i<NodeList->size(); i++)
{
if (DebugLevel >= 9 || (DebugLevel >= 1 && i % 5000 == 0) || (i > 0 && i % 50000 == 0))
@@ -1996,9 +2039,9 @@
write_fortschritt("%d von %d Knoten gespeichert\n", NodeList->size(), NodeList->size());
- write_fortschritt("Knoten speichern beendet\n");
+ write_fortschritt("<-Speichern der Knoten beendet\n");
- write_fortschritt("->Modell-Parameter speichern\n");
+ write_fortschritt("->Speichern der Modell-Parameter gestartet\n");
fprintf(fh, "BEGPARAMDEF\n");
fprintf(fh, "GM HYDRO_AS-2D\n");
@@ -2037,19 +2080,58 @@
fprintf(fh, "END2DMBC\n");
- write_fortschritt("Modell-Parameter speichern beendet\n");
+ write_fortschritt("<-Speichern der Modell-Parameter beendet\n");
fclose (fh);
- write_fortschritt("Netz speichern beendet\n");
+ write_fortschritt("<-Speichern des 2DM-Netzes beendet\n");
return (true);
}
//---------------------------------------------------------------------------
+bool SaveSol(std::string FileName, TNodeList *NodeList, int DebugLevel)
+{
+ write_fortschritt("->Speichern der SOL-Wasserstände gestartet\n");
+
+ if (NodeList == 0) dump_error(__FILE__, __LINE__, "Die Knotenliste ist nicht definiert\n");
+
+ FILE *fh = fopen (FileName.c_str(), "w");
+ if (fh == NULL)
+ {
+ write_error(4201, "Kann Datei '%s' nicht zum Schreiben öffnen\n", FileName.c_str());
+ }
+
+ fprintf(fh, "SCALAR\n");
+ fprintf(fh, "ND %d\n", NodeList->size());
+ fprintf(fh, "ST 0\n");
+ fprintf(fh, "TS 0\n");
+
+ for (unsigned int i=0; i<NodeList->size(); i++)
+ {
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && i % 5000 == 0) || (i > 0 && i % 50000 == 0))
+ {
+ write_fortschritt("%d von %d Wasserstände gespeichert\n", i, NodeList->size());
+ }
+
+ TNode *Node = (*NodeList)[i];
+
+ fprintf(fh, "%15.9f\n", Node->Wsp);
+ }
+
+ write_fortschritt("%d von %d Wasserstände gespeichert\n", NodeList->size(), NodeList->size());
+
+ fclose (fh);
+
+ write_fortschritt("<-Speichern der SOL-Wasserstände beendet\n");
+
+ return (true);
+}
+
+//---------------------------------------------------------------------------
bool SaveProfile(std::string FileName, TProfilList *ProfilList, int DebugLevel)
{
- write_fortschritt("->Profile speichern\n");
+ write_fortschritt("->Speichern der Profile gestartet\n");
DBFHandle DBFHandle = DBFCreate(FileName.c_str());
if(DBFHandle == NULL )
@@ -2130,7 +2212,7 @@
DBFClose(DBFHandle);
SHPClose(SHPHandle);
- write_fortschritt("Profile gespeichert\n");
+ write_fortschritt("<-Speichern der Profile beendet\n");
return (true);
}
@@ -2138,7 +2220,7 @@
//---------------------------------------------------------------------------
bool SavePolygon(std::string FileName, std::string Gewaesser, int Von, int Bis, TXYList *XyList, int DebugLevel)
{
- write_fortschritt("->Polygon wird gespeichert\n");
+ write_fortschritt("->Speichern des Polygons gestartet\n");
DBFHandle DBFHandle = DBFCreate(FileName.c_str());
if(DBFHandle == NULL )
@@ -2174,11 +2256,6 @@
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()+1);
- }
-
TXY* Xy = *i;
double X = Xy->X;
@@ -2189,6 +2266,11 @@
z[AnzPoint] = 0.0;
AnzPoint++;
+
+ 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()+1);
+ }
}
TXYList::iterator i = XyList->begin();
@@ -2220,15 +2302,15 @@
write_fortschritt("%d von %d Stützstellen gespeichert\n", AnzPoint, XyList->size()+1);
- write_fortschritt("Polygon gespeichert\n");
+ write_fortschritt("<-Speichern des Polygons beendet\n");
return (true);
}
//---------------------------------------------------------------------------
-bool SavePolygone(std::string FileName, TErgebnisPolygonList *ErgebnisPolygonList, int DebugLevel)
+bool SavePolygone(std::string FileName, TErgebnisPolygonList *PolygonList, int DebugLevel)
{
- write_fortschritt("->Polygone werden gespeichert\n");
+ write_fortschritt("->Speichern der Ergebnispolygone gestartet\n");
DBFHandle DBFHandle = DBFCreate(FileName.c_str());
if(DBFHandle == NULL )
@@ -2260,33 +2342,14 @@
write_error(4204, "Kann bei Datei '%s' das Attribut 'BIS' nicht erzeugen\n", FileName.c_str());
}
- if (DebugLevel)
- {
- for (TErgebnisPolygonList::iterator i = ErgebnisPolygonList->begin(); i != ErgebnisPolygonList->end(); i++)
- {
- TErgebnisPolygon* ErgebnisPolygon = *i;
+ TErgebnisPolygonList *ErgebnisPolygonList = PolygonList->Copy();
- std::string AktGewaesser = ErgebnisPolygon->Gewaesser;
- double AktVonKm = ErgebnisPolygon->VonKm;
- double AktBisKm = ErgebnisPolygon->BisKm;
- double AktDiff = ErgebnisPolygon->Diff;
-
- write_fortschritt("Gewässer %s %.4f - %.4f Wassertiefe %.2f\n", AktGewaesser.c_str(), AktVonKm, AktBisKm, AktDiff);
- }
- }
-
-
SHPHandle SHPHandle = SHPCreate(FileName.c_str(), SHPT_POLYGON);
- int AnzPolygons = 0;
+ int Count = 0;
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;
@@ -2294,8 +2357,6 @@
double AktBisKm = ErgebnisPolygon->BisKm;
double AktDiff = ErgebnisPolygon->Diff;
- write_fortschritt("Gewässer %s %.4f - %.4f Wassertiefe %.2f ", AktGewaesser.c_str(), AktVonKm, AktBisKm, AktDiff);
-
size_t Size = 0;
int *ps = 0;
@@ -2310,7 +2371,11 @@
for (TErgebnisPolygonList::iterator j = ErgebnisPolygonList->begin(); j != ErgebnisPolygonList->end(); j++)
{
TErgebnisPolygon* EP1 = *j;
- if (EP1->Gewaesser != AktGewaesser || EP1->VonKm != AktVonKm || EP1->BisKm != AktBisKm || EP1->Diff != AktDiff) continue; // Die Moment nicht
+ if (EP1->Gewaesser != AktGewaesser || EP1->VonKm != AktVonKm || EP1->BisKm != AktBisKm || EP1->Diff != AktDiff)
+ {
+ // Andere Gewässer oder Abschnitte werden im Moment noch nicht bearbeitet
+ continue;
+ }
TXYList::iterator First = EP1->begin();
@@ -2324,9 +2389,17 @@
{
TErgebnisPolygon* EP2 = *k;
- if (EP2 == EP1) continue;
+ if (EP2 == EP1)
+ {
+ // Nur mit anderen Polygonen vergleichen
+ continue;
+ }
- if (EP2->Gewaesser != AktGewaesser || EP2->VonKm != AktVonKm || EP2->BisKm != AktBisKm || EP2->Diff != AktDiff) continue; // Die Moment auch nicht
+ if (EP2->Gewaesser != AktGewaesser || EP2->VonKm != AktVonKm || EP2->BisKm != AktBisKm || EP2->Diff != AktDiff)
+ {
+ // Andere Gewässer oder Abschnitte werden im Moment noch nicht bearbeitet
+ continue;
+ }
if (EP2->IsInsideXYList(X, Y))
{
@@ -2369,22 +2442,21 @@
}
}
- if (DebugLevel) write_fortschritt("%d. Polygon %d Teile %d Ecken.\n", AnzPolygons+1, AnzPolyParts, AnzPolyPoints);
- else write_fortschritt("\n");
+ if (DebugLevel >= 1) write_fortschritt("%d. Polygon Gewässer %s %.4f - %.4f, Wassertiefe %.2f, %d Teile, %d Ecken\n", Count+1, AktGewaesser.c_str(), AktVonKm, AktBisKm, AktDiff, AnzPolyParts, AnzPolyPoints);
if (AnzPolyParts > 0 && AnzPolyPoints > 0)
{
- DBFWriteStringAttribute(DBFHandle, AnzPolygons, 0, AktGewaesser.c_str());
- DBFWriteDoubleAttribute(DBFHandle, AnzPolygons, 1, AktVonKm);
- DBFWriteDoubleAttribute(DBFHandle, AnzPolygons, 2, AktBisKm);
- DBFWriteDoubleAttribute(DBFHandle, AnzPolygons, 3, AktDiff);
+ DBFWriteStringAttribute(DBFHandle, Count, 0, AktGewaesser.c_str());
+ DBFWriteDoubleAttribute(DBFHandle, Count, 1, AktVonKm);
+ DBFWriteDoubleAttribute(DBFHandle, Count, 2, AktBisKm);
+ DBFWriteDoubleAttribute(DBFHandle, Count, 3, AktDiff);
SHPObject *psShape = SHPCreateObject(SHPT_POLYGON, -1, AnzPolyParts, ps, NULL, AnzPolyPoints, x, y, z, m);
SHPRewindObject(SHPHandle, psShape);
SHPWriteObject(SHPHandle, -1, psShape);
SHPDestroyObject(psShape);
- AnzPolygons++;
+ Count++;
}
free(ps);
@@ -2408,15 +2480,14 @@
}
j++;
}
+
i = ErgebnisPolygonList->begin();
}
- write_fortschritt("%d von %d Polygonen gespeichert\n", AnzPolygons, ErgebnisPolygonList->size());
-
DBFClose(DBFHandle);
SHPClose(SHPHandle);
- write_fortschritt("Polygone sind gespeichert\n");
+ write_fortschritt("<-Speichern der Ergebnispolygone beendet\n");
return (true);
}
@@ -2551,7 +2622,7 @@
//---------------------------------------------------------------------------
bool SaveElements(std::string FileName, TElementList *ElementList, int DebugLevel)
{
- write_fortschritt("->Elemente speichern\n");
+ write_fortschritt("->Speichern der Elemente gestartet\n");
DBFHandle DBFHandle = DBFCreate(FileName.c_str());
if(DBFHandle == NULL )
@@ -2582,7 +2653,7 @@
int AnzPolygone = 0;
for (TElementList::iterator i=ElementList->begin(); i != ElementList->end(); i++)
{
- if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzPolygone % 100 == 0) || (AnzPolygone > 0 && AnzPolygone % 1000 == 0))
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzPolygone % 5000 == 0) || (AnzPolygone > 0 && AnzPolygone % 50000 == 0))
{
write_fortschritt("%d von %d Elementen (Polygone) gespeichert\n", AnzPolygone, ElementList->size());
}
@@ -2596,7 +2667,7 @@
SHPClose(SHPHandle);
DBFClose(DBFHandle);
- write_fortschritt("Elemente gespeichert\n");
+ write_fortschritt("<-Speichern der Elemente beendet\n");
return (true);
}
@@ -2635,7 +2706,7 @@
int AnzNodes = 0;
for (TNodeList::iterator i=NodeList->begin(); i != NodeList->end(); i++)
{
- if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzNodes % 100 == 0) || (AnzNodes > 0 && AnzNodes % 1000 == 0))
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && AnzNodes % 5000 == 0) || (AnzNodes > 0 && AnzNodes % 50000 == 0))
{
write_fortschritt("%d von %d Knoten gespeichert\n", AnzNodes, NodeList->size());
}
@@ -2669,7 +2740,7 @@
//---------------------------------------------------------------------------
bool SaveEdges(std::string FileName, TEdgeList *EdgeList, int DebugLevel)
{
- write_fortschritt("->Kanten speichern\n");
+ write_fortschritt("->Speichern der Kanten gestartet\n");
DBFHandle DBFHandle = DBFCreate(FileName.c_str());
if(DBFHandle == NULL )
@@ -2702,7 +2773,7 @@
int Count = 0;
for (TEdgeListNrSorted::iterator i = EdgeList->EdgeListNrSorted.begin(); i != EdgeList->EdgeListNrSorted.end(); i++)
{
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 1000 == 0) || (Count > 0 && Count % 10000 == 0))
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 5000 == 0) || (Count > 0 && Count % 50000 == 0))
{
write_fortschritt("%d von %d Kanten gespeichert\n", Count, EdgeList->EdgeListNrSorted.size());
}
@@ -2734,7 +2805,7 @@
DBFClose(DBFHandle);
SHPClose(SHPHandle);
- write_fortschritt("->Kanten speichern\n");
+ write_fortschritt("<-Speichern der Kanten beendet\n");
return (true);
}
Modified: trunk/src/file.h
===================================================================
--- trunk/src/file.h 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/file.h 2006-05-11 21:32:40 UTC (rev 48)
@@ -27,8 +27,8 @@
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, int DebugLevel);
-bool LoadLinien(std::string FileName, TProfilList* SperrenList, TProfilList* BruchList, int DebugLevel);
+bool LoadProfile(std::string FileName, TProfilList* ProfilList, double VonKm, double BisKm, int DebugLevel);
+bool LoadLinien(std::string FileName, TProfilList* SperrenList, TProfilList* GrabenList, TProfilList* RohreList, int DebugLevel);
bool LoadWsp(std::string FileName, TProfilList* ProfilList, int DebugLevel);
bool LoadWspTxt(std::string FileName, TProfilList* ProfilList, int DebugLevel);
@@ -37,6 +37,7 @@
bool LoadAchse(std::string FileName, TGewaesserAchseList* GewaesserAchseList, int DebugLevel);
bool SaveNet(std::string FileName, TNodeList *NodeList, TElementList *ElementList, int DebugLevel);
+bool SaveSol(std::string FileName, TNodeList *NodeList, 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);
Modified: trunk/src/parameter.cpp
===================================================================
--- trunk/src/parameter.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/parameter.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -53,6 +53,13 @@
IsSetAchse = false;
FileNameAchse = "";
+ IsSetStrecke = false;
+ VonKm = -9999.9;
+ BisKm = +9999.9;
+
+ IsSetMaxNodesPerSlice = false;
+ MaxNodesPerSlice = 0;
+
IsSetAusgabe = false;
FileNameAusgabe = "WSPLGEN.SHP";
@@ -138,6 +145,83 @@
LoadPar(FileNamePar, &ParList);
AnzPar = ParList.size();
}
+ else if (Parameter.substr(0, 10) == "-MAXKNOTEN" || Parameter.substr(0, 10) == "-maxknoten")
+ {
+ ///////////////////////////////////////////////
+ // MAXKNOTEN
+ ///////////////////////////////////////////////
+ if (IsSetDebug) write_fortschritt("Parameter -MAXKNOTEN erkannt.\n");
+
+ if (IsSetMaxNodesPerSlice)
+ {
+ write_warning(1106, "Der Parameter -MAXKNOTEN wurde mehrfach angegeben.\n");
+ continue;
+ }
+
+ if (Parameter.substr(10, 1) != "=")
+ {
+ write_error(1125, "Es wurden keine Argumente für -MAXKNOTEN übergeben.\nDas Format lautet korrekt -MAXKNOTEN=<Anzahl>.\n");
+ }
+
+ int D = 0;
+ if (1 == sscanf(Parameter.substr(11).c_str(), "%d", &D))
+ {
+ MaxNodesPerSlice = D;
+ }
+
+ IsSetMaxNodesPerSlice = true;
+
+ if (IsSetDebug)
+ {
+ write_fortschritt("Maximale Geländepunkte pro Bearbeitungsabschnitt: %d\n", MaxNodesPerSlice);
+ }
+ }
+ else if (Parameter.substr(0, 8) == "-STRECKE" || Parameter.substr(0, 8) == "-strecke")
+ {
+ ///////////////////////////////////////////////
+ // STRECKE
+ ///////////////////////////////////////////////
+ if (IsSetDebug) write_fortschritt("Parameter -STRECKE erkannt.\n");
+
+ if (IsSetStrecke)
+ {
+ write_warning(1106, "Der Parameter -STRECKE wurde mehrfach angegeben.\n");
+ continue;
+ }
+
+ if (Parameter.substr(8, 1) != "=")
+ {
+ write_warning(1226, "Es wurden keine Argumente für -STRECKE übergeben.\nDas Format lautet korrekt -STRECKE=<Von>,<Bis>.\n");
+ }
+
+ double D = 0.0;
+ if (1 == sscanf(Parameter.substr(9).c_str(), "%lf", &D))
+ {
+ IsSetVonKm = true;
+ VonKm = D;
+ }
+
+ unsigned int FirstKommaPos = Parameter.find(",");
+
+ if (FirstKommaPos < Parameter.size())
+ {
+ if (1 == sscanf(Parameter.substr(FirstKommaPos + 1).c_str(), "%lf", &D))
+ {
+ IsSetBisKm = true;
+ BisKm = D;
+ }
+ }
+
+ IsSetStrecke = true;
+
+ if (IsSetDebug)
+ {
+ if (IsSetVonKm && IsSetBisKm) write_fortschritt("Strecke Von = %.2f Bis = %.2f\n", VonKm, BisKm);
+ else if (IsSetVonKm) write_fortschritt("Strecke Von = %.2f Bis = <default>\n", VonKm);
+ else if (IsSetBisKm) write_fortschritt("Strecke Von = <default> Bis = %.2f\n", BisKm);
+ else write_fortschritt("Strecke Von = <default> Bis = <default>\n");
+ }
+ }
else if (Parameter.substr(0, 6) == "-DELTA" || Parameter.substr(0, 6) == "-delta")
{
///////////////////////////////////////////////
@@ -193,15 +277,14 @@
if (IsSetDebug)
{
- write_fortschritt("Delta:");
- if (IsSetVon) write_fortschritt(" Von = %.2f", Von);
- else write_fortschritt(" Von = <default>");
-
- if (IsSetBis) write_fortschritt(" Bis = %.2f", Bis);
- else write_fortschritt(" Bis = <default>");
-
- if (IsSetDiff) write_fortschritt(" Diff = %.2f\n", Diff);
- else write_fortschritt(" Diff = <default>\n");
+ if (IsSetVon && IsSetBis && IsSetDiff) write_fortschritt("Delta: Von = %.2f Bis = %.2f Diff = %.2f\n", Von, Bis, Diff);
+ else if (IsSetVon && IsSetBis) write_fortschritt("Delta: Von = %.2f Bis = %.2f Diff = <default>\n", Von, Bis);
+ else if (IsSetVon && IsSetDiff) write_fortschritt("Delta: Von = %.2f Bis = <default> Diff = %.2f\n", Von, Diff);
+ else if (IsSetBis && IsSetBis) write_fortschritt("Delta: Von = <default> Bis = %.2f Diff = %.2f\n", Bis, Diff);
+ else if (IsSetVon) write_fortschritt("Delta: Von = %.2f Bis = <default> Diff = <default>\n", Von);
+ else if (IsSetBis) write_fortschritt("Delta: Von = <default> Bis = %.2f Diff = <default>\n", Bis);
+ else if (IsSetDiff) write_fortschritt("Delta: Von = <default> Bis = <default> Diff = %.2f\n", Diff);
+ else write_fortschritt("Delta: Von = <default> Bis = <default> Diff = <default>\n");
}
}
else if (Parameter.substr(0, 4) == "-GEL" || Parameter.substr(0, 4) == "-gel")
@@ -239,10 +322,16 @@
if (IsSetDebug)
{
- if (!IsSetGel) write_fortschritt("<Standard:> ");
-
- if (Sperre) write_fortschritt("Gelände wirkt als Sperre\n");
- else write_fortschritt("Gelände wirkt nicht als Sperre\n");
+ if (IsSetGel)
+ {
+ if (Sperre) write_fortschritt("Gelände wirkt als Sperre\n");
+ else write_fortschritt("Gelände wirkt nicht als Sperre\n");
+ }
+ else
+ {
+ if (Sperre) write_fortschritt("Standard: Gelände wirkt als Sperre\n");
+ else write_fortschritt("Standard: Gelände wirkt nicht als Sperre\n");
+ }
}
}
else if (Parameter.substr(0, 4) == "-DGM" || Parameter.substr(0, 4) == "-dgm")
Modified: trunk/src/parameter.h
===================================================================
--- trunk/src/parameter.h 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/parameter.h 2006-05-11 21:32:40 UTC (rev 48)
@@ -1,5 +1,5 @@
//
-// $Id: wsplgen.h 11 2005-12-07 10:15:07Z jan $
+// $Id$
//
// Copyright (C) 2005 STADT-LAND-FLUSS INGENIEURDIENSTE GmbH
//
@@ -56,6 +56,15 @@
bool IsSetAchse;
std::string FileNameAchse;
+ bool IsSetStrecke;
+ bool IsSetVonKm;
+ double VonKm;
+ bool IsSetBisKm;
+ double BisKm;
+
+ bool IsSetMaxNodesPerSlice;
+ int MaxNodesPerSlice;
+
bool IsSetAusgabe;
std::string FileNameAusgabe;
};
Modified: trunk/src/shape.cpp
===================================================================
--- trunk/src/shape.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/shape.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -9,6 +9,9 @@
#include "shape.h"
+#include "tools.h"
+
+
typedef unsigned char uchar;
typedef int int32;
@@ -20,36 +23,6 @@
static int bBigEndian;
/************************************************************************/
-/* SwapWord() */
-/* */
-/* Swap a 2, 4 or 8 byte word. */
-/************************************************************************/
-static void SwapWord(int length, void *wordP)
-{
- int i;
- uchar temp;
-
- for( i=0; i < length / 2; i++ )
- {
- temp = ((uchar *) wordP)[i];
- ((uchar *)wordP)[i] = ((uchar *) wordP)[length-i-1];
- ((uchar *) wordP)[length-i-1] = temp;
- }
-}
-
-/************************************************************************/
-/* SfRealloc() */
-/* */
-/* A realloc cover function that will access a NULL pointer as */
-/* a valid input. */
-/************************************************************************/
-static void * SfRealloc(void *pMem, int nNewSize)
-{
- if( pMem == NULL ) return(malloc(nNewSize));
- else return(realloc(pMem, nNewSize));
-}
-
-/************************************************************************/
/* SHPWriteHeader() */
/* */
/* Write out a header for the .shp and .shx files as well as the */
@@ -75,47 +48,47 @@
/* file size */
i32 = psSHP->nFileSize / 2;
ByteCopy(&i32, abyHeader+24, 4);
- if(!bBigEndian) SwapWord( 4, abyHeader+24);
+ if(!bBigEndian) Swap4Bytes(abyHeader+24);
i32 = 1000; /* version */
ByteCopy( &i32, abyHeader+28, 4 );
- if( bBigEndian ) SwapWord( 4, abyHeader+28 );
+ if( bBigEndian ) Swap4Bytes(abyHeader+28 );
i32 = psSHP->nShapeType; /* shape type */
ByteCopy( &i32, abyHeader+32, 4 );
- if( bBigEndian ) SwapWord( 4, abyHeader+32 );
+ if( bBigEndian ) Swap4Bytes(abyHeader+32 );
dValue = psSHP->adBoundsMin[0]; /* set bounds */
ByteCopy( &dValue, abyHeader+36, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+36 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+36 );
dValue = psSHP->adBoundsMin[1];
ByteCopy( &dValue, abyHeader+44, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+44 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+44 );
dValue = psSHP->adBoundsMax[0];
ByteCopy( &dValue, abyHeader+52, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+52 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+52 );
dValue = psSHP->adBoundsMax[1];
ByteCopy( &dValue, abyHeader+60, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+60 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+60 );
dValue = psSHP->adBoundsMin[2]; /* z */
ByteCopy( &dValue, abyHeader+68, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+68 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+68 );
dValue = psSHP->adBoundsMax[2];
ByteCopy( &dValue, abyHeader+76, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+76 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+76 );
dValue = psSHP->adBoundsMin[3]; /* m */
ByteCopy( &dValue, abyHeader+84, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+84 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+84 );
dValue = psSHP->adBoundsMax[3];
ByteCopy( &dValue, abyHeader+92, 8 );
- if( bBigEndian ) SwapWord( 8, abyHeader+92 );
+ if( bBigEndian ) Swap8Bytes(abyHeader+92 );
/* -------------------------------------------------------------------- */
/* Write .shp file header. */
@@ -128,7 +101,7 @@
/* -------------------------------------------------------------------- */
i32 = (psSHP->nRecords * 2 * sizeof(int32) + 100)/2; /* file size */
ByteCopy( &i32, abyHeader+24, 4 );
- if( !bBigEndian ) SwapWord( 4, abyHeader+24 );
+ if( !bBigEndian ) Swap4Bytes(abyHeader+24 );
fseek( psSHP->fpSHX, 0, 0 );
fwrite( abyHeader, 100, 1, psSHP->fpSHX );
@@ -142,8 +115,8 @@
{
panSHX[i*2 ] = psSHP->panRecOffset[i]/2;
panSHX[i*2+1] = psSHP->panRecSize[i]/2;
- if( !bBigEndian ) SwapWord(4, panSHX+i*2);
- if( !bBigEndian ) SwapWord(4, panSHX+i*2+1);
+ if( !bBigEndian ) Swap4Bytes(panSHX+i*2);
+ if( !bBigEndian ) Swap4Bytes(panSHX+i*2+1);
}
fwrite(panSHX, sizeof(int32) * 2, psSHP->nRecords, psSHP->fpSHX);
@@ -281,35 +254,35 @@
/* -------------------------------------------------------------------- */
/* Read the bounds. */
/* -------------------------------------------------------------------- */
- if( bBigEndian ) SwapWord( 8, pabyBuf+36 );
+ if( bBigEndian ) Swap8Bytes(pabyBuf+36 );
memcpy( &dValue, pabyBuf+36, 8 );
psSHP->adBoundsMin[0] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+44 );
+ if( bBigEndian ) Swap8Bytes(pabyBuf+44 );
memcpy( &dValue, pabyBuf+44, 8 );
psSHP->adBoundsMin[1] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+52 );
+ if( bBigEndian ) Swap8Bytes(pabyBuf+52 );
memcpy( &dValue, pabyBuf+52, 8 );
psSHP->adBoundsMax[0] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+60 );
+ if( bBigEndian ) Swap8Bytes(pabyBuf+60 );
memcpy( &dValue, pabyBuf+60, 8 );
psSHP->adBoundsMax[1] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+68 ); /* z */
+ if( bBigEndian ) Swap8Bytes(pabyBuf+68 ); /* z */
memcpy( &dValue, pabyBuf+68, 8 );
psSHP->adBoundsMin[2] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+76 );
+ if( bBigEndian ) Swap8Bytes(pabyBuf+76 );
memcpy( &dValue, pabyBuf+76, 8 );
psSHP->adBoundsMax[2] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+84 ); /* m */
+ if( bBigEndian ) Swap8Bytes(pabyBuf+84 ); /* m */
memcpy( &dValue, pabyBuf+84, 8 );
psSHP->adBoundsMin[3] = dValue;
- if( bBigEndian ) SwapWord( 8, pabyBuf+92 );
+ if( bBigEndian ) Swap8Bytes(pabyBuf+92 );
memcpy( &dValue, pabyBuf+92, 8 );
psSHP->adBoundsMax[3] = dValue;
@@ -341,10 +314,10 @@
int32 nOffset, nLength;
memcpy( &nOffset, pabyBuf + i * 8, 4 );
- if( !bBigEndian ) SwapWord( 4, &nOffset );
+ if( !bBigEndian ) Swap4Bytes(&nOffset );
memcpy( &nLength, pabyBuf + i * 8 + 4, 4 );
- if( !bBigEndian ) SwapWord( 4, &nLength );
+ if( !bBigEndian ) Swap4Bytes(&nLength );
psSHP->panRecOffset[i] = nOffset*2;
psSHP->panRecSize[i] = nLength*2;
@@ -488,15 +461,15 @@
i32 = 50; /* file size */
ByteCopy( &i32, abyHeader+24, 4 );
- if(!bBigEndian) SwapWord( 4, abyHeader+24 );
+ if(!bBigEndian) Swap4Bytes(abyHeader+24 );
i32 = 1000; /* version */
ByteCopy( &i32, abyHeader+28, 4 );
- if(bBigEndian) SwapWord( 4, abyHeader+28 );
+ if(bBigEndian) Swap4Bytes(abyHeader+28 );
i32 = nShapeType; /* shape type */
ByteCopy( &i32, abyHeader+32, 4 );
- if(bBigEndian) SwapWord( 4, abyHeader+32 );
+ if(bBigEndian) Swap4Bytes(abyHeader+32 );
dValue = 0.0; /* set bounds */
ByteCopy( &dValue, abyHeader+36, 8 );
@@ -514,7 +487,7 @@
/* -------------------------------------------------------------------- */
i32 = 50; /* file size */
ByteCopy( &i32, abyHeader+24, 4 );
- if(!bBigEndian) SwapWord(4, abyHeader+24);
+ if(!bBigEndian) Swap4Bytes(abyHeader+24);
fwrite(abyHeader, 100, 1, fpSHX);
@@ -544,10 +517,10 @@
if( bBigEndian )
{
- SwapWord( 8, pabyRec + 0 );
- SwapWord( 8, pabyRec + 8 );
- SwapWord( 8, pabyRec + 16 );
- SwapWord( 8, pabyRec + 24 );
+ Swap8Bytes(pabyRec + 0 );
+ Swap8Bytes(pabyRec + 8 );
+ Swap8Bytes(pabyRec + 16 );
+ Swap8Bytes(pabyRec + 24 );
}
}
@@ -729,11 +702,12 @@
/* -------------------------------------------------------------------- */
pabyRec = (uchar *)malloc(psObject->nVertices * 4 * sizeof(double) + psObject->nParts * 8 + 128);
- /* -------------------------------------------------------------------- */
- /* Extract vertices for a Polygon or Arc. */
- /* -------------------------------------------------------------------- */
if(psObject->nSHPType == SHPT_POLYGON || psObject->nSHPType == SHPT_POLYGONZ || psObject->nSHPType == SHPT_POLYGONM || psObject->nSHPType == SHPT_ARC || psObject->nSHPType == SHPT_ARCZ || psObject->nSHPType == SHPT_ARCM || psObject->nSHPType == SHPT_MULTIPATCH)
{
+ /* -------------------------------------------------------------------- */
+ /* Extract vertices for a Polygon or Arc. */
+ /* -------------------------------------------------------------------- */
+
int32 nPoints, nParts;
int i;
@@ -742,8 +716,8 @@
_SHPSetBounds( pabyRec + 12, psObject );
- if( bBigEndian ) SwapWord( 4, &nPoints );
- if( bBigEndian ) SwapWord( 4, &nParts );
+ if( bBigEndian ) Swap4Bytes(&nPoints );
+ if( bBigEndian ) Swap4Bytes(&nParts );
ByteCopy( &nPoints, pabyRec + 40 + 8, 4 );
ByteCopy( &nParts, pabyRec + 36 + 8, 4 );
@@ -754,7 +728,7 @@
ByteCopy( psObject->panPartStart, pabyRec + 44 + 8, 4 * psObject->nParts );
for( i = 0; i < psObject->nParts; i++ )
{
- if( bBigEndian ) SwapWord( 4, pabyRec + 44 + 8 + 4*i );
+ if( bBigEndian ) Swap4Bytes(pabyRec + 44 + 8 + 4*i );
nRecordSize += 4;
}
@@ -765,7 +739,7 @@
4*psObject->nParts );
for( i = 0; i < psObject->nParts; i++ )
{
- if( bBigEndian ) SwapWord( 4, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap4Bytes(pabyRec + nRecordSize );
nRecordSize += 4;
}
}
@@ -776,9 +750,9 @@
ByteCopy( psObject->padfX + i, pabyRec + nRecordSize, 8 );
ByteCopy( psObject->padfY + i, pabyRec + nRecordSize + 8, 8 );
- if (bBigEndian) SwapWord( 8, pabyRec + nRecordSize );
+ if (bBigEndian) Swap8Bytes(pabyRec + nRecordSize );
- if (bBigEndian) SwapWord( 8, pabyRec + nRecordSize + 8 );
+ if (bBigEndian) Swap8Bytes(pabyRec + nRecordSize + 8 );
nRecordSize = nRecordSize + 2 * 8;
}
@@ -789,17 +763,17 @@
|| psObject->nSHPType == SHPT_MULTIPATCH )
{
ByteCopy( &(psObject->dfZMin), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
ByteCopy( &(psObject->dfZMax), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
for( i = 0; i < psObject->nVertices; i++ )
{
ByteCopy( psObject->padfZ + i, pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
}
}
@@ -816,63 +790,61 @@
|| psObject->nSHPType == SHPT_ARCZ )
{
ByteCopy( &(psObject->dfMMin), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
ByteCopy( &(psObject->dfMMax), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
for( i = 0; i < psObject->nVertices; i++ )
{
ByteCopy( psObject->padfM + i, pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
}
}
}
-
-/* -------------------------------------------------------------------- */
-/* Extract vertices for a MultiPoint. */
-/* -------------------------------------------------------------------- */
- else if( psObject->nSHPType == SHPT_MULTIPOINT
- || psObject->nSHPType == SHPT_MULTIPOINTZ
- || psObject->nSHPType == SHPT_MULTIPOINTM )
+ else if( psObject->nSHPType == SHPT_MULTIPOINT || psObject->nSHPType == SHPT_MULTIPOINTZ || psObject->nSHPType == SHPT_MULTIPOINTM )
{
- int32 nPoints;
+ /* -------------------------------------------------------------------- */
+ /* Extract vertices for a MultiPoint. */
+ /* -------------------------------------------------------------------- */
- nPoints = psObject->nVertices;
+ int32 nPoints;
+ nPoints = psObject->nVertices;
+
_SHPSetBounds( pabyRec + 12, psObject );
- if( bBigEndian ) SwapWord( 4, &nPoints );
- ByteCopy( &nPoints, pabyRec + 44, 4 );
+ if( bBigEndian ) Swap4Bytes(&nPoints );
+ ByteCopy( &nPoints, pabyRec + 44, 4 );
- for( i = 0; i < psObject->nVertices; i++ )
- {
- ByteCopy( psObject->padfX + i, pabyRec + 48 + i*16, 8 );
- ByteCopy( psObject->padfY + i, pabyRec + 48 + i*16 + 8, 8 );
+ for( i = 0; i < psObject->nVertices; i++ )
+ {
+ ByteCopy( psObject->padfX + i, pabyRec + 48 + i*16, 8 );
+ ByteCopy( psObject->padfY + i, pabyRec + 48 + i*16 + 8, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + 48 + i*16 );
- if( bBigEndian ) SwapWord( 8, pabyRec + 48 + i*16 + 8 );
- }
+ if( bBigEndian ) Swap8Bytes(pabyRec + 48 + i*16 );
+ if( bBigEndian ) Swap8Bytes(pabyRec + 48 + i*16 + 8 );
+ }
- nRecordSize = 48 + 16 * psObject->nVertices;
+ nRecordSize = 48 + 16 * psObject->nVertices;
if( psObject->nSHPType == SHPT_MULTIPOINTZ )
{
ByteCopy( &(psObject->dfZMin), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
ByteCopy( &(psObject->dfZMax), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
for( i = 0; i < psObject->nVertices; i++ )
{
ByteCopy( psObject->padfZ + i, pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
}
}
@@ -881,62 +853,61 @@
|| psObject->nSHPType == SHPT_MULTIPOINTM )
{
ByteCopy( &(psObject->dfMMin), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
ByteCopy( &(psObject->dfMMax), pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
for( i = 0; i < psObject->nVertices; i++ )
{
ByteCopy( psObject->padfM + i, pabyRec + nRecordSize, 8 );
- if( bBigEndian ) SwapWord( 8, pabyRec + nRecordSize );
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize );
nRecordSize += 8;
}
}
}
-
-/* -------------------------------------------------------------------- */
-/* Write point. */
-/* -------------------------------------------------------------------- */
else if (psObject->nSHPType == SHPT_POINT || psObject->nSHPType == SHPT_POINTZ || psObject->nSHPType == SHPT_POINTM)
{
+ /* -------------------------------------------------------------------- */
+ /* Write point. */
+ /* -------------------------------------------------------------------- */
+
ByteCopy( psObject->padfX, pabyRec + 12, 8 );
- if (bBigEndian) SwapWord(8, pabyRec + 12);
+ if (bBigEndian) Swap8Bytes(pabyRec + 12);
ByteCopy( psObject->padfY, pabyRec + 20, 8 );
- if (bBigEndian) SwapWord(8, pabyRec + 20);
+ if (bBigEndian) Swap8Bytes(pabyRec + 20);
nRecordSize = 28;
if (psObject->nSHPType == SHPT_POINTZ)
{
ByteCopy(psObject->padfZ, pabyRec + nRecordSize, 8);
- if(bBigEndian) SwapWord(8, pabyRec + nRecordSize);
+ if(bBigEndian) Swap8Bytes(pabyRec + nRecordSize);
nRecordSize += 8;
}
if( psObject->nSHPType == SHPT_POINTZ || psObject->nSHPType == SHPT_POINTM )
{
ByteCopy(psObject->padfM, pabyRec + nRecordSize, 8);
- if( bBigEndian ) SwapWord(8, pabyRec + nRecordSize);
+ if( bBigEndian ) Swap8Bytes(pabyRec + nRecordSize);
nRecordSize += 8;
}
}
-
-/* -------------------------------------------------------------------- */
-/* Not much to do for null geometries. */
-/* -------------------------------------------------------------------- */
else if( psObject->nSHPType == SHPT_NULL )
{
+ /* -------------------------------------------------------------------- */
+ /* Not much to do for null geometries. */
+ /* -------------------------------------------------------------------- */
nRecordSize = 12;
}
-
else
{
/* unknown type */
- assert( FALSE );
+ dump_error(__FILE__, __LINE__, "Unbekannter Shape-Typ %d\n", psObject->nSHPType);
+ return (0);
}
/* -------------------------------------------------------------------- */
@@ -961,15 +932,15 @@
/* Set the shape type, record number, and record size. */
/* -------------------------------------------------------------------- */
i32 = nShapeId+1; /* record # */
- if( !bBigEndian ) SwapWord( 4, &i32 );
+ if( !bBigEndian ) Swap4Bytes(&i32 );
ByteCopy( &i32, pabyRec, 4 );
i32 = (nRecordSize-8)/2; /* record size */
- if( !bBigEndian ) SwapWord( 4, &i32 );
+ if( !bBigEndian ) Swap4Bytes(&i32 );
ByteCopy( &i32, pabyRec + 4, 4 );
i32 = psObject->nSHPType; /* shape type */
- if( bBigEndian ) SwapWord( 4, &i32 );
+ if( bBigEndian ) Swap4Bytes(&i32 );
ByteCopy( &i32, pabyRec + 8, 4 );
/* -------------------------------------------------------------------- */
@@ -1052,7 +1023,7 @@
psShape->nShapeId = hEntity;
memcpy( &psShape->nSHPType, psSHP->pabyRec + 8, 4 );
- if( bBigEndian ) SwapWord( 4, &(psShape->nSHPType) );
+ if( bBigEndian ) Swap4Bytes(&(psShape->nSHPType) );
/* ==================================================================== */
/* Extract vertices for a Polygon or Arc. */
@@ -1075,10 +1046,10 @@
memcpy( &(psShape->dfXMax), psSHP->pabyRec + 8 + 20, 8 );
memcpy( &(psShape->dfYMax), psSHP->pabyRec + 8 + 28, 8 );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfXMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfYMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfXMax) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfYMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfXMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfYMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfXMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfYMax) );
/* -------------------------------------------------------------------- */
/* Extract part/point count, and build vertex and part arrays */
@@ -1087,8 +1058,8 @@
memcpy( &nPoints, psSHP->pabyRec + 40 + 8, 4 );
memcpy( &nParts, psSHP->pabyRec + 36 + 8, 4 );
- if( bBigEndian ) SwapWord( 4, &nPoints );
- if( bBigEndian ) SwapWord( 4, &nParts );
+ if( bBigEndian ) Swap4Bytes(&nPoints );
+ if( bBigEndian ) Swap4Bytes(&nParts );
psShape->nVertices = nPoints;
psShape->padfX = (double *) calloc(nPoints,sizeof(double));
@@ -1109,7 +1080,7 @@
memcpy( psShape->panPartStart, psSHP->pabyRec + 44 + 8, 4 * nParts );
for( i = 0; i < nParts; i++ )
{
- if( bBigEndian ) SwapWord( 4, psShape->panPartStart+i );
+ if( bBigEndian ) Swap4Bytes(psShape->panPartStart+i );
}
nOffset = 44 + 8 + 4*nParts;
@@ -1122,7 +1093,7 @@
memcpy( psShape->panPartType, psSHP->pabyRec + nOffset, 4*nParts );
for( i = 0; i < nParts; i++ )
{
- if( bBigEndian ) SwapWord( 4, psShape->panPartType+i );
+ if( bBigEndian ) Swap4Bytes(psShape->panPartType+i );
}
nOffset += 4*nParts;
@@ -1141,8 +1112,8 @@
psSHP->pabyRec + nOffset + i * 16 + 8,
8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfX + i );
- if( bBigEndian ) SwapWord( 8, psShape->padfY + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfX + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfY + i );
}
nOffset += 16*nPoints;
@@ -1157,14 +1128,14 @@
memcpy( &(psShape->dfZMin), psSHP->pabyRec + nOffset, 8 );
memcpy( &(psShape->dfZMax), psSHP->pabyRec + nOffset + 8, 8 );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfZMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfZMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfZMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfZMax) );
for( i = 0; i < nPoints; i++ )
{
memcpy( psShape->padfZ + i,
psSHP->pabyRec + nOffset + 16 + i*8, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfZ + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfZ + i );
}
nOffset += 16 + 8*nPoints;
@@ -1181,14 +1152,14 @@
memcpy( &(psShape->dfMMin), psSHP->pabyRec + nOffset, 8 );
memcpy( &(psShape->dfMMax), psSHP->pabyRec + nOffset + 8, 8 );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfMMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfMMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfMMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfMMax) );
for( i = 0; i < nPoints; i++ )
{
memcpy( psShape->padfM + i,
psSHP->pabyRec + nOffset + 16 + i*8, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfM + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfM + i );
}
}
@@ -1205,7 +1176,7 @@
int i, nOffset;
memcpy( &nPoints, psSHP->pabyRec + 44, 4 );
- if( bBigEndian ) SwapWord( 4, &nPoints );
+ if( bBigEndian ) Swap4Bytes(&nPoints );
psShape->nVertices = nPoints;
psShape->padfX = (double *) calloc(nPoints,sizeof(double));
@@ -1218,8 +1189,8 @@
memcpy(psShape->padfX+i, psSHP->pabyRec + 48 + 16 * i, 8 );
memcpy(psShape->padfY+i, psSHP->pabyRec + 48 + 16 * i + 8, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfX + i );
- if( bBigEndian ) SwapWord( 8, psShape->padfY + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfX + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfY + i );
}
nOffset = 48 + 16*nPoints;
@@ -1232,10 +1203,10 @@
memcpy( &(psShape->dfXMax), psSHP->pabyRec + 8 + 20, 8 );
memcpy( &(psShape->dfYMax), psSHP->pabyRec + 8 + 28, 8 );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfXMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfYMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfXMax) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfYMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfXMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfYMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfXMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfYMax) );
/* -------------------------------------------------------------------- */
/* If we have a Z coordinate, collect that now. */
@@ -1245,14 +1216,14 @@
memcpy( &(psShape->dfZMin), psSHP->pabyRec + nOffset, 8 );
memcpy( &(psShape->dfZMax), psSHP->pabyRec + nOffset + 8, 8 );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfZMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfZMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfZMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfZMax) );
for( i = 0; i < nPoints; i++ )
{
memcpy( psShape->padfZ + i,
psSHP->pabyRec + nOffset + 16 + i*8, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfZ + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfZ + i );
}
nOffset += 16 + 8*nPoints;
@@ -1269,14 +1240,14 @@
memcpy( &(psShape->dfMMin), psSHP->pabyRec + nOffset, 8 );
memcpy( &(psShape->dfMMax), psSHP->pabyRec + nOffset + 8, 8 );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfMMin) );
- if( bBigEndian ) SwapWord( 8, &(psShape->dfMMax) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfMMin) );
+ if( bBigEndian ) Swap8Bytes(&(psShape->dfMMax) );
for( i = 0; i < nPoints; i++ )
{
memcpy( psShape->padfM + i,
psSHP->pabyRec + nOffset + 16 + i*8, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfM + i );
+ if( bBigEndian ) Swap8Bytes(psShape->padfM + i );
}
}
}
@@ -1299,8 +1270,8 @@
memcpy( psShape->padfX, psSHP->pabyRec + 12, 8 );
memcpy( psShape->padfY, psSHP->pabyRec + 20, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfX );
- if( bBigEndian ) SwapWord( 8, psShape->padfY );
+ if( bBigEndian ) Swap8Bytes(psShape->padfX );
+ if( bBigEndian ) Swap8Bytes(psShape->padfY );
nOffset = 20 + 8;
@@ -1311,7 +1282,7 @@
{
memcpy( psShape->padfZ, psSHP->pabyRec + nOffset, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfZ );
+ if( bBigEndian ) Swap8Bytes(psShape->padfZ );
nOffset += 8;
}
@@ -1326,7 +1297,7 @@
{
memcpy( psShape->padfM, psSHP->pabyRec + nOffset, 8 );
- if( bBigEndian ) SwapWord( 8, psShape->padfM );
+ if( bBigEndian ) Swap8Bytes(psShape->padfM );
}
/* -------------------------------------------------------------------- */
@@ -1598,7 +1569,7 @@
return bAltered;
}
/******************************************************************************
- * $Id: dbfopen.c,v 1.48 2003/03/10 14:51:27 warmerda Exp $
+ * $Id$
*
* Project: Shapelib
* Purpose: Implementation of .dbf access API documented in dbf_api.html.
@@ -2434,7 +2405,7 @@
{
int nWidth = psDBF->panFieldSize[iField];
- if( sizeof(szSField)-2 < nWidth ) nWidth = sizeof(szSField)-2;
+ if( (int)sizeof(szSField)-2 < nWidth ) nWidth = sizeof(szSField)-2;
sprintf( szFormat, "%%%dd", nWidth );
sprintf(szSField, szFormat, (int) *((double *) pValue) );
@@ -2451,7 +2422,7 @@
{
int nWidth = psDBF->panFieldSize[iField];
- if( sizeof(szSField)-2 < nWidth ) nWidth = sizeof(szSField)-2;
+ if( (int)sizeof(szSField)-2 < nWidth ) nWidth = sizeof(szSField)-2;
sprintf( szFormat, "%%%d.%df", nWidth, psDBF->panFieldDecimals[iField] );
sprintf(szSField, szFormat, *((double *) pValue) );
Modified: trunk/src/test_file.cpp
===================================================================
--- trunk/src/test_file.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/test_file.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -65,15 +65,15 @@
// Test der Dateiein- und ausgabe
////////////////////////////////////////
- printf ("**************************\n");
- printf ("Test Dateiein- und Ausgabe\n");
+ printf ("*************************************************************************\n");
+ printf ("Test Datei Ein- und Ausgabe\n");
/////////////////////////////////////////////////
// Test von Parameterdatei laden
/////////////////////////////////////////////////
{
- printf ("Test Parameterdatei laden: ");
+ printf ("Test Parameterdatei laden: ");
char test1[80] = "test";
char test2[80] = "-par=test_daten\\test.par";
@@ -102,7 +102,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-TIN ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-TIN ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -121,7 +121,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-TIN mit Begrenzungspolygon laden: ");
+ printf ("Test DGM-TIN mit Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -146,7 +146,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-GRD mit Begrenzungspolygon laden: ");
+ printf ("Test DGM-GRD mit Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -171,7 +171,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -190,7 +190,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -209,7 +209,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -228,7 +228,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-XYZ ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -249,7 +249,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-SHP ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-SHP ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -268,7 +268,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-SHP mit Begrenzungspolygon laden: ");
+ printf ("Test DGM-SHP mit Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -293,7 +293,7 @@
/////////////////////////////////////////////////
{
- printf ("Test DGM-2DM ohne Begrenzungspolygon laden: ");
+ printf ("Test DGM-2DM ohne Begrenzungspolygon laden: ");
TNodeList *NodeList = new TNodeList();
TElementList *ElementList = new TElementList();
@@ -312,11 +312,11 @@
////////////////////////////////////////
{
- printf ("Test Profilspuren laden: ");
+ printf ("Test Profilspuren laden: ");
TProfilList *ProfilList = new TProfilList();
- LoadProfile(PROFILFILE, ProfilList, 8);
+ LoadProfile(PROFILFILE, ProfilList, -9999.9, 9999.9, 8);
if (ProfilList->size() == 8) printf("Pass\n");
else printf("Failed\n");
@@ -329,11 +329,11 @@
////////////////////////////////////////
{
- printf ("Test Z-Profilspuren laden: ");
+ printf ("Test Z-Profilspuren laden: ");
TProfilList *ProfilList = new TProfilList();
- LoadProfile(PROFILZFILE, ProfilList, 8);
+ LoadProfile(PROFILZFILE, ProfilList, -9999.9, 9999.9, 8);
if (ProfilList->size() == 5) printf("Pass\n");
else printf("Failed\n");
@@ -346,18 +346,20 @@
////////////////////////////////////////
{
- printf ("Test Strukturen laden: ");
+ printf ("Test Strukturen laden: ");
TProfilList *SperrenList = new TProfilList();
- TProfilList *BruchList = new TProfilList();
+ TProfilList *GrabenList = new TProfilList();
+ TProfilList *RohreList = new TProfilList();
- LoadLinien(LINIENFILE, SperrenList, BruchList, 8);
+ LoadLinien(LINIENFILE, SperrenList, GrabenList, RohreList, 8);
- if (SperrenList->size() == 5 && BruchList->size() == 4) printf("Pass\n");
- else printf("Failed\n");
+ if (SperrenList->size() == 5 && GrabenList->size() == 4 && RohreList->size() == 0) printf("Pass\n");
+ else printf("Failed\n");
+ delete RohreList;
+ delete GrabenList;
delete SperrenList;
- delete BruchList;
}
////////////////////////////////////////
@@ -365,7 +367,7 @@
////////////////////////////////////////
{
- printf ("Test Wasserstände als TXT laden: ");
+ printf ("Test Wasserstände als TXT laden: ");
TProfilList *WspList = new TProfilList();
@@ -382,7 +384,7 @@
////////////////////////////////////////
{
- printf ("Test Wasserstände als DBF laden: ");
+ printf ("Test Wasserstände als DBF laden: ");
TProfilList *WspList = new TProfilList();
@@ -399,7 +401,7 @@
////////////////////////////////////////
{
- printf ("Test Gewässerahse laden: ");
+ printf ("Test Gewässerahse laden: ");
TGewaesserAchseList *AchsenList = new TGewaesserAchseList();
@@ -411,5 +413,5 @@
delete AchsenList;
}
- printf ("**************************\n");
+ printf ("*************************************************************************\n");
}
Modified: trunk/src/test_nodes.cpp
===================================================================
--- trunk/src/test_nodes.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/test_nodes.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -15,8 +15,16 @@
#endif
//---------------------------------------------------------------------------
+#ifdef __BORLANDC__
+#define DGMTINFILE "test_daten\\dgmtin\\tnxy.adf"
+#else
+#define DGMTINFILE "test_daten/dgmtin/tnxy.adf"
+#endif
+
+//---------------------------------------------------------------------------
#include <stdio.h>
-#include <stdexcept>
+
+#include "file.h"
#include "xy.h"
//---------------------------------------------------------------------
@@ -26,9 +34,171 @@
// Test der Knoten und Elementverwaltung
////////////////////////////////////////
- printf ("*********************\n");
+ printf ("*************************************************************************\n");
printf ("Test Knotenverwaltung\n");
- printf ("*********************\n");
+ {
+ printf ("Test Knoten: ");
+
+ TNode *P11 = new TNode(1, 1.0, 1.0, 0.0);
+ TNode *P12 = new TNode(2, 9.0, 1.0, 0.0);
+ TNode *P13 = new TNode(3, 9.0, 9.0, 0.0);
+ TNode *P14 = new TNode(4, 1.0, 9.0, 0.0);
+ TNode *P15 = new TNode(5, 4.0, 9.0, 0.0);
+ TNode *P16 = new TNode(6, 7.0, 9.0, 0.0);
+ TNode *P17 = new TNode(7, 7.0, 7.0, 0.0);
+ // NrSumme = 28, XSumme = 38, YSumme = 45, ZSumme = 0, WspSumme = -69993
+
+ // NrSumme = 15, XSumme = 24, YSumme = 25, ZSumme = 15, WspSumme = -49995
+ TNode *P21 = new TNode(1, 3.0, 4.0, 1.0);
+ TNode *P22 = new TNode(2, 7.0, 4.0, 2.0);
+ TNode *P23 = new TNode(3, 7.0, 6.0, 3.0);
+ TNode *P24 = new TNode(4, 3.0, 6.0, 4.0);
+ TNode *P25 = new TNode(5, 4.0, 5.0, 5.0);
+ // NrSumme = 43, XSumme = 62, YSumme = 70, ZSumme = 15, WspSumme = -119988
+
+ // NrSumme = 3, XSumme = 10, YSumme = 11, ZSumme = 8, WspSumme = 7
+ TNode *P31 = new TNode(P21);
+ TNode *P32 = new TNode(2, 7.0, 7.0, 7.0, 7.0);
+
+ // Jetzt zwei leere KnotenListen generieren
+ TNodeList *PL1 = new TNodeList();
+ TNodeList *PL2 = new TNodeList();
+
+ // Ein paar Punkte zur ersten Polylinie zuweisen
+ PL1->push_back(P11);
+ PL1->push_back(P12);
+ PL1->push_back(P13);
+ PL1->push_back(P14);
+ PL1->push_back(P15);
+ PL1->push_back(P16);
+ PL1->push_back(P17);
+
+ // Ein paar Punkte zur zweiten Polylinie zuweisen
+ PL2->push_back(P21);
+ PL2->push_back(P22);
+ PL2->push_back(P23);
+ PL2->push_back(P24);
+ PL2->push_back(P25);
+
+ // Die zweite Knotenliste verdoppeln
+ // Dabei werden alle Punkte mit verdoppelt
+
+ // NrSumme = 15, XSumme = 24, YSumme = 25, ZSumme = 15, WspSumme = -49995
+ TNodeList *PL3 = PL2->Copy();
+ // NrSumme = 58, XSumme = 86, YSumme = 95, ZSumme = 30, WspSumme = -169983
+
+ // Und noch zwei Punkte dazu
+ // NrSumme = 3, XSumme = 10, YSumme = 11, ZSumme = 8, WspSumme = -9999+7
+ PL3->push_back(P31);
+ PL3->push_back(P32);
+ // NrSumme = 61, XSumme = 96, YSumme = 106, ZSumme = 38, WspSumme = -179975
+
+ int NrSumme = 0;
+ int XSumme = 0;
+ int YSumme = 0;
+ int ZSumme = 0;
+ int WspSumme = 0;
+
+ for (TNodeList::iterator i = PL1->begin(); i != PL1->end(); i++)
+ {
+ TNode* Node = *i;
+
+ NrSumme = NrSumme + (int)Node->Nr;
+ XSumme = XSumme + (int)Node->X;
+ YSumme = YSumme + (int)Node->Y;
+ ZSumme = ZSumme + (int)Node->Z;
+ WspSumme = WspSumme + (int)Node->Wsp;
+ }
+
+ for (TNodeList::iterator i = PL2->begin(); i != PL2->end(); i++)
+ {
+ TNode* Node = *i;
+
+ NrSumme = NrSumme + (int)Node->Nr;
+ XSumme = XSumme + (int)Node->X;
+ YSumme = YSumme + (int)Node->Y;
+ ZSumme = ZSumme + (int)Node->Z;
+ WspSumme = WspSumme + (int)Node->Wsp;
+ }
+
+ for (TNodeList::iterator i = PL3->begin(); i != PL3->end(); i++)
+ {
+ TNode* Node = *i;
+
+ NrSumme = NrSumme + (int)Node->Nr;
+ XSumme = XSumme + (int)Node->X;
+ YSumme = YSumme + (int)Node->Y;
+ ZSumme = ZSumme + (int)Node->Z;
+ WspSumme = WspSumme + (int)Node->Wsp;
+ }
+
+ if (PL1->size() != 7 || PL2->size() != 5 || PL3->size() != 7) printf("Failed\n");
+ else if (NrSumme != 61 || XSumme != 96 || YSumme != 106) printf("Failed\n");
+ else if (ZSumme != 38 || WspSumme != -9999 * 18 + 7) printf("Failed\n");
+ else printf("Pass\n");
+ }
+
+ {
+ printf ("Test Knoten Sortieren: ");
+
+ TNode *P11 = new TNode(1, 1.0, 1.0, 0.0);
+ TNode *P12 = new TNode(2, 9.0, 1.0, 0.0);
+ TNode *P13 = new TNode(3, 9.0, 9.0, 0.0);
+ TNode *P14 = new TNode(4, 1.0, 9.0, 0.0);
+ TNode *P15 = new TNode(5, 4.0, 9.0, 0.0);
+ TNode *P16 = new TNode(6, 7.0, 9.0, 0.0);
+ TNode *P17 = new TNode(7, 7.0, 7.0, 0.0);
+
+ // Jetzt eine leere KnotenListe generieren
+ TNodeList *PL1 = new TNodeList();
+
+ // Ein paar Punkte zur ersten Polylinie zuweisen
+ PL1->push_back(P11);
+ PL1->push_back(P12);
+ PL1->push_back(P13);
+ PL1->push_back(P14);
+ PL1->push_back(P15);
+ PL1->push_back(P16);
+ PL1->push_back(P17);
+
+ PL1->SortByXY();
+ // Der letzt Knoten
+ TNode *Node11 = *PL1->begin();
+ TNode *Node12 = *PL1->rbegin();
+
+ PL1->SortByNr();
+ // Der letzt Knoten
+ TNode *Node21 = *PL1->begin();
+ TNode *Node22 = *PL1->rbegin();
+
+ if (Node11->Nr != 1 || Node12->Nr != 3) printf("Failed\n");
+ else if (Node21->Nr != 1 || Node22->Nr != 7) printf("Failed\n");
+ else printf("Pass\n");
+ }
+
+ {
+ printf ("Test Knoten Suchen: ");
+
+ TNodeList *NodeList = new TNodeList();
+ TElementList *ElementList = new TElementList();
+
+ LoadDGM(DGMTINFILE, NodeList, ElementList, 0, 100000, 8);
+
+ TNode* Node1 = NodeList->FindByXY(8080895.32, 2623659.13, 1);
+
+ TNodeList *FoundList = NodeList->FindAllByXY(8080854.58, 2623659.69, 30000.0);
+
+ TNode* Node2 = *FoundList->begin();
+ TNode* Node3 = *FoundList->rbegin();
+
+ if (Node1 == 0 || Node1->Nr != 50) printf("Failed\n");
+ else if (Node2 == 0 || Node2->Nr != 115) printf("Failed\n");
+ else if (Node3 == 0 || Node3->Nr != 39) printf("Failed\n");
+ else if (FoundList->size() != 4) printf("Failed\n");
+ else printf("Pass\n");
+ }
+
+ printf ("*************************************************************************\n");
}
Modified: trunk/src/test_tools.cpp
===================================================================
--- trunk/src/test_tools.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/test_tools.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -25,415 +25,211 @@
// Test der Tools
////////////////////////////////////////
- printf ("\nTest Tools\n");
+ printf ("*************************************************************************\n");
+ printf ("Test Tools\n");
////////////////////////////////////////
- // Test der Zeichenkettenhilfsfunktionen
+ // Test von CircumCircle
////////////////////////////////////////
- printf ("\nTest Zeichenkettenhilfsfunktionen\n");
+ {
+ printf ("Test CircumCircle : ");
- printf ("\nTest ToUpperCase\n");
+ TNode N1(1, 1.0, 1.0, 1.0);
+ TNode N2(2, 3.0, 4.0, 1.0);
+ TNode N3(3, 3.0, 6.0, 1.0);
+ TNode N4(4, 3.0, 7.0, 1.0);
+ TNode N5(5, 3500833.39, 5873151.40, 1.0);
+ TNode N6(6, 3500835.54, 5873155.65, 1.0);
+ TNode N7(7, 3500809.24, 5873159.03, 1.0);
+ TNode N8(8, 3500815.10, 5873170.62, 1.0);
- std::string Lower = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZaabbccddeeff";
- std::string Upper = ToUpperCase(Lower);
- printf ("'%s'\nist in Grossbuchstaben\n'%s'\n", Lower.c_str(), Upper.c_str());
+ double CX1, CY1, R1;
+ bool OK1 = CircumCircle(&N1, &N2, &N3, &CX1, &CY1, &R1);
- printf ("\nTest GetFileExt\n");
+ double CX2, CY2, R2;
+ bool OK2 = CircumCircle(&N2, &N3, &N4, &CX2, &CY2, &R2);
- std::string FileName = "c:\\hallo\\test.adf";
- std::string Ext = GetFileExt(FileName);
- printf ("Die Dateiendung von '%s' ist '%s'\n", FileName.c_str(), Ext.c_str());
+ double CX3, CY3, R3;
+ bool OK3 = CircumCircle(&N5, &N6, &N7, &CX3, &CY3, &R3);
- FileName = "c:\\hallo\\test";
- Ext = GetFileExt(FileName);
- printf ("Die Dateiendung von '%s' ist '%s'\n", FileName.c_str(), Ext.c_str());
+ double CX4, CY4, R4;
+ bool OK4 = CircumCircle(&N5, &N6, &N8, &CX4, &CY4, &R4);
+ if (false == OK1) printf("Failed\n");
+ else if (fabs(sqrt(R1) - 4.8541) > 0.001) printf("Failed\n");
+ else if (fabs(CX1 - (-1.75)) > 0.001) printf("Failed\n");
+ else if (fabs(CY1 - 5) > 0.001) printf("Failed\n");
+ else if (true == OK2) printf("Failed\n");
+ else if (false == OK3) printf("Failed\n");
+ else if (fabs(sqrt(R3) - 13.4348) > 0.001) printf("Failed\n");
+ else if (fabs(CX3 - 3500822.6668) > 0.001) printf("Failed\n");
+ else if (fabs(CY3 - 5873159.4935) > 0.001) printf("Failed\n");
+ else if (false == OK4) printf("Failed\n");
+ else if (fabs(sqrt(R4) - 13.4458) > 0.001) printf("Failed\n");
+ else if (fabs(CX4 - 3500822.6567) > 0.001) printf("Failed\n");
+ else if (fabs(CY4 - 5873159.4986) > 0.001) printf("Failed\n");
+ else printf("Pass\n");
+ }
- FileName = "c:\\hallo\\test.txt.shp";
- Ext = GetFileExt(FileName);
- printf ("Die Dateiendung von '%s' ist '%s'\n", FileName.c_str(), Ext.c_str());
-
- printf ("\nTest ExchangeFileExt\n");
-
- std::string NewFileName = ExchangeFileExt(FileName, ".dat");
- printf ("Die Dateiendung wird durch .dat ausgetauscht\nAus '%s'\nwird\n'%s'\n", FileName.c_str(), NewFileName.c_str());
-
- std::string Path = GetFilePath(FileName);
- printf ("Der Pfad von '%s' ist '%s'\n", NewFileName.c_str(), Path.c_str());
-
- FileName = "c:/test/einwenigunix.txt";
- Path = GetFilePath(FileName);
- printf ("Der Pfad von '%s' ist '%s'\n", FileName.c_str(), Path.c_str());
-
- FileName = "c:test/nichtganzkorrekt.txt";
- Path = GetFilePath(FileName);
- printf ("Der Pfad von '%s' ist '%s'\n", FileName.c_str(), Path.c_str());
-
- FileName = "c:nochwenigerkorrekt.txt";
- Path = GetFilePath(FileName);
- printf ("Der Pfad von '%s' ist '%s'\n", FileName.c_str(), Path.c_str());
-
- FileName = "c:\\";
- Path = GetFilePath(FileName);
- printf ("Der Pfad von '%s' ist '%s'\n", FileName.c_str(), Path.c_str());
-
- FileName = "test.txt";
- Path = GetFilePath(FileName);
- printf ("Der Pfad von '%s' ist '%s'\n", FileName.c_str(), Path.c_str());
-
////////////////////////////////////////
- // Test der Fehlerausgabe
+ // Test der Zeichenkettenhilfsfunktionen
////////////////////////////////////////
- printf ("\nTest Fehlerausgabe\n");
-
- try
{
- dump_error(__FILE__, __LINE__, "Dies ist keine Fehler.\nEs werden nur 3 Argumente der Typen char *, double und int ausgegeben\nArg 1: '%s'\nArg 2: %f\nArg 3: %d\n", "Test String", 3.1415926, 1029233);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
+ printf ("Test ToUpperCase : ");
+ std::string Lower = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZaabbccddeeff";
+ std::string Upper = ToUpperCase(Lower);
+ if (Upper != "AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZAABBCCDDEEFF") printf("Failed\n");
+ else printf("Pass\n");
+ }
- ////////////////////////////////////////
- // Test der Binärumwandlung long
- ////////////////////////////////////////
+ {
+ printf ("Test GetFileExt: ");
- printf ("\nTest Binärumwandlung 32-Bit\n");
+ std::string FileName1 = "c:\\hallo\\test.adf";
+ std::string Ext1 = GetFileExt(FileName1);
- unsigned long LongValue = 0L;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName2 = "c:\\hallo\\test";
+ std::string Ext2 = GetFileExt(FileName2);
- LongValue = 1;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName3 = "c:\\hallo\\test.txt.SHP";
+ std::string Ext3 = GetFileExt(FileName3);
- LongValue = 2;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ if (Ext1 != ".adf" || Ext2 != "" || Ext3 != ".SHP") printf("Failed\n");
+ else printf("Pass\n");
+ }
- LongValue = 123;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ {
+ printf ("Test ExchangeFileExt: ");
- LongValue = 0x1000;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName = "c:\\hallo\\test.adf";
+ std::string NewFileName = ExchangeFileExt(FileName, ".dat");
- LongValue = 0x7FFFFFFE;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ if (NewFileName != "c:\\hallo\\test.dat") printf("Failed\n");
+ else printf("Pass\n");
+ }
- LongValue = 0x7FFFFFFF;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ {
+ printf ("Test GetFilePath: ");
- LongValue = 0x80000000;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName1 = "c:\\hallo\\test.adf";
+ std::string Path1 = GetFilePath(FileName1);
- LongValue = 0x80000001;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName2 = "c:/test/einwenigunix.txt";
+ std::string Path2 = GetFilePath(FileName2);
- LongValue = 0xF0000000;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName3 = "c:test/nichtganzkorrekt.txt";
+ std::string Path3 = GetFilePath(FileName3);
- LongValue = 0xFF000000;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName4 = "c:nochwenigerkorrekt.txt";
+ std::string Path4 = GetFilePath(FileName4);
- LongValue = 0xFFFFF000;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName5 = "c:\\";
+ std::string Path5 = GetFilePath(FileName5);
- LongValue = 0xFFFFFFFE;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ std::string FileName6 = "test.txt";
+ std::string Path6 = GetFilePath(FileName6);
- LongValue = 0xFFFFFFFF;
- printf ("Value = %lu -> Value = %s\n", LongValue, UnsignedInt32ToBin(LongValue, "").c_str());
+ if (Path1 != "c:\\hallo\\") printf("Failed\n");
+ else if (Path2 != "c:/test/") printf("Failed\n");
+ else if (Path3 != "c:test/") printf("Failed\n");
+ else if (Path4 != "c:") printf("Failed\n");
+ else if (Path5 != "c:\\") printf("Failed\n");
+ else if (Path6 != "") printf("Failed\n");
+ else printf("Pass\n");
+ }
////////////////////////////////////////
- // Test der Binärumwandlung __int64
- ////////////////////////////////////////
-
- printf ("\nTest Binärumwandlung 64-Bit\n");
-
- unsigned INT64 Value = INT64SUFF(0);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(1);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(2);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(123);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(4096);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(2147483648);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(34359738368);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(9223372036854775806);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(9223372036854775807);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(9223372036854775808);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(9223372036854775809);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(17293822569102704640);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(18374686479671623680);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(18446726481523507200);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(18446744073709551360);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(18446744073709551600);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(18446744073709551614);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
- Value = INT64SUFF(18446744073709551615);
- printf ("Value = %s -> Value = %s\n", UnsignedInt64ToDez(Value).c_str(), UnsignedInt64ToBin(Value).c_str());
-
-
- ////////////////////////////////////////
// Test der XYKombination
////////////////////////////////////////
- printf ("\nTest XYKombination\n");
+ {
+ printf ("Test XYKombination: ");
- unsigned INT64 TestXYKombi = INT64SUFF(0);
+ unsigned INT64 XYKombi = INT64SUFF(0);
- double X = 0.0;
- double Y = 0.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(0.0, 0.0);
+ std::string XYKombiStr1 = UnsignedInt64ToBin(XYKombi);
- X = 1.0;
- Y = 0.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(1.0, 0.0);
+ std::string XYKombiStr2 = UnsignedInt64ToBin(XYKombi);
- X = 0.0;
- Y = 1.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(0.0, 1.0);
+ std::string XYKombiStr3 = UnsignedInt64ToBin(XYKombi);
- X = 1.0;
- Y = 1.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(1.0, 1.0);
+ std::string XYKombiStr4 = UnsignedInt64ToBin(XYKombi);
- X = 10.0;
- Y = 10.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(10.0, 10.0);
+ std::string XYKombiStr5 = UnsignedInt64ToBin(XYKombi);
- X = 100.0;
- Y = 100.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(100.0, 100.0);
+ std::string XYKombiStr6 = UnsignedInt64ToBin(XYKombi);
- X = 10000.0;
- Y = 10000.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(10000.0, 10000.0);
+ std::string XYKombiStr7 = UnsignedInt64ToBin(XYKombi);
- X = 1000000.0;
- Y = 1000000.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(6000000.0, 6000000.0);
+ std::string XYKombiStr8 = UnsignedInt64ToBin(XYKombi);
- X = 6000000.0;
- Y = 6000000.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ XYKombi = CalcXYKombi(0x7FFFFFFFL, 0x7FFFFFFFL);
+ std::string XYKombiStr9 = UnsignedInt64ToBin(XYKombi);
- X = 0x7FFFFFFFL;
- Y = 0x7FFFFFFFL;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
-
- try
- {
- X = 0x80000000L;
- Y = 0x7FFFFFFFL;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
+ if (XYKombiStr1 != "0000000000000000000000000000000000000000000000000000000000000000") printf("Failed\n");
+ else if (XYKombiStr2 != "0000000000000000000000000000000000000000000000000000000000000010") printf("Failed\n");
+ else if (XYKombiStr3 != "0000000000000000000000000000000000000000000000000000000000000001") printf("Failed\n");
+ else if (XYKombiStr4 != "0000000000000000000000000000000000000000000000000000000000000011") printf("Failed\n");
+ else if (XYKombiStr5 != "0000000000000000000000000000000000000000000000000000000011001100") printf("Failed\n");
+ else if (XYKombiStr6 != "0000000000000000000000000000000000000000000000000011110000110000") printf("Failed\n");
+ else if (XYKombiStr7 != "0000000000000000000000000000000000001100001111110000001100000000") printf("Failed\n");
+ else if (XYKombiStr8 != "0000000000000000001100111100111111000000111100111100000000000000") printf("Failed\n");
+ else if (XYKombiStr9 != "0011111111111111111111111111111111111111111111111111111111111111") printf("Failed\n");
+ else printf("Pass\n");
}
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
- try
- {
- X = 0x7FFFFFFFL;
- Y = 0x80000000L;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
- try
- {
- X = -1.0;
- Y = 1.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
- try
- {
- X = 1.0;
- Y = -1.0;
- TestXYKombi = CalcXYKombi(X, Y);
- printf ("X = %10.2f Y = %10.2f\n", X, Y);
- printf ("%s\n", UnsignedInt32ToBin((long)X, " ").c_str());
- printf (" %s\n", UnsignedInt32ToBin((long)Y, " ").c_str());
- printf ("%s\n\n", UnsignedInt64ToBin(TestXYKombi).c_str());
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
-
////////////////////////////////////////
// Test der Funktion IsInside
////////////////////////////////////////
- printf ("\nTest IsInside\n");
-
- TXYList *XyList = 0;
- int alpha = -999;
-
- try
{
- alpha = IsInside(XyList, 1.0, 1.0);
- }
- catch(TFehler)
- {
- printf ("Fehler korrekt gefangen\n");
- }
+ printf ("Test IsInside: ");
- XyList = new TXYList();
+ TXYList *XyList = new TXYList();
- alpha = IsInside(XyList, 1.0, 1.0);
- if (alpha == 0) printf ("Punkt %f, %f nicht im Polygon. OK.\n", 1.0, 1.0);
- else printf ("Fehler.\n");
+ int Alpha1 = IsInside(XyList, 1.0, 1.0);
- TXY *Xy = 0;
+ XyList->push_back(new TXY(2.0, 3.0));
- Xy = new TXY(2, 2);
- XyList->push_back(Xy);
+ int Alpha2 = IsInside(XyList, 2.0, 3.0);
+ int Alpha3 = IsInside(XyList, 1.0, 1.0);
- alpha = IsInside(XyList, 2.0, 2.0);
- if (alpha == -1) printf ("Punkt %f, %f ist auf dem Rand des Polygons. OK.\n", 2.0, 2.0);
- else printf ("Fehler.\n");
+ XyList->push_back(new TXY(2, 0));
- alpha = IsInside(XyList, 1.0, 1.0);
- if (alpha == 0) printf ("Punkt %f, %f ist nicht im Polygon. OK.\n", 1.0, 1.0);
- else printf ("Fehler.\n");
+ int Alpha4 = IsInside(XyList, 2.0, 1.0);
- Xy = new TXY(2, 0);
- XyList->push_back(Xy);
+ XyList->push_back(new TXY(0, 0));
+ XyList->push_back(new TXY(0, 2));
- alpha = IsInside(XyList, 2.0, 1.0);
- if (alpha == -1) printf ("Punkt %f, %f ist auf dem Rand des Polygons. OK.\n", 2.0, 2.0);
- else printf ("Fehler.\n");
+ int Alpha5 = IsInside(XyList, 1.0, 1.0);
+ int Alpha6 = IsInside(XyList, 3.0, 3.0);
+ int Alpha7 = IsInside(XyList, 2.0, 2.0);
- Xy = new TXY(0, 0);
- XyList->push_back(Xy);
+ if (Alpha1 != 0) printf("Failed\n");
+ else if (Alpha2 != -1) printf("Failed\n");
+ else if (Alpha3 != 0) printf("Failed\n");
+ else if (Alpha4 != -1) printf("Failed\n");
+ else if (Alpha5 != -4) printf("Failed\n");
+ else if (Alpha6 != 0) printf("Failed\n");
+ else if (Alpha7 != -1) printf("Failed\n");
+ else printf("Pass\n");
- Xy = new TXY(0, 2);
- XyList->push_back(Xy);
+ delete XyList;
+ }
- X = 1.0;
- Y = 1.0;
-
- alpha = IsInside(XyList, X, Y);
- if (alpha == 0) printf ("1,1 ist nicht im Polygon.\n");
- else if (alpha == -4) printf ("1,1 ist im Polygon (Polygon ist mit dem Uhrzeigersinn)\n");
- else if (alpha == 4) printf ("1,1 ist im Polygon (Polygon ist gegen den Uhrzeigersinn)\n");
- else if (alpha == -1) printf ("1,1 ist auf dem Rand von Polygon\n");
- else dump_error(__FILE__, __LINE__, "Unbekannter Wert für Alpha");
-
- X = 3.0;
- Y = 3.0;
- alpha = IsInside(XyList, X, Y);
- if (alpha == 0) printf ("3,3 ist nicht im Polygon.\n");
- else if (alpha == -4) printf ("3,3 ist im Polygon (Polygon ist mit dem Uhrzeigersinn)\n");
- else if (alpha == 4) printf ("3,3 ist im Polygon (Polygon ist gegen den Uhrzeigersinn)\n");
- else if (alpha == -1) printf ("3,3 ist auf dem Rand von Polygon\n");
- else dump_error(__FILE__, __LINE__, "Unbekannter Wert für Alpha");
-
- X = 2.0;
- Y = 2.0;
- alpha = IsInside(XyList, X, Y);
- if (alpha == 0) printf ("2,2 ist nicht im Polygon.\n");
- else if (alpha == -4) printf ("2,2 ist im Polygon (Polygon ist mit dem Uhrzeigersinn)\n");
- else if (alpha == 4) printf ("2,2 ist im Polygon (Polygon ist gegen den Uhrzeigersinn)\n");
- else if (alpha == -1) printf ("2,2 ist auf dem Rand von Polygon\n");
- else dump_error(__FILE__, __LINE__, "Unbekannter Wert für Alpha");
-
- delete XyList;
+ printf ("*************************************************************************\n");
}
+
Modified: trunk/src/test_tri.cpp
===================================================================
--- trunk/src/test_tri.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/test_tri.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -15,6 +15,13 @@
#endif
//---------------------------------------------------------------------------
+#ifdef __BORLANDC__
+#define DGMFILE "test_daten\\dgm2.shp"
+#else
+#define DGMFILE "test_daten/dgm2.shp"
+#endif
+
+//---------------------------------------------------------------------------
#include <stdio.h>
#include "file.h"
@@ -29,96 +36,94 @@
// Test der Triangulierung
////////////////////////////////////////
- printf ("\nTest Triangulierung\n");
+ printf ("*************************************************************************\n");
+ printf ("Test Triangulierung\n");
- // Zuerst ein paar Punkte generieren
- TNode *N01 = new TNode(1, 1.0, 1.0, 0.0);
- TNode *N02 = new TNode(2, 9.0, 1.0, 0.0);
- TNode *N03 = new TNode(3, 9.0, 9.0, 0.0);
+ {
+ printf ("Test Triangulierung 3 Knoten : ");
- TNodeList *NL = new TNodeList();
+ // Zuerst ein paar Punkte generieren
+ TNode *N01 = new TNode(1, 1.0, 1.0, 0.0);
+ TNode *N02 = new TNode(2, 9.0, 1.0, 0.0);
+ TNode *N03 = new TNode(3, 9.0, 9.0, 0.0);
- NL->push_back(N01);
- NL->push_back(N02);
- NL->push_back(N03);
+ TNodeList *NodeList = new TNodeList();
- TElementList *EL = new TElementList();
+ NodeList->push_back(N01);
+ NodeList->push_back(N02);
+ NodeList->push_back(N03);
- Triangulate(NL, EL, true);
+ TElementList *ElementList = new TElementList();
- printf("Anzahl Elemente in Elementliste: %d\n", EL->size());
- for (unsigned int j=0; j<EL->size(); j++)
- {
- TElement *Element = (*EL)[j];
+ Triangulate(NodeList, ElementList, 8);
- printf("Knoten die das Element %d bilden:", j);
- if (Element->Typ == TRI)
- {
- TNode *Node1 = Element->Node1;
- TNode *Node2 = Element->Node2;
- TNode *Node3 = Element->Node3;
- printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
- }
- 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);
- }
+ if (ElementList->size() != 1) printf("Failed\n");
+ else printf("Pass\n");
+
+ delete ElementList;
+ delete NodeList;
}
- TNode *N04 = new TNode(4, 1.0, 9.0, 0.0);
- TNode *N05 = new TNode(5, 4.0, 9.0, 0.0);
- TNode *N06 = new TNode(6, 7.0, 9.0, 0.0);
- TNode *N07 = new TNode(7, 7.0, 7.0, 0.0);
- TNode *N08 = new TNode(8, 3.0, 4.0, 0.0);
- TNode *N09 = new TNode(9, 7.0, 4.0, 0.0);
- TNode *N10 = new TNode(10, 7.0, 6.0, 0.0);
- TNode *N11 = new TNode(11, 3.0, 6.0, 0.0);
- TNode *N12 = new TNode(12, 4.0, 5.0, 0.0);
+ {
+ printf ("Test Triangulierung 12 Knoten: ");
- NL->push_back(N04);
- NL->push_back(N05);
- NL->push_back(N06);
- NL->push_back(N07);
- NL->push_back(N08);
- NL->push_back(N09);
- NL->push_back(N10);
- NL->push_back(N11);
- NL->push_back(N12);
+ TNode *N01 = new TNode(1, 1.0, 1.0, 0.0);
+ TNode *N02 = new TNode(2, 9.0, 1.0, 0.0);
+ TNode *N03 = new TNode(3, 9.0, 9.0, 0.0);
+ TNode *N04 = new TNode(4, 1.0, 9.0, 0.0);
+ TNode *N05 = new TNode(5, 4.0, 9.0, 0.0);
+ TNode *N06 = new TNode(6, 7.0, 9.0, 0.0);
+ TNode *N07 = new TNode(7, 7.0, 7.0, 0.0);
+ TNode *N08 = new TNode(8, 3.0, 4.0, 0.0);
+ TNode *N09 = new TNode(9, 7.0, 4.0, 0.0);
+ TNode *N10 = new TNode(10, 7.0, 6.0, 0.0);
+ TNode *N11 = new TNode(11, 3.0, 6.0, 0.0);
+ TNode *N12 = new TNode(12, 4.0, 5.0, 0.0);
- EL->Clear();
+ TNodeList *NodeList = new TNodeList();
- Triangulate(NL, EL, true);
+ NodeList->push_back(N01);
+ NodeList->push_back(N02);
+ NodeList->push_back(N03);
+ NodeList->push_back(N04);
+ NodeList->push_back(N05);
+ NodeList->push_back(N06);
+ NodeList->push_back(N07);
+ NodeList->push_back(N08);
+ NodeList->push_back(N09);
+ NodeList->push_back(N10);
+ NodeList->push_back(N11);
+ NodeList->push_back(N12);
- printf("Anzahl Elemente in Elementliste: %d\n", EL->size());
- for (unsigned int j=0; j<EL->size(); j++)
- {
- TElement *Element = (*EL)[j];
+ TElementList *ElementList = new TElementList();
- printf("Knoten die das Element %d bilden:", j);
- if (Element->Typ == TRI)
- {
- TNode *Node1 = Element->Node1;
- TNode *Node2 = Element->Node2;
- TNode *Node3 = Element->Node3;
- printf(" %d %d %d\n", Node1->Nr, Node2->Nr, Node3->Nr);
- }
- 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);
- }
+ Triangulate(NodeList, ElementList, 8);
+
+ if (ElementList->size() != 16) printf("Failed\n");
+ else printf("Pass\n");
+
+ delete ElementList;
+ delete NodeList;
}
- SaveNet("test_tri.2dm", NL, EL, 9);
+ {
+ printf ("Test Triangulierung 156249 Knoten: ");
+ TNodeList *NodeList = new TNodeList();
+ TElementList *ElementList = new TElementList();
- delete EL;
- delete NL;
+ LoadDGM(DGMFILE, NodeList, ElementList, 0, 200000, 1);
+
+ Triangulate(NodeList, ElementList, 1);
+
+ if (ElementList->size() != 310248) printf("Failed\n");
+ else printf("Pass\n");
+
+// SaveNet("debug_output\\test_tri.2dm", NodeList, ElementList, 8);
+
+ delete ElementList;
+ delete NodeList;
+ }
+
+ printf ("*************************************************************************\n");
}
Modified: trunk/src/test_xy.cpp
===================================================================
--- trunk/src/test_xy.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/test_xy.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -14,9 +14,10 @@
#pragma hdrstop
#endif
-//---------------------------------------------------------------------------
+//---------------------------------------------------------------------
#include <stdio.h>
#include "tools.h"
+#include "file.h"
#include "xy.h"
@@ -27,56 +28,107 @@
// Test der Punktverwaltung
////////////////////////////////////////
- printf ("\nTest Punktverwaltung\n");
+ printf ("*************************************************************************\n");
+ printf ("Test Punktverwaltung\n");
- // Zuerst ein paar Punkte generieren
- TXY *P11 = new TXY(1.0, 1.0);
- TXY *P12 = new TXY(9.0, 1.0);
- TXY *P13 = new TXY(9.0, 9.0);
- TXY *P14 = new TXY(1.0, 9.0);
- TXY *P15 = new TXY(4.0, 9.0);
- TXY *P16 = new TXY(7.0, 9.0);
- TXY *P17 = new TXY(7.0, 7.0);
+ ////////////////////////////////////////
+ // Zuerst TXY
+ ////////////////////////////////////////
- TXY *P21 = new TXY(3.0, 4.0);
- TXY *P22 = new TXY(7.0, 4.0);
- TXY *P23 = new TXY(7.0, 6.0);
- TXY *P24 = new TXY(3.0, 6.0);
- TXY *P25 = new TXY(4.0, 5.0);
+ {
+ printf ("Test XY-Punkte: ");
- // Jetzt zwei leere PolyliniePolygone generieren
- TXYList *PL1 = new TXYList();
- TXYList *PL2 = new TXYList();
+ TXY *P11 = new TXY(1.0, 1.0);
+ TXY *P12 = new TXY(9.0, 1.0);
+ TXY *P13 = new TXY(9.0, 9.0);
+ TXY *P14 = new TXY(1.0, 9.0);
+ TXY *P15 = new TXY(4.0, 9.0);
+ TXY *P16 = new TXY(7.0, 9.0);
+ TXY *P17 = new TXY(7.0, 7.0);
+ // XSumme = 38, YSumme = 45
- // Ein paar Punkte zur ersten Polylinie zuweisen
- PL1->push_back(P11);
- PL1->push_back(P12);
- PL1->push_back(P13);
- PL1->push_back(P14);
- PL1->push_back(P15);
- PL1->push_back(P16);
- PL1->push_back(P17);
+ // XSumme = 24, YSumme = 25
+ TXY *P21 = new TXY(3.0, 4.0);
+ TXY *P22 = new TXY(7.0, 4.0);
+ TXY *P23 = new TXY(7.0, 6.0);
+ TXY *P24 = new TXY(3.0, 6.0);
+ TXY *P25 = new TXY(4.0, 5.0);
+ // XSumme = 62, YSumme = 70
- // Ein paar Punkte zur zweiten Polylinie zuweisen
- PL2->push_back(P21);
- PL2->push_back(P22);
- PL2->push_back(P23);
- PL2->push_back(P24);
- PL2->push_back(P25);
+ // XSumme = 3, YSumme = 4
+ TXY *P31 = new TXY(P21);
- // die zweite Polylinie verdoppeln
- // Dabei werden alle Punkte mit verdoppelt
- TXYList *PL3 = PL2->Copy();
+ // Jetzt zwei leere Polylinie/Polygone generieren
+ TXYList *PL1 = new TXYList();
+ TXYList *PL2 = new TXYList();
- printf("Anzahl Punktepaare im Polygon: %d\n", PL3->size());
+ // Ein paar Punkte zur ersten Polylinie zuweisen
+ PL1->push_back(P11);
+ PL1->push_back(P12);
+ PL1->push_back(P13);
+ PL1->push_back(P14);
+ PL1->push_back(P15);
+ PL1->push_back(P16);
+ PL1->push_back(P17);
- for (unsigned int j=0; j<PL3->size(); j++)
- {
- TXY *XY = (*PL3)[j];
+ // Ein paar Punkte zur zweiten Polylinie zuweisen
+ PL2->push_back(P21);
+ PL2->push_back(P22);
+ PL2->push_back(P23);
+ PL2->push_back(P24);
+ PL2->push_back(P25);
- printf("Koordinaten von Punkt %d: %.3f,%.3f\n", j, XY->X, XY->Y);
+ // Die zweite Polylinie verdoppeln
+ // Dabei werden alle Punkte mit verdoppelt
+ // XSumme = 24, YSumme = 25
+ TXYList *PL3 = PL2->Copy();
+ // XSumme = 86, YSumme = 95
+
+ // Und noch ein Punkt dazu
+ // XSumme = 3, YSumme = 4
+ PL3->push_back(P31);
+ // XSumme = 89, YSumme = 99
+
+ int XSumme = 0;
+ int YSumme = 0;
+
+ for (TXYList::iterator i = PL1->begin(); i != PL1->end(); i++)
+ {
+ TXY* Xy = *i;
+
+ XSumme = XSumme + (int)Xy->X;
+ YSumme = YSumme + (int)Xy->Y;
+ }
+
+ for (TXYList::iterator i = PL2->begin(); i != PL2->end(); i++)
+ {
+ TXY* Xy = *i;
+
+ XSumme = XSumme + (int)Xy->X;
+ YSumme = YSumme + (int)Xy->Y;
+ }
+
+ for (TXYList::iterator i = PL3->begin(); i != PL3->end(); i++)
+ {
+ TXY* Xy = *i;
+
+ XSumme = XSumme + (int)Xy->X;
+ YSumme = YSumme + (int)Xy->Y;
+ }
+
+ if (PL1->size() != 7 || PL2->size() != 5 || PL3->size() != 6) printf("Failed\n");
+ else if (XSumme != 89 || YSumme != 99) printf("Failed\n");
+ else printf("Pass\n");
}
+
+/*
+ ////////////////////////////////////////
+ // XErgebnisPolygone
+ ////////////////////////////////////////
+
+ printf ("Test XY-Punkt-Liste: ");
+
// Jetzt zwei leere PolyliniePolygone generieren
TErgebnisPolygon *EP1 = new TErgebnisPolygon(0.0);
TErgebnisPolygon *EP2 = new TErgebnisPolygon(0.0);
@@ -247,193 +299,10 @@
EPL2 = 0;
- /////////////////////////////////////////////
- // Jetzt der 3D Teil
- /////////////////////////////////////////////
-
- printf("\nXYZ wird getestet\n\n");
-
- // Zuerst ein paar Punkte generieren
- TXYZ *Pz11 = new TXYZ(1.0, 1.0, 1.0);
- TXYZ *Pz12 = new TXYZ(9.0, 1.0, 2.0);
- TXYZ *Pz13 = new TXYZ(9.0, 9.0, 3.0);
- TXYZ *Pz14 = new TXYZ(1.0, 9.0, 4.0);
- TXYZ *Pz15 = new TXYZ(1.0, 1.0, 5.0);
- TXYZ *Pz16 = new TXYZ(9.0, 1.0, 6.0);
- TXYZ *Pz17 = new TXYZ(9.0, 9.0, 7.0);
- TXYZ *Pz18 = new TXYZ(1.0, 9.0, 8.0);
- TXYZ *Pz19 = new TXYZ(1.0, 1.0, 9.0);
-
- TXYZ *Pz21 = new TXYZ(3.0, 4.0, 5.0);
- TXYZ *Pz22 = new TXYZ(7.0, 4.0, 6.0);
- TXYZ *Pz23 = new TXYZ(7.0, 6.0, 7.0);
- TXYZ *Pz24 = new TXYZ(3.0, 6.0, 8.0);
- TXYZ *Pz25 = new TXYZ(Pz14);
-
- // Jetzt zwei leer PolyliniePolygone generieren
- TXYZList *PLz1 = new TXYZList();
- TXYZList *PLz2 = new TXYZList();
-
- // Ein paar Punkte zur ersten Polylinie zuweisen
- PLz1->push_back(Pz11);
- PLz1->push_back(Pz12);
- PLz1->push_back(Pz13);
- PLz1->push_back(Pz14);
- PLz1->push_back(Pz15);
- PLz1->push_back(Pz16);
- PLz1->push_back(Pz17);
- PLz1->push_back(Pz18);
- PLz1->push_back(Pz19);
-
- // Ein paar Punkte zur zweiten Polylinie zuweisen
- PLz2->push_back(Pz21);
- PLz2->push_back(Pz22);
- PLz2->push_back(Pz23);
- PLz2->push_back(Pz24);
- PLz2->push_back(Pz25);
-
- // die zweite Polylinie verdoppeln
- // Dabei werden alle Punkte mit verdoppelt
- TXYZList *PLz3 = PLz2->Copy();
-
- // Alles ausgeben
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", PLz1->size());
- for (unsigned int j=0; j<PLz1->size(); j++)
- {
- TXYZ *XYZ = (*PLz1)[j];
- printf("Koordinaten von Punkt %d: %.3f,%.3f,%.3f\nXYKombi: %s\n", j, XYZ->X, XYZ->Y, XYZ->Z, UnsignedInt64ToDez(XYZ->XYKombi).c_str());
- }
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", PLz2->size());
- for (unsigned int j=0; j<PLz2->size(); j++)
- {
- TXYZ *XYZ = (*PLz2)[j];
- printf("Koordinaten von Punkt %d: %.3f,%.3f,%.3f\nXYKombi: %s\n", j, XYZ->X, XYZ->Y, XYZ->Z, UnsignedInt64ToDez(XYZ->XYKombi).c_str());
- }
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", PLz3->size());
- for (unsigned int j=0; j<PLz3->size(); j++)
- {
- TXYZ *XYZ = (*PLz3)[j];
- printf("Koordinaten von Punkt %d: %.3f,%.3f,%.3f\nXYKombi: %s\n", j, XYZ->X, XYZ->Y, XYZ->Z, UnsignedInt64ToDez(XYZ->XYKombi).c_str());
- }
-
- printf("\nXYZ sortieren wird getestet\n\n");
-
- PLz1->SortByXY();
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", PLz1->size());
-
- for (unsigned int j=0; j<PLz1->size(); j++)
- {
- TXYZ *XYZ = (*PLz1)[j];
-
- printf("Koordinaten von Punkt %d: %.3f,%.3f,%.3f\nXYKombi: %s\n", j, XYZ->X, XYZ->Y, XYZ->Z, UnsignedInt64ToDez(XYZ->XYKombi).c_str());
- }
-
- printf("\nXYZ Suchen wird getestet\n\n");
-
- TXYZ *XYZS = (*PLz1)[3];
- TXYZ *XYZF = PLz1->FindByXY(XYZS->X, XYZS->Y);
- if (XYZF == 0) printf("Punkt %d: %.3f,%.3f,%.3f nicht gefunden\n", 3, XYZS->X, XYZS->Y, XYZS->Z);
- else printf("Punkt %d: %.3f,%.3f,%.3f gefunden\n", 3, XYZF->X, XYZF->Y, XYZF->Z);
-
- XYZS = (*PLz1)[0];
- XYZF = PLz1->FindByXY(XYZS->X, XYZS->Y);
- if (XYZF == 0) printf("Punkt %d: %.3f,%.3f,%.3f nicht gefunden\n", 0, XYZS->X, XYZS->Y, XYZS->Z);
- else printf("Punkt %d: %.3f,%.3f,%.3f gefunden\n", 0, XYZF->X, XYZF->Y, XYZF->Z);
-
- XYZS = new TXYZ(9.0, 9.0, 1.0);
- XYZF = PLz1->FindByXY(XYZS->X, XYZS->Y);
- if (XYZF == 0) printf("Punkt mit den Koordinaten %.3f,%.3f,%.3f nicht gefunden\n", XYZS->X, XYZS->Y, XYZS->Z);
- else printf("Punkt mit den Koordinaten %.3f,%.3f,%.3f gefunden\n", XYZF->X, XYZF->Y, XYZF->Z);
- delete XYZS;
-
- XYZS = new TXYZ(4.0, 7.0);
- XYZF = PLz1->FindByXY(XYZS->X, XYZS->Y);
- if (XYZF == 0) printf("Punkt mit den Koordinaten %.3f,%.3f,%.3f nicht gefunden\n", XYZS->X, XYZS->Y, XYZS->Z);
- else printf("Punkt mit den Koordinaten %.3f,%.3f,%.3f gefunden\n", XYZF->X, XYZF->Y, XYZF->Z);
- delete XYZS;
-
-
- delete PLz1;
- delete PLz2;
- delete PLz3;
-
-
-
- /////////////////////////////////////////////
+/////////////////////////////////////////////
// Jetzt der Node Teil
/////////////////////////////////////////////
- printf("\nKnoten werden getestet\n\n");
-
- // Zuerst ein paar Punkte generieren
- TNode *N11 = new TNode(1, 1.0, 1.0, 1.0);
- TNode *N12 = new TNode(2, 9.0, 1.0, 2.0);
- TNode *N13 = new TNode(3, 9.0, 9.0, 3.0);
- TNode *N14 = new TNode(4, 1.0, 9.0, 4.0);
- TNode *N15 = new TNode(5, 1.0, 1.0, 5.0);
- TNode *N16 = new TNode(6, 9.0, 1.0, 6.0);
- TNode *N17 = new TNode(7, 9.0, 9.0, 7.0);
- TNode *N18 = new TNode(8, 1.0, 9.0, 8.0);
- TNode *N19 = new TNode(9, 1.0, 1.0, 9.0);
-
- TNode *N21 = new TNode(1, 3.0, 4.0, 5.0);
- TNode *N22 = new TNode(2, 7.0, 4.0, 6.0);
- TNode *N23 = new TNode(3, 7.0, 6.0, 7.0);
- TNode *N24 = new TNode(4, 3.0, 6.0, 8.0);
- TNode *N25 = new TNode(N15);
-
- // Jetzt zwei leer PolyliniePolygone generieren
- TNodeList *NL1 = new TNodeList();
- TNodeList *NL2 = new TNodeList();
-
- // Ein paar Punkte zur ersten Polylinie zuweisen
- NL1->push_back(N11);
- NL1->push_back(N12);
- NL1->push_back(N13);
- NL1->push_back(N14);
- NL1->push_back(N15);
- NL1->push_back(N16);
- NL1->push_back(N17);
- NL1->push_back(N18);
- NL1->push_back(N19);
- // Ein paar Punkte zur zweiten Polylinie zuweisen
- NL2->push_back(N21);
- NL2->push_back(N22);
- NL2->push_back(N23);
- NL2->push_back(N24);
- NL2->push_back(N25);
-
- // die zweite Polylinie verdoppeln
- // Dabei werden alle Punkte mit verdoppelt
- TNodeList *NL3 = NL2->Copy();
-
- // Alles ausgeben
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", NL1->size());
- for (unsigned int j=0; j<NL1->size(); j++)
- {
- TNode *Node = (*NL1)[j];
- printf("Koordinaten von Knoten %d: %d, %.3f,%.3f,%.3f\nXYKombi: %s\n", j, Node->Nr, Node->X, Node->Y, Node->Z, UnsignedInt64ToDez(Node->XYKombi).c_str());
- }
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", NL2->size());
- for (unsigned int j=0; j<NL2->size(); j++)
- {
- TNode *Node = (*NL2)[j];
- printf("Koordinaten von Knoten %d: %d, %.3f,%.3f,%.3f\nXYKombi: %s\n", j, Node->Nr, Node->X, Node->Y, Node->Z, UnsignedInt64ToDez(Node->XYKombi).c_str());
- }
-
- printf("Anzahl Punktepaare in 3D-PunkteListe: %d\n", NL3->size());
- for (unsigned int j=0; j<NL3->size(); j++)
- {
- TNode *Node = (*NL3)[j];
- printf("Koordinaten von Knoten %d: %d, %.3f,%.3f,%.3f\nXYKombi: %s\n", j, Node->Nr, Node->X, Node->Y, Node->Z, UnsignedInt64ToDez(Node->XYKombi).c_str());
- }
-
printf("\nNode nach XY sortieren wird getestet\n\n");
NL1->SortByXY();
@@ -632,6 +501,9 @@
delete NL1;
delete NL2;
delete NL3;
+*/
+
+ printf ("*************************************************************************\n");
}
Modified: trunk/src/tools.cpp
===================================================================
--- trunk/src/tools.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/tools.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -35,7 +35,7 @@
//---------------------------------------------------------------------------
void dump_error(char *file, int line, char *format, ...)
{
- fprintf(fhsta, "->Kritischer Fehler (9298)\n");
+ fprintf(fhsta, "Kritischer Fehler\n");
char *p = file;
@@ -55,15 +55,13 @@
vfprintf(fhsta, format, argptr);
va_end(argptr);
- fprintf(fhsta, "Kritischer Fehler (9298)\n");
+ fprintf(fhsta, "Kritischer Fehler\n");
fflush(fhsta);
- // Hier sollte das Programm eigentlich nie hinkommen,
- // deshalb wird hier auch kein 'sinnvoller' Rückgabewert definiert
- ReturnCode = 9298;
+ ReturnCode = 3;
- throw TFehler("Problem");
+ throw TFehler("Problem");
}
//---------------------------------------------------------------------------
@@ -73,7 +71,7 @@
//---------------------------------------------------------------------------
void write_error(int ErrorNr, char *format, ...)
{
- fprintf(fhsta, "->Fehler (%d)\n", ErrorNr);
+ fprintf(fhsta, "Fehler (%d)\n", ErrorNr);
va_list argptr;
@@ -81,9 +79,7 @@
vfprintf(fhsta, format, argptr);
va_end(argptr);
- // Fehler sind wichtiger als Warningen,
- // deshalb wird der Wert hier immer überschrieben
- ReturnCode = ErrorNr;
+ ReturnCode = 2;
fprintf(fhsta, "Fehler (%d)\n", ErrorNr);
@@ -100,7 +96,7 @@
//---------------------------------------------------------------------------
void write_warning(int WarningNr, char *format, ...)
{
- fprintf(fhsta, "->Warnung (%d)\n", WarningNr);
+ fprintf(fhsta, "Warnung (%d)\n", WarningNr);
va_list argptr;
@@ -108,9 +104,7 @@
vfprintf(fhsta, format, argptr);
va_end(argptr);
- // Es wird immer die Nummer der ersten Warnung zurückgegeben.
- // Ausser es kommt noch eine Fehler. Der hat Vorrang !
- if (ReturnCode == 0) ReturnCode = WarningNr;
+ ReturnCode = 1;
fprintf(fhsta, "Warnung (%d)\n", WarningNr);
@@ -244,47 +238,47 @@
else return(realloc(pMem, nNewSize));
}
//---------------------------------------------------------------------------
-void Swap2Bytes(byte *Bytes)
+void Swap2Bytes(void *Bytes)
{
byte Temp;
- Temp = Bytes[0];
- Bytes[0] = Bytes[1];
- Bytes[1] = Temp;
+ Temp = ((byte*)Bytes)[0];
+ ((byte*)Bytes)[0] = ((byte*)Bytes)[1];
+ ((byte*)Bytes)[1] = Temp;
}
//---------------------------------------------------------------------------
-void Swap4Bytes(byte *Bytes)
+void Swap4Bytes(void *Bytes)
{
byte Temp;
- Temp = Bytes[0];
- Bytes[0] = Bytes[3];
- Bytes[3] = Temp;
+ Temp = ((byte*)Bytes)[0];
+ ((byte*)Bytes)[0] = ((byte*)Bytes)[3];
+ ((byte*)Bytes)[3] = Temp;
- Temp = Bytes[1];
- Bytes[1] = Bytes[2];
- Bytes[2] = Temp;
+ Temp = ((byte*)Bytes)[1];
+ ((byte*)Bytes)[1] = ((byte*)Bytes)[2];
+ ((byte*)Bytes)[2] = Temp;
}
//---------------------------------------------------------------------------
-void Swap8Bytes(byte *Bytes)
+void Swap8Bytes(void *Bytes)
{
byte Temp;
- Temp = Bytes[0];
- Bytes[0] = Bytes[7];
- Bytes[7] = Temp;
+ Temp = ((byte*)Bytes)[0];
+ ((byte*)Bytes)[0] = ((byte*)Bytes)[7];
+ ((byte*)Bytes)[7] = Temp;
- Temp = Bytes[1];
- Bytes[1] = Bytes[6];
- Bytes[6] = Temp;
+ Temp = ((byte*)Bytes)[1];
+ ((byte*)Bytes)[1] = ((byte*)Bytes)[6];
+ ((byte*)Bytes)[6] = Temp;
- Temp = Bytes[2];
- Bytes[2] = Bytes[5];
- Bytes[5] = Temp;
+ Temp = ((byte*)Bytes)[2];
+ ((byte*)Bytes)[2] = ((byte*)Bytes)[5];
+ ((byte*)Bytes)[5] = Temp;
- Temp = Bytes[3];
- Bytes[3] = Bytes[4];
- Bytes[4] = Temp;
+ Temp = ((byte*)Bytes)[3];
+ ((byte*)Bytes)[3] = ((byte*)Bytes)[4];
+ ((byte*)Bytes)[4] = Temp;
}
//---------------------------------------------------------------------------
@@ -337,37 +331,37 @@
}
//---------------------------------------------------------------------------
-double CrossProduct(TNode *n1, TNode *n2, TNode *n3)
+long double CrossProduct(TNode *n1, TNode *n2, TNode *n3)
{
- double Dx1 = n2->X - n1->X;
- double Dy1 = n2->Y - n1->Y;
- double Dx2 = n3->X - n1->X;
- double Dy2 = n3->Y - n1->Y;
+ long double Dx1 = n2->X - n1->X;
+ long double Dy1 = n2->Y - n1->Y;
+ long double Dx2 = n3->X - n1->X;
+ long double Dy2 = n3->Y - n1->Y;
return (Dx1 * Dy2 - Dy1 * Dx2);
}
//---------------------------------------------------------------------------
-bool CircumCircle(TNode *n1, TNode *n2, TNode *n3, double *cx, double *cy, double *cr)
+bool CircumCircle(TNode *n1, TNode *n2, TNode *n3, double *CX, double *CY, double *CR)
{
- double cp = CrossProduct(n1, n2, n3);
+ long double cp = CrossProduct(n1, n2, n3);
if (cp != 0.0)
{
- double n1Sq = n1->X * n1->X + n1->Y * n1->Y;
- double n2Sq = n2->X * n2->X + n2->Y * n2->Y;
- double n3Sq = n3->X * n3->X + n3->Y * n3->Y;
- double numx = n1Sq * (n2->Y - n3->Y) + n2Sq * (n3->Y - n1->Y) + n3Sq * (n1->Y - n2->Y);
- double x = numx / (2.0 * cp);
- double numy = n1Sq * (n3->X - n2->X) + n2Sq * (n1->X - n3->X) + n3Sq * (n2->X - n1->X);
- double y = numy / (2.0 * cp);
+ long double n1Sq = n1->X * n1->X + n1->Y * n1->Y;
+ long double n2Sq = n2->X * n2->X + n2->Y * n2->Y;
+ long double n3Sq = n3->X * n3->X + n3->Y * n3->Y;
+ long double numx = n1Sq * (n2->Y - n3->Y) + n2Sq * (n3->Y - n1->Y) + n3Sq * (n1->Y - n2->Y);
+ long double x = numx / (2.0 * cp);
+ long double numy = n1Sq * (n3->X - n2->X) + n2Sq * (n1->X - n3->X) + n3Sq * (n2->X - n1->X);
+ long double y = numy / (2.0 * cp);
- double dx = n3->X - x;
- double dy = n3->Y - y;
+ long double dx = n3->X - x;
+ long double dy = n3->Y - y;
- *cx = x;
- *cy = y;
- *cr = dx * dx + dy * dy;
+ *CX = x;
+ *CY = y;
+ *CR = dx * dx + dy * dy;
return(true);
}
@@ -522,16 +516,11 @@
//---------------------------------------------------------------------------
void InterpolateWsp(TProfilList *ProfilList, TProfilList *WspProfilList, int DebugLevel)
{
- write_fortschritt ("->Wasserstände werden interpoliert\n");
+ write_fortschritt ("->Interpolieren der Wasserstände gestartet\n");
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 Profile bearbeitet\n", Count);
- }
-
TProfil *Profil = *i;
TProfil *UnderProfil = *WspProfilList->begin();
@@ -552,33 +541,39 @@
if (UnderProfil->Station == Profil->Station)
{
Profil->Wsp = UnderProfil->Wsp;
- if (DebugLevel >= 2) 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("Bei 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 (DebugLevel >= 2) 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("Bei 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 (DebugLevel >= 2) 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("Bei 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);
+ write_error(2203, "Bei Profil %.4f konnte kein Wasserstand interpoliert werden\n", Profil->Station / 10000.0);
}
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10 == 0) || (Count > 0 && Count % 100 == 0))
+ {
+ write_fortschritt ("%d Profile bearbeitet\n", Count);
+ }
}
write_fortschritt ("%d Profile bearbeitet\n", Count);
- write_fortschritt ("Wasserstände wurden interpoliert\n");
+
+ write_fortschritt ("<-Interpolieren der Wasserstände beendet\n");
}
//---------------------------------------------------------------------------
TProfilMap BuildGewaesserListen(TProfilList *ProfilList, int DebugLevel)
{
- write_fortschritt ("->Gewässerlisten werden erzeugt\n");
+ write_fortschritt ("->Erzeugung der Gewässerlisten gestartet\n");
TProfilMap ProfilMap;
@@ -620,7 +615,7 @@
}
}
- write_fortschritt ("Gewässerlisten wurden erzeugt\n");
+ write_fortschritt ("<-Erzeugung der Gewässerlisten beendet\n");
return (ProfilMap);
}
@@ -628,7 +623,7 @@
//---------------------------------------------------------------------------
void BuildPolygon(TProfilList *ProfilList, TXYList *XyList, int DebugLevel)
{
- write_fortschritt ("->Begrenzungspolygon wird erzeugt\n");
+ write_fortschritt ("->Erzeugung des Begrenzungspolygons gestartet\n");
if (ProfilList->size() < 2)
{
@@ -641,11 +636,6 @@
TProfilList::iterator ProfilIter = ProfilList->begin();
for (unsigned int i = 0; i < ProfilList->size()-1; i++)
{
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
- {
- write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
- }
-
TProfil* Profil = *ProfilIter;
if (i == 0)
@@ -662,17 +652,18 @@
XyList->Add(Point->X, Point->Y);
}
ProfilIter++;
+
Count++;
- }
- TProfilList::reverse_iterator RProfilIter = ProfilList->rbegin();
- for (unsigned int i = ProfilList->size()-1; i > 0; i--)
- {
if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
{
write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
}
+ }
+ TProfilList::reverse_iterator RProfilIter = ProfilList->rbegin();
+ for (unsigned int i = ProfilList->size()-1; i > 0; i--)
+ {
TProfil* Profil = *RProfilIter;
if (i == ProfilList->size()-1)
@@ -689,11 +680,17 @@
XyList->Add(Point->X, Point->Y);
}
RProfilIter++;
+
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
+ }
}
write_fortschritt("%d Begrenzungspunkte erzeugt\n", XyList->size());
- if (DebugLevel >= 8)
+ if (DebugLevel >= 9)
{
write_fortschritt("Polygon:\n");
for (TXYList::iterator j = XyList->begin(); j != XyList->end(); j++)
@@ -703,7 +700,7 @@
}
}
- write_fortschritt ("Begrenzungspolygon wurde erzeugt\n");
+ write_fortschritt ("<-Erzeugung des Begrenzungspolygons beendet\n");
}
//---------------------------------------------------------------------------
@@ -711,6 +708,7 @@
{
write_fortschritt ("->Suche nach doppelten Knoten gestartet\n");
+ int SollKnotenGeloescht = 0;
int KnotenGeloescht = 0;
int ElementeGeloescht = 0;
@@ -728,13 +726,6 @@
int Count = 0;
for (TElementList::iterator i = ElementList->begin(); i != ElementList->end(); i++)
{
- Count++;
-
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
- {
- write_fortschritt("%d von %d Elementen durchsucht, %d Knoten und %d Elemente gelöscht\n", Count, ElementList->size(), KnotenGeloescht, ElementeGeloescht);
- }
-
TElement *Element = *i;
TNode *Node1 = Element->Node1;
@@ -746,7 +737,7 @@
{
if (Node1->Nr != Node2->Nr)
{
- if (DebugLevel >= 3)
+ if (DebugLevel >= 9)
{
write_fortschritt("Lösche Knoten %d (%.3f, %.3f) ident mit Knoten %d (%.3f, %.3f)\n", Node2->Nr, Node2->X, Node2->Y, Node1->Nr, Node1->X, Node1->Y);
}
@@ -756,10 +747,14 @@
TElement *Element2 = *k;
if (Element2->Node1 == Node2) Element2->Node1 = Node1;
- if (Element2->Node2 == Node2) Element2->Node2 = Node1;
- if (Element2->Node3 == Node2) Element2->Node3 = Node1;
- }
- Node2->Nr = 0;
+ if (Element2->Node2 == Node2) Element2->Node2 = Node1;
+ if (Element2->Node3 == Node2) Element2->Node3 = Node1;
+ }
+ if (Node2->Nr > 0)
+ {
+ Node2->Nr = 0;
+ SollKnotenGeloescht++;
+ }
}
}
}
@@ -767,15 +762,15 @@
Node1 = Element->Node2;
if (Node1->Nr != 0)
{
- TNode *Node2 = NodeList->FindByXY(Node1->X, Node1->Y, 0.01);
+ TNode *Node2 = NodeList->FindByXY(Node1->X, Node1->Y, 0.01);
if (Node2->Nr != 0)
{
if (Node1->Nr != Node2->Nr)
{
- if (DebugLevel >= 3)
+ if (DebugLevel >= 9)
{
- write_fortschritt("Lösche Knoten %d (%.2f, %.2f)\nEr ist ident mit Knoten %d (%.2f, %.2f)\n", Node2->Nr, Node2->X, Node2->Y, Node1->Nr, Node1->X, Node1->Y);
+ write_fortschritt("Lösche Knoten %d (%.2f, %.2f) ident mit Knoten %d (%.2f, %.2f)\n", Node2->Nr, Node2->X, Node2->Y, Node1->Nr, Node1->X, Node1->Y);
}
for (TElementList::iterator k = ElementList->begin(); k != ElementList->end(); k++)
{
@@ -785,7 +780,11 @@
if (Element2->Node2 == Node2) Element2->Node2 = Node1;
if (Element2->Node3 == Node2) Element2->Node3 = Node1;
}
- Node2->Nr = 0;
+ if (Node2->Nr > 0)
+ {
+ Node2->Nr = 0;
+ KnotenGeloescht++;
+ }
}
}
}
@@ -799,9 +798,9 @@
{
if (Node1->Nr != Node2->Nr)
{
- if (DebugLevel >= 3)
+ if (DebugLevel >= 9)
{
- write_fortschritt("Lösche Knoten %d (%.2f, %.2f)\nEr ist ident mit Knoten %d (%.2f, %.2f)\n", Node2->Nr, Node2->X, Node2->Y, Node1->Nr, Node1->X, Node1->Y);
+ write_fortschritt("Lösche Knoten %d (%.2f, %.2f) ident mit Knoten %d (%.2f, %.2f)\n", Node2->Nr, Node2->X, Node2->Y, Node1->Nr, Node1->X, Node1->Y);
}
for (TElementList::iterator k = ElementList->begin(); k != ElementList->end(); k++)
{
@@ -811,55 +810,70 @@
if (Element2->Node2 == Node2) Element2->Node2 = Node1;
if (Element2->Node3 == Node2) Element2->Node3 = Node1;
}
- Node2->Nr = 0;
+ if (Node2->Nr > 0)
+ {
+ Node2->Nr = 0;
+ KnotenGeloescht++;
+ }
}
}
}
- }
+ Count++;
- Count = 0;
- for (TNodeList::iterator i = NodeList->begin(); i != NodeList->end(); i++)
- {
- Count++;
if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
{
- write_fortschritt("%d von %d Knoten durchsucht, %d Knoten und %d Elemente gelöscht\n", Count, NodeList->size(), KnotenGeloescht, ElementeGeloescht);
+ write_fortschritt("%d von %d Elementen, %d/%d Knoten und %d Elemente gelöscht\n", Count, ElementList->size(), KnotenGeloescht, SollKnotenGeloescht, ElementeGeloescht);
}
+ }
- TNode *Node = *i;
+ if (SollKnotenGeloescht > 0)
+ {
+ Count = 0;
+ for (TNodeList::iterator i = NodeList->begin(); i != NodeList->end(); i++)
+ {
+ Count++;
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
+ {
+ write_fortschritt("%d von %d Elementen, %d/%d Knoten und %d Elemente gelöscht\n", Count, ElementList->size(), KnotenGeloescht, SollKnotenGeloescht, ElementeGeloescht);
+ }
- if (Node->Nr == 0)
- {
- NodeList->erase(i);
- KnotenGeloescht++;
- NetChanged = true;
+ TNode *Node = *i;
+
+ if (Node->Nr == 0)
+ {
+ NodeList->erase(i);
+ KnotenGeloescht++;
+ NetChanged = true;
+ }
}
}
} while (NetChanged);
- NetChanged = false;
- do
+ if (KnotenGeloescht > 0)
{
- NetChanged = false;
-
- for (TElementList::iterator i = ElementList->begin(); i != ElementList->end(); i++)
+ do
{
- TElement *Element = *i;
+ NetChanged = false;
- TNode *Node1 = Element->Node1;
- TNode *Node2 = Element->Node2;
- TNode *Node3 = Element->Node3;
+ for (TElementList::iterator i = ElementList->begin(); i != ElementList->end(); i++)
+ {
+ TElement *Element = *i;
- if (Node1 == Node2 || Node1 == Node3 || Node2 == Node3)
- {
- Element->Typ = NO_ELEMENT;
- ElementeGeloescht++;
- NetChanged = true;
- i = ElementList->begin();
- break;
+ TNode *Node1 = Element->Node1;
+ TNode *Node2 = Element->Node2;
+ TNode *Node3 = Element->Node3;
+
+ if (Node1 == Node2 || Node1 == Node3 || Node2 == Node3)
+ {
+ Element->Typ = NO_ELEMENT;
+ ElementeGeloescht++;
+ NetChanged = true;
+ i = ElementList->begin();
+ break;
+ }
}
- }
- } while (NetChanged);
+ } while (NetChanged);
+ }
}
else
{
@@ -871,12 +885,6 @@
int Count = 0;
for (TNodeList::iterator i = NodeList->begin(); i != NodeList->end(); i++)
{
- Count++;
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
- {
- write_fortschritt("%d von %d Knoten durchsucht, %d Knoten gelöscht\n", Count, ElementList->size(), KnotenGeloescht);
- }
-
TNode *Node1 = *i;
TNode *Node2 = NodeList->FindByXY(Node1->X, Node1->Y, 0.01);
@@ -885,6 +893,13 @@
NodeList->erase(i);
KnotenGeloescht++;
}
+
+ Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
+ {
+ write_fortschritt("%d von %d Knoten, %d Knoten gelöscht\n", Count, NodeList->size(), KnotenGeloescht);
+ }
}
}
@@ -894,10 +909,11 @@
}
//---------------------------------------------------------------------------
-void BuildEdgeList(TEdgeList* EdgeList, TElementList* ElementList, int DebugLevel)
+void BuildEdgeList(TNodeList* NodeList, TElementList* ElementList, TEdgeList* EdgeList, int DebugLevel)
{
- write_fortschritt ("->Kanten werden erzeugt\n");
+ write_fortschritt ("->Erzeugung der Kanten gestartet\n");
+ NodeList->ClearEdgeIndex();
EdgeList->Clear();
TEdge* NewEdge = 0;
@@ -906,11 +922,6 @@
int Count = 0;
for (TElementList::iterator i=ElementList->begin(); i!=ElementList->end(); i++)
{
- 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;
// Testen, ob das Element gesperrt wurde
@@ -920,11 +931,20 @@
TNode* N2 = Element->Node2;
TNode* N3 = Element->Node3;
- AntiEdge = EdgeList->Find(N2->Nr, N1->Nr);
+/*
+ for (TEdgeListNrSorted::iterator j=EdgeList->EdgeListNrSorted.begin(); j!=EdgeList->EdgeListNrSorted.end(); j++)
+ {
+ TEdge* Edge = *j;
+ write_fortschritt("%d - %d\n", Edge->Node1->Nr, Edge->Node2->Nr);
+ }
+ write_fortschritt("\n%d - %d - %d\n", N1->Nr, N2->Nr, N3->Nr);
+*/
+
+ AntiEdge = EdgeList->FindWithIndex(N2, N1);
if (AntiEdge == 0)
{
// Im moment gehe ich mal davon aus, dass es eine neue Randkante ist
- NewEdge = EdgeList->Add(N1, N2);
+ NewEdge = EdgeList->AddWithIndex(N1, N2);
NewEdge->IsBoundary = true;
}
else
@@ -938,17 +958,17 @@
else
{
// Die neue ist besser, aber keine Randkante
- EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(N1, N2);
+ EdgeList->EraseWithIndex(AntiEdge);
+ NewEdge = EdgeList->AddWithIndex(N1, N2);
NewEdge->IsBoundary = false;
}
}
- AntiEdge = EdgeList->Find(N3->Nr, N2->Nr);
+ AntiEdge = EdgeList->FindWithIndex(N3, N2);
if (AntiEdge == 0)
{
- // Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(N2, N3);
+ // Im moment gehe ich mal davon aus, dass es keine neue Randkante ist
+ NewEdge = EdgeList->AddWithIndex(N2, N3);
NewEdge->IsBoundary = true;
}
else
@@ -962,19 +982,19 @@
else
{
// Die neue ist besser, aber keine Randkante
- EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(N2, N3);
+ EdgeList->EraseWithIndex(AntiEdge);
+ NewEdge = EdgeList->AddWithIndex(N2, N3);
NewEdge->IsBoundary = false;
}
}
if (Element->Typ == TRI)
{
- AntiEdge = EdgeList->Find(N1->Nr, N3->Nr);
+ AntiEdge = EdgeList->FindWithIndex(N1, N3);
if (AntiEdge == 0)
{
- // Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(N3, N1);
+ // Im moment gehe ich mal davon aus, dass es eine neue Randkante ist
+ NewEdge = EdgeList->AddWithIndex(N3, N1);
NewEdge->IsBoundary = true;
}
else
@@ -988,8 +1008,8 @@
else
{
// Die neue ist besser, aber keine Randkante
- EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(N3, N1);
+ EdgeList->EraseWithIndex(AntiEdge);
+ NewEdge = EdgeList->AddWithIndex(N3, N1);
NewEdge->IsBoundary = false;
}
}
@@ -998,11 +1018,11 @@
{
TNode* N4 = Element->Node4;
- AntiEdge = EdgeList->Find(N4->Nr, N3->Nr);
+ AntiEdge = EdgeList->FindWithIndex(N4, N3);
if (AntiEdge == 0)
{
- // Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(N3, N4);
+ // Im moment gehe ich mal davon aus, dass es eine neue Randkante ist
+ NewEdge = EdgeList->AddWithIndex(N3, N4);
NewEdge->IsBoundary = true;
}
else
@@ -1016,17 +1036,17 @@
else
{
// Die neue ist besser, aber keine Randkante
- EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(N3, N4);
+ EdgeList->EraseWithIndex(AntiEdge);
+ NewEdge = EdgeList->AddWithIndex(N3, N4);
NewEdge->IsBoundary = false;
}
}
- AntiEdge = EdgeList->Find(N1->Nr, N4->Nr);
+ AntiEdge = EdgeList->FindWithIndex(N1, N4);
if (AntiEdge == 0)
{
- // Im moment gehe ich mal davon aus, dass es könnte eine neue Randkante ist
- NewEdge = EdgeList->Add(N4, N1);
+ // Im moment gehe ich mal davon aus, dass es eine neue Randkante ist
+ NewEdge = EdgeList->AddWithIndex(N4, N1);
NewEdge->IsBoundary = true;
}
else
@@ -1040,15 +1060,20 @@
else
{
// Die neue ist besser, aber keine Randkante
- EdgeList->Erase(AntiEdge);
- NewEdge = EdgeList->Add(N4, N1);
+ EdgeList->EraseWithIndex(AntiEdge);
+ NewEdge = EdgeList->AddWithIndex(N4, N1);
NewEdge->IsBoundary = false;
}
}
}
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 5000 == 0) || (Count > 0 && Count % 50000 == 0))
+ {
+ write_fortschritt("%d von %d Elementen, %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);
+ write_fortschritt("%d von %d Elementen, %d Kanten erzeugt\n", Count, ElementList->size(), EdgeList->Anz);
if (DebugLevel >= 8)
{
@@ -1081,13 +1106,13 @@
write_fortschritt("%d von %d Kanten getestet\n", Count, EdgeList->EdgeListNrSorted.size());
}
- write_fortschritt ("Kanten wurden erzeugt\n");
+ write_fortschritt ("<-Erzeugung der Kanten beendet\n");
}
//---------------------------------------------------------------------------
void BuildProfilNodeList(TProfilList *ProfilList, TNodeList *NodeList, TGewaesserAchseList *GewaesserAchseList, TProfilList *SperrenList, TNodeList *ProfilNodeList, double AvgDistance, bool Sperre, int DebugLevel)
{
- write_fortschritt ("->Knotenliste wird aus den Profilspuren generiert\n");
+ write_fortschritt ("->Generierung der Knotenliste aus den Profilspuren gestartet\n");
NodeList->SortByXY();
@@ -1097,11 +1122,6 @@
int Count = 0;
for (TProfilList::iterator i = ProfilList->begin(); i != ProfilList->end(); i++)
{
- 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;
std::string Gewaesser = Profil->Gewaesser;
@@ -1140,6 +1160,13 @@
double Lambda = 0.0;
double Meter = 0.0;
+ double PDx = NextPoint->X - Point->X;
+ double PDy = NextPoint->Y - Point->Y;
+ if (fabs(PDx) < 0.00000001 && fabs(PDy) < 0.00000001)
+ {
+ write_error(3207, "Profil-Punkteabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Point->X, Point->Y, NextPoint->X, NextPoint->Y);
+ }
+
bool Found = CalcProfilSchnitt(Point->X, Point->Y, NextPoint->X, NextPoint->Y, SperrenList, &X, &Y, &Lambda, &Meter);
if (Found)
@@ -1161,9 +1188,9 @@
if (false == Found)
{
// Dies bedeutet, die Profile ragen aus dem DGM raus oder die Punkte sind lokal sehr weit auseinander
- if (DebugLevel >= 6)
+ if (DebugLevel >= 9)
{
- write_warning(9999, "Es konnte für den Profilpunkt (%.2f, %.2f) keine Höhe interpoliert werden\n", X, Y);
+ write_warning(9999, "Für Profilpunkt (%.2f, %.2f) konnte keine Höhe interpoliert werden\n", X, Y);
}
continue;
}
@@ -1199,6 +1226,13 @@
double Lambda = 0.0;
double Meter = 0.0;
+ double PDx = NextPoint->X - Point->X;
+ double PDy = NextPoint->Y - Point->Y;
+ if (fabs(PDx) < 0.00000001 && fabs(PDy) < 0.00000001)
+ {
+ write_error(3207, "Profil-Punkteabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Point->X, Point->Y, NextPoint->X, NextPoint->Y);
+ }
+
bool Found = CalcProfilSchnitt(Point->X, Point->Y, NextPoint->X, NextPoint->Y, SperrenList, &X, &Y, &Lambda, &Meter);
if (Found)
@@ -1221,9 +1255,9 @@
{
// Dies bedeutet, die Profile ragen aus dem DGM raus oder die Punkte sind lokal sehr weit auseinander
- if (DebugLevel >= 6)
+ if (DebugLevel >= 9)
{
- write_warning(9999, "Es konnte für den Profilpunkt (%.2f, %.2f) keine Höhe interpoliert werden\n", X, Y);
+ write_warning(9999, "Für Profilpunkt (%.2f, %.2f) konnte keine Höhe interpoliert werden\n", X, Y);
}
continue;
}
@@ -1242,16 +1276,21 @@
}
}
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("%d von %d Profilen, %d Knoten erzeugt\n", Count, ProfilList->size(), NodeNr);
+ }
}
- write_fortschritt("%d von %d Profilen getestet, %d Knoten erzeugt\n", Count, ProfilList->size(), NodeNr);
+ write_fortschritt("%d von %d Profilen, %d Knoten erzeugt\n", Count, ProfilList->size(), NodeNr);
- write_fortschritt ("Knotenliste wurde aus den Profilspuren generiert\n");
+ write_fortschritt ("<-Generierung der Knotenliste aus den Profilspuren beendet\n");
}
//---------------------------------------------------------------------------
void TransferWsp(TNodeList *ProfilNodeList, TNodeList *NodeList, TProfilList* SperrenList, double AvgDistance, int DebugLevel)
{
- write_fortschritt ("->Wasserstände werden übertragen\n");
+ write_fortschritt ("->Übertragen der Wasserstände gestartet\n");
ProfilNodeList->SortByXY();
@@ -1285,56 +1324,107 @@
}
write_fortschritt("%d von %d Knoten getestet, %d Wasserstände übertragen\n", Count, NodeList->size(), WspCount);
- write_fortschritt ("Wasserstände wurden übertragen\n");
+ write_fortschritt ("<-Übertragen der Wasserstände beendet\n");
}
//---------------------------------------------------------------------------
-void GetWspFromNodeList(TProfilList* BruchList, TNodeList* NodeList, TProfilList* SperrenList, double AvgDistance, int DebugLevel)
+void TransferWsp(TProfilList *RohreList, TNodeList *NodeList, double AvgDistance, int DebugLevel)
{
- write_fortschritt ("->Wasserstände für Brüche werden ermittelt\n");
+ write_fortschritt ("->Übertragen der Wasserstände durch Rohre gestartet\n");
+ NodeList->SortByXY();
+
+ int WspCount = 0;
int Count = 0;
- for (TProfilList::iterator i = BruchList->begin(); i != BruchList->end(); i++)
+ for (TProfilList::iterator i = RohreList->begin(); i != RohreList->end(); i++)
{
- TProfil* Bruch = *i;
-
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 1000 == 0) || (Count > 0 && Count % 10000 == 0))
{
- write_fortschritt("Für Bruch %d von %d wird der Wasserstand ermittelt\n", Count, BruchList->size());
+ write_fortschritt("%d von %d Rohren getestet, %d Wasserstände übertragen\n", Count, RohreList->size(), WspCount);
}
- double MaxWsp = 0.0;
- int WspCount = 0;
- for (TPointList::iterator j = Bruch->PointList->begin(); j != Bruch->PointList->end(); j++)
+ TProfil* Rohr = *i;
+ TPoint* Point = *Rohr->PointList->rbegin();
+
+ double X = Point->X;
+ double Y = Point->Y;
+
+ TNodeList* FoundNodeList = NodeList->FindAllByXY(X, Y, AvgDistance);
+
+ TNode* NearestNode = 0;
+ for (TNodeList::iterator j = FoundNodeList->begin(); j != FoundNodeList->end(); j++)
{
- TPoint* Point = *j;
+ TNode* Node = *j;
- double X = Point->X;
- double Y = Point->Y;
+ if (NearestNode == 0)
+ {
+ NearestNode = Node;
+ continue;
+ }
- double ZDummy = 0.0;
- double Wsp = 0.0;
- bool Found = NodeList->Interpolate(SperrenList, X, Y, AvgDistance, &ZDummy, &Wsp);
+ double Dx = X - Node->X;
+ double Dy = Y - Node->Y;
- if (Found)
+ double NDx = X - NearestNode->X;
+ double NDy = Y - NearestNode->Y;
+
+ if (sqrt(Dx*Dx+Dy*Dy) < sqrt(NDx*NDx+NDy*NDy))
{
- if (WspCount == 0 || MaxWsp < Wsp)
- {
- MaxWsp = Wsp;
- if (DebugLevel >= 6) write_fortschritt("Bruch %d: bisher höchster Wasserstand (%.3f)\n", Count, MaxWsp);
- }
+ NearestNode = Node;
+ }
+ }
+
+ if (NearestNode)
+ {
+ if (NearestNode->Z < Rohr->Wsp)
+ {
+ NearestNode->Wsp = Rohr->Wsp;
WspCount++;
}
}
+ Count++;
+ }
+ write_fortschritt("%d von %d Rohren getestet, %d Wasserstände übertragen\n", Count, RohreList->size(), WspCount);
- if (WspCount > 0) Bruch->Wsp = MaxWsp;
- else Bruch->Wsp = -9999.9;
+ write_fortschritt ("<-Übertragen der Wasserstände durch Rohre beendet\n");
+}
+//---------------------------------------------------------------------------
+void GetWspFromNodeList(TNodeList* NodeList, TProfilList* RohreList, double AvgDistance, int DebugLevel)
+{
+ write_fortschritt ("->Wasserstände für Rohre werden ermittelt\n");
+
+ int Count = 0;
+ for (TProfilList::iterator i = RohreList->begin(); i != RohreList->end(); i++)
+ {
+ TProfil* Rohr = *i;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 100 == 0) || (Count > 0 && Count % 1000 == 0))
+ {
+ write_fortschritt("Rohr %d von %d\n", Count, RohreList->size());
+ }
+
+ TPoint* Point = *Rohr->PointList->begin();
+
+ double X = Point->X;
+ double Y = Point->Y;
+
+ double ZDummy = 0.0;
+ double Wsp = 0.0;
+ bool Found = NodeList->Interpolate(0, X, Y, AvgDistance, &ZDummy, &Wsp);
+
+ if (Found)
+ {
+ if (DebugLevel >= 6) write_fortschritt("Rohr %d hat Wasserstand %.3f\n", Count, Wsp);
+ }
+
+ Rohr->Wsp = Wsp;
+
Count++;
}
- write_fortschritt("Für Bruch %d von %d wird der Wasserstand ermittelt\n", Count, BruchList->size());
+ write_fortschritt("Rohr %d von %d\n", Count, RohreList->size());
- write_fortschritt ("->Wasserstände für Brüche wurden ermittelt\n");
+ write_fortschritt ("<-Wasserstände für Rohre werden beendet\n");
}
//---------------------------------------------------------------------------
@@ -1374,31 +1464,43 @@
//---------------------------------------------------------------------------
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)
{
- double PDx = P1x - P0x;
- double PDy = P1y - P0y;
+ *x = 0.0;
+ *y = 0.0;
+ *lambdap = -9999;
+ *lambdas = 9999;
- double SDx = S1x - S0x;
- double SDy = S1y - S0y;
+ if (P0x < S0x && P1x < S0x && P0x < S1x && P1x < S1x) return (false);
+ if (P0x > S0x && P1x > S0x && P0x > S1x && P1x > S1x) return (false);
+ if (P0y < S0y && P1y < S0y && P0y < S1y && P1y < S1y) return (false);
+ if (P0y > S0y && P1y > S0y && P0y > S1y && P1y > S1y) return (false);
- double LambdaP = 0.0;
- double LambdaS = 0.0;
+ long double PDx = P1x - P0x;
+ long double PDy = P1y - P0y;
+ long double SDx = S1x - S0x;
+ long double SDy = S1y - S0y;
+
+ long double LambdaP = 0.0;
+ long double LambdaS = 0.0;
+
if (fabs(PDx) < 0.00000001 && fabs(PDy) < 0.00000001)
{
- write_error(3207, "Profil-Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", P0x, P0y, P1x, P1y);
+ dump_error(__FILE__, __LINE__, "Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", P0x, P0y, P1x, P1y);
}
- else if (fabs(SDx) < 0.001 && fabs(SDy) < 0.001)
+ else if (fabs(SDx) < 0.00000001 && fabs(SDy) < 0.00000001)
{
- write_error(3208, "GewaesserAchse-Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", S0x, S0y, S1x, S1y);
+ dump_error(__FILE__, __LINE__, "Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", P0x, P0y, P1x, P1y);
}
else if (fabs(PDx) < 0.00000001 && fabs(SDx) < 0.00000001)
{
- // S-Segment und P->Abschnitt sind beide senkrecht (parallel)
+ // S-Strecke und P-Stecke sind beide senkrecht (parallel)
+ // Eigentlich müsse man hier noch auf identität testen
return (false);
}
else if (fabs(PDy) < 0.00000001 && fabs(SDy) < 0.00000001)
{
- // S-Segment und P->Abschnitt sind beide waagerecht (parallel)
+ // S-Strecke und P-Stecke sind beide waagerecht (parallel)
+ // Eigentlich müsse man hier noch auf identität testen
return (false);
}
else if (fabs(PDx) < 0.00000001)
@@ -1431,17 +1533,12 @@
LambdaP = (S0y + LambdaS * SDy - P0y) / PDy;
}
- double Px = P0x + LambdaP * PDx;
- double Py = P0y + LambdaP * PDy;
+ long double Px = P0x + LambdaP * PDx;
+ long double Py = P0y + LambdaP * PDy;
- double Sx = S0x + LambdaS * SDx;
- double Sy = S0y + LambdaS * SDy;
+ long double Sx = S0x + LambdaS * SDx;
+ long double Sy = S0y + LambdaS * SDy;
- if (fabs(Px-Sx) > 0.001 || fabs(Py-Sy) > 0.001)
- {
- dump_error (__FILE__, __LINE__, "Errechnete Punkte sind nicht identisch (%10.5f,%10.5f) und (%10.5f,%10.5f)\n", Px, Py, Sx, Sy);
- }
-
*x = Px;
*y = Py;
*lambdap = LambdaP;
@@ -1450,12 +1547,24 @@
if (LambdaP < 0.0 || LambdaP > 1.0) return (false);
if (LambdaS < 0.0 || LambdaS > 1.0) return (false);
+ if (fabs(Px-Sx) > 0.001 || fabs(Py-Sy) > 0.001)
+ {
+ dump_error (__FILE__, __LINE__, "Errechnete Punkte sind nicht identisch (%10.5f,%10.5f) und (%10.5f,%10.5f)\n", Px, Py, Sx, Sy);
+ }
+
return (true);
}
//---------------------------------------------------------------------
bool CalcProfilSchnitt (double P0x, double P0y, double P1x, double P1y, TProfilList *ProfilList, double *x, double *y, double *lambdap, double *meter)
{
+ double PDx = P1x - P0x;
+ double PDy = P1y - P0y;
+ if (fabs(PDx) < 0.00000001 && fabs(PDy) < 0.00000001)
+ {
+ dump_error(__FILE__, __LINE__, "Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", P0x, P0y, P1x, P1y);
+ }
+
for (TProfilList::iterator i = ProfilList->begin(); i != ProfilList->end(); i++)
{
TProfil* Profil = *i;
@@ -1481,6 +1590,13 @@
double S1x = S1->X;
double S1y = S1->Y;
+ double SDx = S1x - S0x;
+ double SDy = S1y - S0y;
+ if (fabs(SDx) < 0.00000001 && fabs(SDy) < 0.00000001)
+ {
+ write_error(3207, "Profil-Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", S0x, S0y, S1x, S1y);
+ }
+
double LambdaS;
bool Found = Calc2Schnitt(P0x, P0y, P1x, P1y, S0x, S0y, S1x, S1y, x, y, lambdap, &LambdaS);
@@ -1703,7 +1819,7 @@
//---------------------------------------------------------------------------
void NassTrockenBerechnung(TNodeList *NodeList, TEdgeList *EdgeList, TErgebnisPolygonList* ErgebnisPolygone, double Von, double Bis, double Diff, int DebugLevel)
{
- write_fortschritt("->Überschwemmungsgrenzen werden ermittelt.\n");
+ write_fortschritt("->Ermittlung der Überschwemmungsgrenzen gestartet\n");
TNodeList *SaveNodeList = NodeList->Copy();
@@ -1714,7 +1830,7 @@
for (double DeltaTopo = Von; DeltaTopo <= Bis; DeltaTopo = DeltaTopo + Diff)
{
- write_fortschritt("Wasserstand %.3f wird bearbeitet.\n", DeltaTopo);
+ write_fortschritt("Wasserstand %.3f zwischen %.3f und %.3f wird bearbeitet\n", DeltaTopo, Von, Bis);
// Zuerst alles wieder wie gehabt einstellen
// Bloss das die Topographie etwas angehoben wird
@@ -1724,8 +1840,8 @@
{
TNode *Node = *n++;
TNode *SaveNode = *s++;
- if (SaveNode->Z > -9999 && SaveNode->Z < 9999) Node->Z = SaveNode->Z + DeltaTopo;
- else Node->Z = SaveNode->Z;
+ if (SaveNode->Z > -9999 && SaveNode->Z < 9999) Node->Z = SaveNode->Z + DeltaTopo;
+ else Node->Z = SaveNode->Z;
if (SaveNode->Wsp > Node->Z + Eps)
{
Node->Wsp = SaveNode->Wsp;
@@ -1760,7 +1876,7 @@
}
*/
- if (DebugLevel >= 2) write_fortschritt("Maximaler Wasserstand wird ermittelt.\n");
+ if (DebugLevel >= 2) write_fortschritt("Maximalen Wasserstand ermitteln\n");
// Maximalen Wasserstand ermitteln
double MaxWsp = 0.0;
@@ -1771,7 +1887,7 @@
if (i == NodeList->begin() || MaxWsp < Node->Wsp) MaxWsp = Node->Wsp;
}
- if (DebugLevel >=2) write_fortschritt("Sicher trockene Knoten werden ermittelt.\n");
+ if (DebugLevel >=2) write_fortschritt("Sicher trockene Knoten ermitteln\n");
// Anzahl der Knoten bestimmen, die höher als der maximale Wassrstand sind
// oder die schon einen Wasserstand haben
@@ -1783,7 +1899,7 @@
if (Node->Wsp > -9999 || Node->Z > MaxWsp) Ready++;
}
- if (DebugLevel >= 2) write_fortschritt("Die ersten Kanten ermitteln, an denen ein Nass/Trocken-Übergng stattfindet.\n");
+ if (DebugLevel >= 2) write_fortschritt("Ersten Kanten mit Nass/Trocken-Übergang ermitteln\n");
// Die Kanten bestimmen, die an einem Ende einen nassen und am anderen Ende einen trockenen Knoten haben
// Dies ist die Anfangskanten
@@ -1802,15 +1918,17 @@
}
}
- if (DebugLevel >= 2) write_fortschritt("Jetzt die Wasserstände weitertragen.\n");
+ if (DebugLevel >= 2) write_fortschritt("Wasserstände ausbreiten\n");
TEdgeList *TempEdgeList = new TEdgeList();
int Changed = 0;
int Run = 0;
do
{
- write_fortschritt("Durchlauf %d\n", ++Run);
+ Run++;
+ if (Run % 10 == 0) write_fortschritt("Durchlauf %d\n", Run);
+
// Hier nur die Verwaltungsinformationen, aber nicht die richtigen Kanten löschen
// Es waren nur geliehene Kanten
TempEdgeList->Empty();
@@ -1934,7 +2052,7 @@
Edge->Ready = false;
}
- if (DebugLevel >= 2) write_fortschritt("Jetzt die Nass/Trocken-Übergänge auf den Kanten bestimmen.\n");
+ if (DebugLevel >= 2) write_fortschritt("Nass/Trocken-Übergänge auf den Kanten bestimmen\n");
// Jetzt die Nass/Trocken Übergänge bestimmen
int FoundWetDry = 0;
@@ -1978,11 +2096,11 @@
if (fabs(D2) >= 0.00001) Faktor = 1 / (1 + D1/D2);
- if (Z1 < -9999 || Z1 > 9999)
+ if (Z1 < -9999 || Z1 > 9999)
{
Faktor = 0.99;
}
- else if (Z2 < -9999 || Z2 > 9999)
+ else if (Z2 < -9999 || Z2 > 9999)
{
Faktor = 0.01;
}
@@ -1998,7 +2116,7 @@
// Jetzt sind alle Nass/Trockenübergänge bestimmt
- if (DebugLevel >= 2) write_fortschritt("Jetzt die Nass/Trocken-Übergänge verbinden.\n");
+ if (DebugLevel >= 2) write_fortschritt("Nass/Trocken-Übergänge verbinden\n");
// Jetzt muss man sie nur noch verbinden
@@ -2044,10 +2162,35 @@
}
} while (FoundStartChangeEdge);
+
+ if (fabs(DeltaTopo - Von) < 0.001)
+ {
+ // Jetzt die Wasserstände sichern
+ TNodeList::iterator n = NodeList->begin();
+ TNodeList::iterator s = SaveNodeList->begin();
+ for (unsigned int i=0; i<NodeList->size(); i++)
+ {
+ TNode *Node = *n++;
+ TNode *SaveNode = *s++;
+ SaveNode->Wsp = Node->Wsp;
+ }
+ }
}
+
+ // Jetzt die Wasserstände sichern
+ TNodeList::iterator n = NodeList->begin();
+ TNodeList::iterator s = SaveNodeList->begin();
+ for (unsigned int i=0; i<NodeList->size(); i++)
+ {
+ TNode *Node = *n++;
+ TNode *SaveNode = *s++;
+ Node->Z = SaveNode->Z;
+ Node->Wsp = SaveNode->Wsp;
+ }
+
delete SaveNodeList;
- write_fortschritt("Überschwemmungsgrenzen wurden ermittelt.\n");
+ write_fortschritt("<-Ermittlung der Überschwemmungsgrenzen beendet\n");
}
Modified: trunk/src/tools.h
===================================================================
--- trunk/src/tools.h 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/tools.h 2006-05-11 21:32:40 UTC (rev 48)
@@ -44,15 +44,15 @@
std::string UnsignedInt64ToBin (unsigned INT64 Value);
std::string UnsignedInt64ToDez (unsigned INT64 Value);
unsigned INT64 CalcXYKombi (double X, double Y);
-void Swap2Bytes(byte *Bytes);
-void Swap4Bytes(byte *Bytes);
-void Swap8Bytes(byte *Bytes);
+void Swap2Bytes(void *Bytes);
+void Swap4Bytes(void *Bytes);
+void Swap8Bytes(void *Bytes);
void* SfRealloc(void *pMem, int nNewSize);
std::string GetFileExt(std::string FileName);
std::string ExchangeFileExt(std::string FileName, std::string Ext);
std::string GetFilePath(std::string FileName);
std::string ToUpperCase(std::string InString);
-double CrossProduct(TNode *n1, TNode *n2, TNode *n3);
+long double CrossProduct(TNode *n1, TNode *n2, TNode *n3);
bool CircumCircle(TNode *n1, TNode *n2, TNode *n3, double *x, double *y, double *r);
long CheckSpeed(int DebugLevel);
const char* ShapeTypeName(TShpType ShapeType);
@@ -68,10 +68,11 @@
void BuildPolygon(TProfilList *ProfilList, TXYList *XyList, int DebugLevel);
void EqualizeProfil(TProfil *ProfilOne, TProfil *ProfilTwo);
void CheckForDuplicates(TNodeList *NodeList, TElementList *ElementList, int DebugLevel);
-void BuildEdgeList(TEdgeList* EdgeList, TElementList* ElementList, int DebugLevel);
+void BuildEdgeList(TNodeList* NodeList, TElementList* ElementList, TEdgeList* EdgeList, int DebugLevel);
void BuildProfilNodeList(TProfilList *ProfilList, TNodeList *NodeList, TGewaesserAchseList *GewaesserAchseList, TProfilList *SperrenList, TNodeList *ProfilNodeList, double AvgDistance, bool Sperre, int DebugLevel);
void TransferWsp(TNodeList *ProfilNodeList, TNodeList *NodeList, TProfilList* SperrenList, double AvgDistance, int DebugLevel);
-void GetWspFromNodeList(TProfilList* BruchList, TNodeList* NodeList, TProfilList* SperrenList, double AvgDistance, int DebugLevel);
+void TransferWsp(TProfilList *RohreList, TNodeList *NodeList, double AvgDistance, int DebugLevel);
+void GetWspFromNodeList(TNodeList* NodeList, TProfilList* RohreList, double AvgDistance, int DebugLevel);
void NassTrockenBerechnung(TNodeList *NodeList, TEdgeList *edgelist, TErgebnisPolygonList* ErgebnisPolygone, double Von, double Bis, double Diff, int DebugLevel);
//---------------------------------------------------------------------------
Modified: trunk/src/tri.cpp
===================================================================
--- trunk/src/tri.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/tri.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -25,12 +25,11 @@
double cy = 0;
double cr = 0;
-double MinWin = 360.0;
-double MaxWin = 0.0;
-
//---------------------------------------------------------------------
void FindLeftMostNeighbours(TNodeList* NodeList, TNode* *Node1, TNode* *Node2)
{
+ write_fortschritt("->Suchen der Startkante gestartet\n");
+
double Min1 = 0.0;
double Min2 = 0.0;
@@ -73,7 +72,9 @@
*Node2 = Node;
}
}
- if (*Node1 && *Node2) write_fortschritt("Kante: Knoten %d -> Knoten %d als Start\n", (*Node1)->Nr, (*Node2)->Nr);
+ if (*Node1 && *Node2) write_fortschritt("Kante: %d - %d als Startkante\n", (*Node1)->Nr, (*Node2)->Nr);
+
+ write_fortschritt("<-Suchen der Startkante beendet\n");
}
//---------------------------------------------------------------------
@@ -91,8 +92,6 @@
TNode *Node1 = AktEdge->Node1;
TNode *Node2 = AktEdge->Node2;
- TNode* NewNode = 0;
-
double X1 = Node1->X;
double Y1 = Node1->Y;
double X2 = Node2->X;
@@ -101,18 +100,20 @@
double Dx = X2 - X1;
double Dy = Y2 - Y1;
+ TNodeList* FoundNodeList = 0;
+
double X = (X1 + X2) / 2;
double Y = (Y1 + Y2) / 2;
int MaxTestAnz = 5;
int TestAnz = 0;
- TNodeList* FoundNodeList = 0;
+ int FoundAnz = 0;
do
{
TestAnz++;
- double SX = X - TestAnz * TestAnz * Dy;
- double SY = Y + TestAnz * TestAnz * Dx;
+ double SX = X - 3 * TestAnz * Dy;
+ double SY = Y + 3 * TestAnz * Dx;
TestNode.X = SX;
TestNode.Y = SY;
@@ -127,71 +128,36 @@
FoundNodeList->clear();
}
+ FoundAnz = 0;
TNodeList::iterator i = FoundNodeList->begin();
while (i != FoundNodeList->end())
{
TNode* Node = *i;
+ Node->Wsp = 1;
+
if (Node->Nr == Node1->Nr)
{
- FoundNodeList->erase(i);
- i = FoundNodeList->begin();
- continue;
+ Node->Wsp = 0;
}
- if (Node->Nr == Node2->Nr)
+ else if (Node->Nr == Node2->Nr)
{
- FoundNodeList->erase(i);
- i = FoundNodeList->begin();
- continue;
+ Node->Wsp = 0;
}
-
- double CP = CrossProduct(Node1, Node2, Node);
- if (CP < 0.0000001)
+ else if (CrossProduct(Node1, Node2, Node) < 0.0000001)
{
- FoundNodeList->erase(i);
- i = FoundNodeList->begin();
- continue;
+ Node->Wsp = 0;
}
-
-
- double X3 = Node->X;
- double Y3 = Node->Y;
- double Win = ThreeToWin(X2, Y2, X3, Y3, X1, Y1, 1);
-
-
- if (DebugLevel >= 8)
+ else
{
- 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("Minimaler Winkel bisher: %7.3f, Maximaler Winkel bisher: %7.3f\n", MinWin, MaxWin);
- }
+ FoundAnz++;
}
-
- if (Win > 177)
- {
- write_warning(9197, "Der Winkel zwischen den Kanten ist zu groß\n");
- }
-
- if (Win < 3)
- {
- FoundNodeList->erase(i);
- i = FoundNodeList->begin();
- continue;
- }
-
i++;
}
- } while (TestAnz < MaxTestAnz && FoundNodeList->size() == 0);
+ } while (FoundAnz <= 0 && TestAnz < MaxTestAnz);
+/*
// Dann versuche ich es noch mal mit allen
-/*
if (FoundNodeList->size() == 0)
{
for (TNodeList::iterator i = NodeList->begin(); i != NodeList->end(); i++)
@@ -203,28 +169,32 @@
}
*/
- NewNode = 0;
TNodeList::iterator i = FoundNodeList->begin();
- if (i != FoundNodeList->end())
- {
- NewNode = *i++;
- }
+ TNode* NewNode = 0;
+ while (i != FoundNodeList->end() && (*i)->Wsp < 1) i++;
+ if (i != FoundNodeList->end()) 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)
+ if (Node->Wsp < 1)
{
- dump_error(__FILE__, __LINE__, "Einer der gefundenen Knoten ist einer der beiden Kantenknoten");
+ i++;
+ continue;
}
+ if (Node->Nr == Node1->Nr || Node->Nr == Node2->Nr || Node->Nr == NewNode->Nr)
+ {
+ dump_error(__FILE__, __LINE__, "Einer der gefundenen Knoten ist einer der bereits getesteten Kantenknoten");
+ }
+
if (DebugLevel >= 8)
{
double CP = CrossProduct(Node1, Node2, Node);
@@ -235,58 +205,102 @@
}
}
- if (Node->Nr != NewNode->Nr)
+ double X = Node->X;
+ double Y = Node->Y;
+
+ double Dx = cx - X;
+ double Dy = cy - Y;
+
+ // Liegt er im Umkreis ?
+ if (Dx * Dx + Dy * Dy < cr - 0.1)
{
- double X = Node->X;
- double Y = Node->Y;
+ // Er ist deutlich dichter dran, also ist er besser
+ NewNode = Node;
+ CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
+ i++;
+ continue;
+ }
- double Dx = cx - X;
- double Dy = cy - Y;
+ if (Dx * Dx + Dy * Dy > cr + 0.1)
+ {
+ // Er ist deutlich weiter weg, also brauchen wir ihn nicht weiter zu beachten
+ i++;
+ continue;
+ }
- // Liegt er im Umkreis ?
- if (sqrt(Dx * Dx + Dy * Dy) < sqrt(cr) - 0.01)
+ // Die beiden Knoten sind gleich oder wenigstens fast gleich gut
+ // Dann hilft nur eine andere Art der Unterscheidung
+
+ double CP = CrossProduct(Node1, NewNode, Node);
+
+ if (CP < 0.0000001)
+ {
+ // die Diagonalen sind Node1 - Node und NewNode - Node2
+
+ // Gab es die Diagonale Node1 - Node ?
+ TEdge* Edge = ReadyEdgeList->FindWithIndex(Node1, Node);
+
+ if (Edge)
{
+ // Dann müssen wir Node auch nehmen
NewNode = Node;
+ CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
i++;
continue;
}
- if (sqrt(Dx * Dx + Dy * Dy) > sqrt(cr) + 0.01)
+ // Gab es schon die Diagonale NewNode - Node2 ?
+ Edge = ReadyEdgeList->FindWithIndex(NewNode, Node2);
+
+ // Dann müssen wir NewNode auch nehmen
+ if (Edge)
{
- // Er ist weiter weg, also brauchen wir ihn nicht weiter zu beachten
i++;
continue;
}
+ }
+ else
+ {
+ // die Diagonalen sind Node - Node2 und Node1 - NewNode
- // Die beiden Knoten sind gleich oder wenigstens fast gleich gut
- // Dann hilft nur eine andere Art der Unterscheidung
+ // Gab es die Diagonale Node - Node2 ?
+ TEdge* Edge = ReadyEdgeList->FindWithIndex(Node, Node2);
- // Gab es schon eine Kante zu dem neuen Knoten ?
- TEdge* Edge = TodoEdgeList->Find(Node, Node1);
-
if (Edge)
{
- // Dann müssen wir ihn nehmen
+ // Dann müssen wir Node auch nehmen
NewNode = Node;
+ CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
i++;
continue;
}
- // Gab es schon eine Kante zu dem neuen Knoten ?
- Edge = TodoEdgeList->Find(Node2, Node);
+ // Gab es schon die Diagonale Node1 - NewNode ?
+ Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
- // Dann müssen wir ihn nehmen
+ // Dann müssen wir NewNode auch nehmen
if (Edge)
{
- NewNode = Node;
i++;
continue;
}
}
+
+ if (Dx * Dx + Dy * Dy < cr)
+ {
+ // Er ist dichter dran, also ist er besser
+ // Runddungsfehler spielen keine Rolle mehr
+ NewNode = Node;
+ CircumCircle(Node1, Node2, NewNode, &cx, &cy, &cr);
+ i++;
+ continue;
+ }
+
i++;
}
}
+/*
if (NewNode)
{
// Wenn eine neue Kante schon als Aussenkante definiert wurde, dann
@@ -310,9 +324,80 @@
NewNode = 0;
}
}
+*/
+/*
if (NewNode)
{
+ double X3 = NewNode->X;
+ double Y3 = NewNode->Y;
+ double Win = ThreeToWin(X1, Y1, X2, Y2, X3, Y3, 1);
+
+ if (Win < 2 || Win > 178)
+ {
+ TEdge* Edge2 = ReadyEdgeList->FindWithIndex(Node2, NewNode);
+ TEdge* Edge3 = ReadyEdgeList->FindWithIndex(NewNode, Node1);
+
+ if (Edge2 == 0 || Edge3 == 0)
+ {
+ // Das neue Element wäre mir zu spitz oder flach
+ // und wurde nicht unbedingt benötigt
+ NewNode = 0;
+ }
+ }
+ }
+
+ if (NewNode)
+ {
+ double X3 = NewNode->X;
+ double Y3 = NewNode->Y;
+ double Win = ThreeToWin(X2, Y2, X3, Y3, X1, Y1, 1);
+
+// double Dx = X3 - X2;
+// double Dy = Y3 - Y2;
+
+// if ((ReadyEdgeList->Anz > 100 && sqrt(Dx*Dx+Dy*Dy) > ReadyEdgeList->AvgDistance * 10) || Win < 2 || Win > 178)
+ if (Win < 2 || Win > 178)
+ {
+ TEdge* Edge2 = ReadyEdgeList->FindWithIndex(Node2, NewNode);
+ TEdge* Edge3 = ReadyEdgeList->FindWithIndex(NewNode, Node1);
+
+ if (Edge2 == 0 || Edge3 == 0)
+ {
+ // Das neue Element wäre mir zu spitz oder flach
+ // und wurde nicht unbedingt benötigt
+ NewNode = 0;
+ }
+ }
+ }
+
+ if (NewNode)
+ {
+ double X3 = NewNode->X;
+ double Y3 = NewNode->Y;
+ double Win = ThreeToWin(X3, Y3, X1, Y1, X2, Y2, 1);
+
+// double Dx = X3 - X1;
+// double Dy = Y3 - Y1;
+
+// if ((ReadyEdgeList->Anz > 100 && sqrt(Dx*Dx+Dy*Dy) > ReadyEdgeList->AvgDistance * 10) || Win < 2 || Win > 178)
+ if (Win < 2 || Win > 178)
+ {
+ TEdge* Edge2 = ReadyEdgeList->FindWithIndex(Node2, NewNode);
+ TEdge* Edge3 = ReadyEdgeList->FindWithIndex(NewNode, Node1);
+
+ if (Edge2 == 0 || Edge3 == 0)
+ {
+ // Das neue Element wäre mir zu spitz oder flach
+ // und wurde nicht unbedingt benötigt
+ NewNode = 0;
+ }
+ }
+ }
+*/
+
+ if (NewNode)
+ {
if (DebugLevel >= 8)
{
TEdge* Edge1 = ReadyEdgeList->FindWithIndex(Node1, Node2);
@@ -350,6 +435,7 @@
}
else
{
+/*
if (DebugLevel >= 8)
{
// Wenn diese Richtung nicht in der Todo-Liste war,
@@ -363,6 +449,13 @@
Edge = new TEdge(NewNode, Node2);
TodoEdgeList->Add(Edge);
+*/
+ Edge = ReadyEdgeList->FindWithIndex(NewNode, Node2);
+ if (0 == Edge)
+ {
+ Edge = new TEdge(NewNode, Node2);
+ TodoEdgeList->Add(Edge);
+ }
}
// Richtung: Ist schon fertig
@@ -375,6 +468,7 @@
}
else
{
+/*
if (DebugLevel >= 8)
{
Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
@@ -386,6 +480,13 @@
Edge = new TEdge(Node1, NewNode);
TodoEdgeList->Add(Edge);
+*/
+ Edge = ReadyEdgeList->FindWithIndex(Node1, NewNode);
+ if (0 == Edge)
+ {
+ Edge = new TEdge(Node1, NewNode);
+ TodoEdgeList->Add(Edge);
+ }
}
}
else
@@ -402,18 +503,20 @@
//---------------------------------------------------------------------
bool Triangulate(TNodeList *NodeList, TElementList *ElementList, int DebugLevel)
{
- write_fortschritt("->Netz wird trianguliert\n");
+ write_fortschritt("->Triangulierung der Knoten gestartet\n");
if (NodeList->size() < 3)
{
write_error(1234, "Es sind im DGM nur %d Knoten vorhanden.\nEs werden aber mindestens 3 Knoten benötigt\n", NodeList->size());
}
- write_fortschritt("Sortiere die Knoten\n");
+ write_fortschritt("->Sortien Knoten gestartet\n");
NodeList->SortByXY();
+ write_fortschritt("<-Sortien der Knoten beendet\n");
- write_fortschritt("Lösche den Knoten/Kanten-Index\n");
+ write_fortschritt("->Löschen des Knoten/Kanten-Index gestartet\n");
NodeList->ClearEdgeIndex();
+ write_fortschritt("<-Löschen des Knoten/Kanten-Index beendet\n");
TEdgeList *TodoEdgeList = new TEdgeList;
TEdgeList *ReadyEdgeList = new TEdgeList;
@@ -424,7 +527,7 @@
// Find closest neighbours
FindLeftMostNeighbours(NodeList, &Node1, &Node2);
- // Create Edges and add it to the triangulation.
+ // Erzeuge die ersten beiden Kanten
TEdge* SeedEdge1 = new TEdge(Node1, Node2);
TodoEdgeList->Add(SeedEdge1);
@@ -444,13 +547,14 @@
while (TodoEdgeList->Anz > 0)
{
CompleteFacet(NodeList, ElementList, TodoEdgeList, ReadyEdgeList, DebugLevel);
+
/*
- #include "file.h"
- if (ReadyEdgeList->Anz > 618)
- {
- SaveElements("tmp_elements.shp", ElementList, true);
- SaveNet("tmp.2dm", NodeList, ElementList, true);
- }
+#include "file.h"
+if (ReadyEdgeList->Anz >= 128901)
+{
+ SaveElements("tmp_elements.shp", ElementList, true);
+ SaveNet("tmp.2dm", NodeList, ElementList, true);
+}
*/
ftime (&Now);
@@ -461,10 +565,14 @@
NextMSec = NowMSec + TimeDiff;
int DiffMSec = NowMSec - StartMSec;
- 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);
+
+ if (ElementList->size() > 0)
+ {
+ double RestMSec = DiffMSec * 2.0 * (NodeList->size() * 2.0 - ElementList->size()) / ElementList->size();
+ 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);
+ }
}
}
@@ -473,7 +581,7 @@
ReadyEdgeList->Clear();
delete ReadyEdgeList;
- write_fortschritt("Netz wurde trianguliert\n");
+ write_fortschritt("<-Triangulierung der Knoten beendet\n");
return (true);
}
Modified: trunk/src/wsplgen.cpp
===================================================================
--- trunk/src/wsplgen.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/wsplgen.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -28,13 +28,10 @@
#endif
//---------------------------------------------------------------------------
-//#include <sys/stat.h>
-//#include <fcntl.h>
-//#include <io.h>
-
#ifndef __BORLANDC__
#include <unistd.h>
#endif
+#include "wsplgen.h"
#include "parameter.h"
#include "tools.h"
#include "xy.h"
@@ -52,11 +49,19 @@
//---------------------------------------------------------------------------
int main(int argc, char **argv)
{
- if (argc > 1 && argv[1][0] == '$')
+ if (argc <= 1)
{
fhlog = fopen ("wsplgen_log.txt", "w");
fhsta = fopen ("wsplgen_sta.txt", "w");
+
+ write_fortschritt ("WSPLGEN Version %s vom %s\n", Version, __DATE__);
+ write_error(1201, "Es wurden keine Parameter übergeben.\nWenigstens die Parameter -DGM=<DGM-Datei>, -PRO=<Profil-Datei> und -WSP=<Wasserstands-Datei>\nmüssen angegeben werden.\n");
}
+ else if (argv[1][0] == '$')
+ {
+ fhlog = fopen ("wsplgen_log.txt", "w");
+ fhsta = fopen ("wsplgen_sta.txt", "w");
+ }
else
{
fhlog = stdout;
@@ -64,7 +69,7 @@
}
- write_fortschritt ("->WSPLGEN wurde gestartet\n");
+ write_fortschritt ("->WSPLGEN Version %s vom %s wurde gestartet\n", Version, __DATE__);
// Hier werden alle Profile drin verwaltet
TProfilList ProfilList;
@@ -75,12 +80,9 @@
// Hier werden alle Sperren und Brüche drin verwaltet
TProfilList SperrenList;
- TProfilList BruchList;
+ TProfilList GrabenList;
+ TProfilList RohreList;
- // 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;
@@ -105,15 +107,15 @@
// Dies dient nur dazu mal kurz ein Netz zu triangulieren
// LoadDGM("daten\\dgm_ziemlich_riesig.shp", &NodeList, &ElementList, 0, 99999999, 3);
-// 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, 3);
-// SaveElements("tmp_elements.shp", &ElementList, true);
-// SaveNet("daten\\dgm_riesig.2dm.shp", &NodeList, &ElementList, 3);
+// LoadDGM("debug_output\\dgm.xyz", &NodeList, &ElementList, 0, 99999999, 8);
+// LoadDGM("debug_output\\dgm.grd", &NodeList, &ElementList, 0, 99999999, 8);
+// LoadDGM("debug_output\\testdgm.shp", &NodeList, &ElementList, 0, 99999999, 8);
+// LoadDGM("debug_output\\testdgm2.shp", &NodeList, &ElementList, 0, 99999999, 8);
+// LoadDGM("daten\\dgm_riesig.shp", &NodeList, &ElementList, 0, 99999999, 8);
+// SaveNodes("tmp_ori_nodes.shp", &NodeList, 3);
+// Triangulate (&NodeList, &ElementList, 8);
+// SaveNet("daten\\dgm_riesig.2dm", &NodeList, &ElementList, 8);
+// SaveElements("tmp_elements.shp", &ElementList, 8);
// return(0);
@@ -125,7 +127,7 @@
// Jetzt die Profile einlesen
// Dabei wird die Stationierung in km in cm umgerechnet
- LoadProfile(Parameter.FileNamePro, &ProfilList, Parameter.DebugLevel);
+ LoadProfile(Parameter.FileNamePro, &ProfilList, Parameter.VonKm, Parameter.BisKm, Parameter.DebugLevel);
if (ProfilList.size() < 2)
{
@@ -151,10 +153,10 @@
LoadAchse(Parameter.FileNameAchse, &GewaesserAchseList, Parameter.DebugLevel);
}
- // Jetzt die Brüche und Dämme einlesen, wenn es notwendig ist
+ // Jetzt die Gräben und Sperren einlesen, wenn es notwendig ist
if (Parameter.IsSetLin)
{
- LoadLinien(Parameter.FileNameLin, &SperrenList, &BruchList, Parameter.DebugLevel);
+ LoadLinien(Parameter.FileNameLin, &SperrenList, &GrabenList, &RohreList, Parameter.DebugLevel);
}
// Jetzt die Profile nach Gewaessern trennen
@@ -165,29 +167,34 @@
// Ungefähre Geschwindigkeit ermitteln, als Grundlage für die Entscheidung
// ob in Scheiben gearbeitet werden soll
- long Speed = CheckSpeed(Parameter.DebugLevel);
+ int MaxNodesPerSlice = Parameter.MaxNodesPerSlice;
- write_fortschritt("->Ermitteln der maximalen DGM-Knotenanzahl\n");
- // Eine rein empirische Formel
- int MaxNodesPerSlice = Speed * 10;
- // MaxNodesPerSlice = 20000;
+ if (false == Parameter.IsSetMaxNodesPerSlice)
+ {
+ long Speed = CheckSpeed(Parameter.DebugLevel);
+ // Eine rein empirische Formel
+ MaxNodesPerSlice = Speed * 11;
+ write_fortschritt("Es können ca. %d Geländepunkte pro Bearbeitungsabschnitt eingelesen werden\n", MaxNodesPerSlice);
+ }
- write_fortschritt("Es können nur ca. %d DGM-Punkte eingelesen werden\n", MaxNodesPerSlice);
- write_fortschritt("Ermitteln der maximalen DGM-Knotenanzahl beendet\n");
-
// Jetzt die Gewasser der Reihe nach bearbeiten
// Für jedes Gewaesser gibt es eine Profilliste in der ProfilMap
for (TProfilMap::iterator GewaesserIter = ProfilMap.begin(); GewaesserIter != ProfilMap.end(); GewaesserIter++)
{
std::string Gewaesser = GewaesserIter->first;
- write_fortschritt("Gewässer '%s' wird bearbeitet\n", Gewaesser.c_str());
+ write_fortschritt("->Bearbeitung von Gewässer '%s' gestartet\n", Gewaesser.c_str());
TProfilList *GewProfilList = GewaesserIter->second;
TProfil *FirstProfil = *GewProfilList->begin();
TProfil *LastProfil = *GewProfilList->rbegin();
+ // Jetzt ein Polygon bilden, das die Profile begrenzt
+ BuildPolygon(GewProfilList, &Bereichspolygon, Parameter.DebugLevel);
+
+ if (Parameter.DebugLevel >= 4) SavePolygon("debug_output\\03_" + Gewaesser + "_Polygon" + ".shp", Gewaesser, 0, 0, &Bereichspolygon, Parameter.DebugLevel);
+
if (GewProfilList->size() < 100)
{
double SollAbstand = (LastProfil->Station - FirstProfil->Station) / 100.0;
@@ -197,13 +204,8 @@
}
// Mal wieder Zwischenergebnisse produzieren
- if (Parameter.DebugLevel >= 5) SaveProfile("debug_output\\03_" + Gewaesser + "_Profile_100" + ".shp", GewProfilList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 5) SaveProfile("debug_output\\04_" + Gewaesser + "_Profile_100" + ".shp", GewProfilList, Parameter.DebugLevel);
- // Jetzt ein Polygon bilden, das die Profile begrenzt
- BuildPolygon(GewProfilList, &Bereichspolygon, Parameter.DebugLevel);
-
- if (Parameter.DebugLevel >= 4) SavePolygon("debug_output\\04_" + Gewaesser + "_Polygon" + ".shp", Gewaesser, 0, 0, &Bereichspolygon, Parameter.DebugLevel);
-
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,
@@ -235,7 +237,8 @@
sprintf (VC, "_Von%d", VonProfil->Station);
sprintf (NC, "_Bis%d", BisProfil->Station);
- write_fortschritt("->Bei Gewaesser %s wird der %d. Bereich von %.4f bis %.4f bearbeitet\n", Gewaesser.c_str(), Count, VonProfil->Station / 10000.0, BisProfil->Station / 10000.0);
+ write_fortschritt("->Bearbeitung vom %d. von %d Bereichen gestartet\n", Count, BereichsList.size());
+ write_fortschritt("Gewässer %s, Bereich %.4f bis %.4f\n", Gewaesser.c_str(), VonProfil->Station / 10000.0, BisProfil->Station / 10000.0);
// Als Endemarkierung
Bis++;
@@ -265,28 +268,30 @@
NodeList.SortByNr();
- if (Parameter.DebugLevel >= 7) SaveNet("debug_output\\06_" + Gewaesser + "_Net_" + VC + NC + ".2dm", &NodeList, &ElementList, true);
- if (Parameter.DebugLevel >= 5) SaveNodes("debug_output\\07_" + Gewaesser + "_Nodes_" + VC + NC + ".shp", &NodeList, true);
- if (Parameter.DebugLevel >= 5) SaveElements("debug_output\\08_" + Gewaesser + "_Elements_" + VC + NC + ".shp", &ElementList, true);
+ if (Parameter.DebugLevel >= 7) SaveNet("debug_output\\06_" + Gewaesser + "_Net_" + VC + NC + ".2dm", &NodeList, &ElementList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 5) SaveNodes("debug_output\\07_" + Gewaesser + "_Nodes_" + VC + NC + ".shp", &NodeList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 5) SaveElements("debug_output\\08_" + Gewaesser + "_Elements_" + VC + NC + ".shp", &ElementList, Parameter.DebugLevel);
// Aus den Elementen werden nun die Kanten gebildet
// Der durchschnittliche Abstand der Knoten (bzw. die Kantenlänge) wird dabei mit ermittelt.
// Das DGM sollte einigermassen homogen sein
- // Jetzt die gesperrten Elemente entfernen
- ElementList.ChangeElements(&NodeList, &SperrenList, &BruchList, Parameter.DebugLevel);
+ if (SperrenList.size() > 0 || GrabenList.size() > 0)
+ {
+ // Jetzt die gesperrten Elemente entfernen
+ ElementList.ChangeElements(&NodeList, &SperrenList, &GrabenList, Parameter.DebugLevel);
+ CheckForDuplicates(&NodeList, &ElementList, Parameter.DebugLevel);
+ }
- CheckForDuplicates(&NodeList, &ElementList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 7) SaveNet("debug_output\\09_" + Gewaesser + "_Net_" + VC + NC + ".2dm", &NodeList, &ElementList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 5) SaveNodes("debug_output\\10_" + Gewaesser + "_Nodes_" + VC + NC + ".shp", &NodeList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 5) SaveElements("debug_output\\11_" + Gewaesser + "_Elements_" + VC + NC + ".shp", &ElementList, Parameter.DebugLevel);
- if (Parameter.DebugLevel >= 7) SaveNet("debug_output\\09_" + Gewaesser + "_Net_" + VC + NC + ".2dm", &NodeList, &ElementList, true);
- if (Parameter.DebugLevel >= 5) SaveNodes("debug_output\\10_" + Gewaesser + "_Nodes_" + VC + NC + ".shp", &NodeList, true);
- if (Parameter.DebugLevel >= 5) SaveElements("debug_output\\11_" + Gewaesser + "_Elements_" + VC + NC + ".shp", &ElementList, true);
-
// Hier werden die Kanten drin verwaltet
// Die Kanten werden im Moment noch aus den Elementen generiert
// Dieser Umweg ist eingendlich nicht notwendig
TEdgeList* EdgeList = new TEdgeList;
- BuildEdgeList(EdgeList, &ElementList, Parameter.DebugLevel);
+ BuildEdgeList(&NodeList, &ElementList, EdgeList, Parameter.DebugLevel);
// Die Elemete werden nun nicht mehr gebraucht
ElementList.Clear();
@@ -323,37 +328,27 @@
// Jetzt eine neue Knotenliste aus den Profilen generienen
BuildProfilNodeList(TempProfilList, &NodeList, &GewaesserAchseList, &SperrenList, &ProfilNodeList, AvgDistance * 2.0, Parameter.Sperre, Parameter.DebugLevel);
- if (Parameter.DebugLevel >= 4) SaveNodes("debug_output\\15_" + Gewaesser + "_ProfilNodes_" + VC + NC + ".shp", &ProfilNodeList, true);
+ if (Parameter.DebugLevel >= 4) SaveNodes("debug_output\\15_" + Gewaesser + "_ProfilNodes_" + VC + NC + ".shp", &ProfilNodeList, Parameter.DebugLevel);
- // Jetzt die Wasserstände übertragen
+ // Jetzt die Wasserstände der Profile übertragen
TransferWsp(&ProfilNodeList, &NodeList, &SperrenList, AvgDistance / 2.0, Parameter.DebugLevel);
-/*
- if (BruchList.size() > 0)
+ if (Parameter.DebugLevel >= 4) SaveNodes("debug_output\\16_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".shp", &NodeList, Parameter.DebugLevel);
+
+ if (RohreList.size() > 0)
{
- // Mit Stützstellen auffüllen
- BruchList.FillProfile(AvgDistance / 2.0, -1, Parameter.DebugLevel);
+ // Jetzt den Wasserstand aus der NodeList extrahieren
+ GetWspFromNodeList(&NodeList, &RohreList, AvgDistance * 2.0, Parameter.DebugLevel);
- // Jetzt den Wasserstand aus der Node_List extrahieren
- GetWspFromNodeList(&BruchList, &NodeList, &SperrenList, AvgDistance / 2.0, Parameter.DebugLevel);
-
- if (Parameter.DebugLevel >= 7) SaveProfile("debug_output\\15_" + Gewaesser + "_Bruch_ohne_Wsp_" + VC + NC + ".shp", &BruchList, Parameter.DebugLevel);
-
- // Jetzt eine neue Knotenliste aus den Brüchen generienen
- BuildProfilNodeList(&BruchList, &NodeList, &GewaesserAchseList, 0, &BruchNodeList, AvgDistance * 2.0, false, Parameter.DebugLevel);
-
- if (Parameter.DebugLevel >= 6) SaveNodes("debug_output\\16_" + Gewaesser + "_Bruch_mit_Wsp_" + VC + NC + ".shp", &BruchNodeList, true);
-
- // Jetzt die Wasserstände übertragen
- TransferWsp(&BruchNodeList, &NodeList, &SperrenList, AvgDistance / 2.0, Parameter.DebugLevel);
+ // Jetzt die Wasserstände der Rohre übertragen
+ TransferWsp(&RohreList, &NodeList, AvgDistance * 2.0, Parameter.DebugLevel);
}
-*/
ProfilNodeList.Clear();
delete TempProfilList;
- if (Parameter.DebugLevel >= 4) SaveNodes("debug_output\\16_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".shp", &NodeList, true);
+ if (Parameter.DebugLevel >= 4) SaveNodes("debug_output\\17_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".shp", &NodeList, Parameter.DebugLevel);
// Wurde der Wert für das Argument 'Bis' beim Parameter -DELTA nicht gesetzt
// so ist jetzt die Zeit das nachzuholen
@@ -392,6 +387,12 @@
TErgebnisPolygonList* TempErgebnisPolygone = new TErgebnisPolygonList;
NassTrockenBerechnung(&NodeList, EdgeList, TempErgebnisPolygone, Parameter.Von, Parameter.Bis, Parameter.Diff, Parameter.DebugLevel);
+ NodeList.SortByNr();
+
+ if (Parameter.DebugLevel >= 4) SaveNodes("debug_output\\18_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".shp", &NodeList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 4) SaveSol("debug_output\\19_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".sol", &NodeList, Parameter.DebugLevel);
+ if (Parameter.DebugLevel >= 4) SaveNet("debug_output\\20_" + Gewaesser + "_Nodes_mit_WSP_" + VC + NC + ".2dm", &NodeList, 0, Parameter.DebugLevel);
+
for (TErgebnisPolygonList::iterator i = TempErgebnisPolygone->begin(); i != TempErgebnisPolygone->end(); i++)
{
TErgebnisPolygon* ErgebnisPolygon = *i;
@@ -403,6 +404,9 @@
ErgebnisPolygonList.Append(TempErgebnisPolygone);
+ // Speichern der Ergebnispolygone
+ SavePolygone(Gewaesser + VC + NC + ".shp", TempErgebnisPolygone, Parameter.DebugLevel);
+
if (Parameter.DebugLevel >= 8)
{
for (TErgebnisPolygonList::iterator i = ErgebnisPolygonList.begin(); i != ErgebnisPolygonList.end(); i++)
@@ -425,8 +429,9 @@
// die Knoten waren nur geliehen
delete EdgeList;
- write_fortschritt("Bei Gewaesser %s wurde der %d. Bereich von %.4f bis %.4f bearbeitet\n", Gewaesser.c_str(), Count, VonProfil->Station / 10000.0, BisProfil->Station / 10000.0);
+ write_fortschritt("<-Bearbeitung vom %d. von %d Bereichen beendet\n", Count, BereichsList.size());
}
+ write_fortschritt("<-Bearbeitung von Gewässer '%s' beendet\n", Gewaesser.c_str());
}
// Speichern der Ergebnispolygone
Modified: trunk/src/wsplgen.h
===================================================================
--- trunk/src/wsplgen.h 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/wsplgen.h 2006-05-11 21:32:40 UTC (rev 48)
@@ -10,5 +10,18 @@
// Read the file COPYING coming with WSPLGEN for details.
//
-const char Version[] = "0.9.0 r0";
+const char Version[] = "0.9.4 r1";
+// Es wurde ein Fehler bei der Generieung von gleichen Profilen behoben
+// EqualizeProfil hatte Probleme, wenn es zu Rundungsfehlern bei der Ermittlung von
+// der Meter kam und somit das Hinzufügen von Profilpunkten scheiterte
+// Es wurden Profilpunkte hinzugefügt, die eigentlich bereitsvorhanden waren
+// Jetzt wird das gleich (bzw. das kleiner etwas ungenauer behandelt)
+// Ein ProfilStützPunkt muss jetzt 0.01 Meter kleiner sein um wirklich kleiner und damit ungleich zu sein
+
+
+// Die Gewässerachse merkt sich ihre maximale Ausdehnung, was den Test mit dem Schnitt von Profilen deutlich
+// beschleunigt
+
+// const char Version[] = "0.9.3 r0";
+
Modified: trunk/src/xy.cpp
===================================================================
--- trunk/src/xy.cpp 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/xy.cpp 2006-05-11 21:32:40 UTC (rev 48)
@@ -54,60 +54,32 @@
};
//---------------------------------------------------------------------
-// TXYZ
-//---------------------------------------------------------------------
-
-//---------------------------------------------------------------------
-TXYZ::TXYZ(double x, double y) : TXY (x, y)
-{
- Z = -999999.0;
-}
-
-//---------------------------------------------------------------------
-TXYZ::TXYZ(double x, double y, double z) : TXY (x, y)
-{
- Z = z;
-}
-
-//---------------------------------------------------------------------
-TXYZ::TXYZ(TXYZ *xyz) : TXY (xyz->X, xyz->Y)
-{
- Z = xyz->Z;
-}
-
-//---------------------------------------------------------------------
-struct TXYZSort
-{
- bool operator()(TXYZ* const &XYZ1, TXYZ* const &XYZ2)
- {
- return(XYZ1->XYKombi < XYZ2->XYKombi);
- }
-};
-
-//---------------------------------------------------------------------
// TNode
//---------------------------------------------------------------------
//---------------------------------------------------------------------
-TNode::TNode(int nr, double x, double y, double z) : TXYZ (x, y, z)
+TNode::TNode(int nr, double x, double y, double z) : TXY (x, y)
{
Nr = nr;
+ Z = z;
Wsp = -9999.9;
EdgeIndex = 0;
}
//---------------------------------------------------------------------
-TNode::TNode(int nr, double x, double y, double z, double wsp) : TXYZ (x, y, z)
+TNode::TNode(int nr, double x, double y, double z, double wsp) : TXY (x, y)
{
Nr = nr;
+ Z = z;
Wsp = wsp;
EdgeIndex = 0;
}
//---------------------------------------------------------------------
-TNode::TNode(TNode *node) : TXYZ (node->X, node->Y, node->Z)
+TNode::TNode(TNode *node) : TXY (node->X, node->Y)
{
Nr = node->Nr;
+ Z = node->Z;
Wsp = node->Wsp;
EdgeIndex = 0;
}
@@ -188,19 +160,6 @@
}
//---------------------------------------------------------------------
-struct TNodeSortByX
-{
- bool operator()(TNode* const &Node1, TNode* const &Node2)
- {
- if (Node1->X < Node2->X) return (true);
- if (Node1->X > Node2->X) return (false);
- if (Node1->Y < Node2->Y) return (true);
- if (Node1->Y > Node2->Y) return (false);
- return (false);
- }
-};
-
-//---------------------------------------------------------------------
struct TNodeSortByXY
{
bool operator()(TNode* const &Node1, TNode* const &Node2)
@@ -223,20 +182,23 @@
//---------------------------------------------------------------------
//---------------------------------------------------------------------
-TPoint::TPoint(double x, double y, double meter) : TXYZ (x, y)
+TPoint::TPoint(double x, double y, double meter) : TXY (x, y)
{
+ Z = -9999.9;
Meter = meter;
}
//---------------------------------------------------------------------
-TPoint::TPoint(double x, double y, double z, double meter) : TXYZ (x, y, z)
+TPoint::TPoint(double x, double y, double z, double meter) : TXY (x, y)
{
+ Z = z;
Meter = meter;
}
//---------------------------------------------------------------------
-TPoint::TPoint(TPoint *point) : TXYZ (point->X, point->Y, point->Z)
+TPoint::TPoint(TPoint *point) : TXY (point->X, point->Y)
{
+ Z = point->Z;
Meter = point->Meter;
}
@@ -450,152 +412,6 @@
}
//---------------------------------------------------------------------
-// TXYZList
-//---------------------------------------------------------------------
-
-//---------------------------------------------------------------------------
-TXYZList::TXYZList(void)
-{
- XYKombiIndex = 0;
- MinX = 0.0;
- MaxX = 0.0;
- MinY = 0.0;
- MaxY = 0.0;
-}
-
-//---------------------------------------------------------------------------
-TXYZList::~TXYZList(void)
-{
- if (XYKombiIndex) delete XYKombiIndex;
- XYKombiIndex = 0;
-
- Clear();
-}
-
-//---------------------------------------------------------------------
-void TXYZList::Clear(void)
-{
- for (unsigned int i=0; i<size(); i++)
- {
- TXYZ *Xyz = (*this)[i];
- delete Xyz;
- }
- clear();
-
- MinX = 0.0;
- MaxX = 0.0;
- MinY = 0.0;
- MaxY = 0.0;
-}
-
-//---------------------------------------------------------------------
-TXYZList* TXYZList::Copy(void)
-{
- TXYZList *NewXyzList = new TXYZList;
-
- for (unsigned int i=0; i<size(); i++)
- {
- TXYZ *OldXyz = (*this)[i];
- TXYZ *NewXyz = new TXYZ(OldXyz);
- NewXyzList->push_back(NewXyz);
- }
-
- NewXyzList->MinX = MinX;
- NewXyzList->MaxX = MaxX;
- NewXyzList->MinY = MinY;
- NewXyzList->MaxY = MaxY;
-
- return(NewXyzList);
-}
-
-//---------------------------------------------------------------------
-void TXYZList::SortByXY(void)
-{
- std::sort(this->begin(), this->end(), TXYZSort());
-
- if (XYKombiIndex) delete XYKombiIndex;
- XYKombiIndex = new TXYKombiIndex<TXYZList, TXYZ>();
- XYKombiIndex->Build(this, 0, size());
-}
-
-//---------------------------------------------------------------------
-TXYZ* TXYZList::FindByXY(double X, double Y, double Eps)
-{
- if (size() <= 0) return (0);
-
- int Index = XYKombiIndex->Search(this, X, Y, Eps);
-
- if (Index >= 0)
- {
- TXYZ *Xyz = (* this)[Index];
-
- double Dx = Xyz->X - X;
- double Dy = Xyz->Y - Y;
- double R = sqrt(Dx * Dx + Dy * Dy);
-
- if (R <= Eps)
- {
- return (Xyz);
- }
- else
- {
- dump_error(__FILE__, __LINE__, "Falschen Knoten gefunden\n");
- }
- }
- else
- {
- for (unsigned int i=0; i<size(); i++)
- {
- TXYZ *Xyz = (* this)[i];
-
- double Dx = Xyz->X - X;
- double Dy = Xyz->Y - Y;
- double R = sqrt(Dx * Dx + Dy * Dy);
-
- if (R <= Eps)
- {
- dump_error(__FILE__, __LINE__, "Existierenden Knoten nicht gefunden\n");
- }
- }
- return (0);
- }
-
- if (Index < 0) return (0);
-
- TXYZ *Xyz = (* this)[Index];
-
- return(Xyz);
-}
-
-//---------------------------------------------------------------------
-void TXYZList::Add(TXYZ *Xyz)
-{
- push_back(Xyz);
-
- if (size() == 1)
- {
- MinX = Xyz->X;
- MaxX = Xyz->X;
- MinY = Xyz->Y;
- MaxY = Xyz->Y;
- }
- else
- {
- if (MinX > Xyz->X) MinX = Xyz->X;
- if (MaxX < Xyz->X) MaxX = Xyz->X;
- if (MinY > Xyz->Y) MinY = Xyz->Y;
- if (MaxY < Xyz->Y) MaxY = Xyz->Y;
- }
-}
-
-//---------------------------------------------------------------------
-void TXYZList::Add(double X, double Y, double Z)
-{
- TXYZ *Xyz = new TXYZ(X, Y, Z);
- Add(Xyz);
-}
-
-//---------------------------------------------------------------------
// TNodeList
//---------------------------------------------------------------------
@@ -808,7 +624,9 @@
{
TNode* Node = *i;
- if (Node->X == X && Node->Y == Y)
+ double NDx = X - Node->X;
+ double NDy = Y - Node->Y;
+ if (fabs(NDx) < 0.01 && fabs(NDy) < 0.01)
{
*ZWert = Node->Z;
*WspWert = Node->Wsp;
@@ -1029,17 +847,14 @@
}
//---------------------------------------------------------------------
-double TNodeList::GetMaxDepth(bool Debug)
+double TNodeList::GetMaxDepth(int DebugLevel)
{
- write_fortschritt("->Maximale Wassertiefe wird ermittelt\n");
+ write_fortschritt("->Ermittlung der maximalen Wassertiefe gestartet\n");
double MaxDepth = 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;
@@ -1054,28 +869,30 @@
if (Count == 0 || Depth > MaxDepth) MaxDepth = Depth;
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
+ {
+ write_fortschritt("Knoten %d von %d untersucht.\n", Count, size());
+ }
}
- write_fortschritt("Knoten %d von %d wird untersucht.\n", Count, size());
+ write_fortschritt("Knoten %d von %d untersucht.\n", Count, size());
write_fortschritt("Maximale Wassertiefe: %.3f.\n", MaxDepth);
- write_fortschritt("Maximale Wassertiefe ermittelt\n");
+ write_fortschritt("<-Ermittlung der maximalen Wassertiefe beendet\n");
return (MaxDepth);
}
//---------------------------------------------------------------------
-double TNodeList::GetMaxWsp(bool Debug)
+double TNodeList::GetMaxWsp(int DebugLevel)
{
- write_fortschritt("->Maximaler Wasserstand wird ermittelt\n");
+ write_fortschritt("->Ermittlung des maximalen Wasserstandes gestartet\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;
@@ -1090,28 +907,30 @@
if (Count == 0 || Wsp > MaxWsp) MaxWsp = Wsp;
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
+ {
+ write_fortschritt("Knoten %d von %d untersucht.\n", Count, size());
+ }
}
- write_fortschritt("Knoten %d von %d wird untersucht.\n", Count, size());
+ write_fortschritt("Knoten %d von %d untersucht.\n", Count, size());
write_fortschritt("Maximaler Wasserstand: %.3f.\n", MaxWsp);
- write_fortschritt("Maximaler Wasserstand ermittelt\n");
+ write_fortschritt("<-Ermittlung des maximalen Wasserstandes beendet\n");
return (MaxWsp);
}
//---------------------------------------------------------------------
-double TNodeList::GetMaxZ(bool Debug)
+double TNodeList::GetMaxZ(int DebugLevel)
{
- write_fortschritt("->Maximale Geländehöhe wird ermittelt\n");
+ write_fortschritt("->Ermittlung der maximale Geländehöhe gestartet\n");
double MaxZ = 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;
double Z = Node->Z;
@@ -1119,12 +938,17 @@
if (Count == 0 || Z > MaxZ) MaxZ = Z;
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 10000 == 0) || (Count > 0 && Count % 100000 == 0))
+ {
+ write_fortschritt("Knoten %d von %d untersucht.\n", Count, size());
+ }
}
- write_fortschritt("Knoten %d von %d wird untersucht.\n", Count, size());
+ write_fortschritt("Knoten %d von %d untersucht.\n", Count, size());
write_fortschritt("Maximale Geländehöhe: %.3f.\n", MaxZ);
- write_fortschritt("Maximale Geländehöhe ermittelt\n");
+ write_fortschritt("<-Ermittlung der maximale Geländehöhe beendet\n");
return (MaxZ);
}
@@ -1150,23 +974,33 @@
}
//---------------------------------------------------------------------------
-void TElementList::ChangeElements(TNodeList *NodeList, TProfilList *SperrenList, TProfilList *BruchList, int DebugLevel)
+void TElementList::ChangeElements(TNodeList *NodeList, TProfilList *SperrenList, TProfilList *GrabenList, int DebugLevel)
{
- write_fortschritt("->Elemente werden an Sperren und Brüche angepasst\n");
+ write_fortschritt("->Anpassung der Elemente an Sperren und Gräben gestartet\n");
- write_fortschritt("->Elemente werden an Sperren\n");
+ write_fortschritt("->Ermittlung der größten Knotenummer gestartet\n");
+ int MaxNodeNr = 0;
+ for (TNodeList::iterator i=NodeList->begin(); i!=NodeList->end(); i++)
+ {
+ TNode* Node = *i;
+ if (MaxNodeNr < Node->Nr) MaxNodeNr = Node->Nr;
+ }
+ write_fortschritt("<-Ermittlung der größten Knotenummer beendet\n");
+
+ write_fortschritt("->Anpassung der Elemente an Sperren gestartet\n");
+
int ChangeCount = 0;
- double SperrZ = 9999.9;
- double BruchZ = -9999.9;
+ double SperrZ = 9999.9;
+ double GrabenZ = -9999.9;
int Count = 0;
for (TElementList::iterator i = begin(); i != end(); i++)
{
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 1000 == 0) || (Count > 0 && Count % 10000 == 0))
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 5000 == 0) || (Count > 0 && Count % 50000 == 0))
{
- write_fortschritt("%d von %d Elemente auf Sperren getestet, %d Elemente angepasst\n", Count, size(), ChangeCount);
+ write_fortschritt("%d von %d Elemente, %d Elemente angepasst\n", Count, size(), ChangeCount);
}
TElement* Element = *i;
@@ -1187,6 +1021,13 @@
double X = 0.0;
double Y = 0.0;
+ double N12Dx = Node2->X - Node1->X;
+ double N12Dy = Node2->Y - Node1->Y;
+ if (fabs(N12Dx) < 0.00000001 && fabs(N12Dy) < 0.00000001)
+ {
+ write_error(3214, "Knotenabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Node1->X, Node1->Y, Node2->X, Node2->Y);
+ }
+
if (CalcProfilSchnitt(Node1->X, Node1->Y, Node2->X, Node2->Y, SperrenList, &X, &Y, &Lambda, &Meter))
{
if (fabs(Node1->X - X) < 0.1 && fabs(Node1->Y - Y) < 0.1)
@@ -1201,7 +1042,7 @@
}
else
{
- TNode* Node = new TNode(NodeList->size()+1, X, Y, SperrZ);
+ TNode* Node = new TNode(++MaxNodeNr, X, Y, SperrZ);
NodeList->push_back(Node);
NewElement = new TElement(Node1, Node, Node3);
@@ -1218,6 +1059,13 @@
}
}
+ double N23Dx = Node3->X - Node2->X;
+ double N23Dy = Node3->Y - Node2->Y;
+ if (fabs(N23Dx) < 0.00000001 && fabs(N23Dy) < 0.00000001)
+ {
+ write_error(3214, "Knotenabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Node2->X, Node2->Y, Node3->X, Node3->Y);
+ }
+
if (CalcProfilSchnitt(Node2->X, Node2->Y, Node3->X, Node3->Y, SperrenList, &X, &Y, &Lambda, &Meter))
{
if (fabs(Node2->X - X) < 0.1 && fabs(Node2->Y - Y) < 0.1)
@@ -1232,7 +1080,7 @@
}
else
{
- TNode* Node = new TNode(NodeList->size()+1, X, Y, SperrZ);
+ TNode* Node = new TNode(++MaxNodeNr, X, Y, SperrZ);
NodeList->push_back(Node);
NewElement = new TElement(Node2, Node, Node1);
@@ -1249,6 +1097,13 @@
}
}
+ double N31Dx = Node1->X - Node3->X;
+ double N31Dy = Node1->Y - Node3->Y;
+ if (fabs(N31Dx) < 0.00000001 && fabs(N31Dy) < 0.00000001)
+ {
+ write_error(3214, "Knotenabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Node3->X, Node3->Y, Node1->X, Node1->Y);
+ }
+
if (CalcProfilSchnitt(Node3->X, Node3->Y, Node1->X, Node1->Y, SperrenList, &X, &Y, &Lambda, &Meter))
{
if (fabs(Node3->X - X) < 0.1 && fabs(Node3->Y - Y) < 0.1)
@@ -1263,7 +1118,7 @@
}
else
{
- TNode* Node = new TNode(NodeList->size()+1, X, Y, SperrZ);
+ TNode* Node = new TNode(++MaxNodeNr, X, Y, SperrZ);
NodeList->push_back(Node);
NewElement = new TElement(Node3, Node, Node2);
@@ -1282,17 +1137,18 @@
Count++;
}
- write_fortschritt("%d von %d Elemente auf Sperren getestet, %d Elemente geändert\n", Count, size(), ChangeCount);
- write_fortschritt("Elemente wurden an Sperren angepasst\n");
+ write_fortschritt("%d von %d Elemente, %d Elemente geändert\n", Count, size(), ChangeCount);
- write_fortschritt("->Elemente werden an Brüche angepasst\n");
+ write_fortschritt("<-Anpassung der Elemente an Sperren beendet\n");
+ write_fortschritt("->Anpassung der Elemente an Gräben gestartet\n");
+
Count = 0;
for (TElementList::iterator i = begin(); i != end(); i++)
{
- if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 1000 == 0) || (Count > 0 && Count % 10000 == 0))
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 5000 == 0) || (Count > 0 && Count % 50000 == 0))
{
- write_fortschritt("%d von %d Elemente auf Brüche getestet, %d Elemente geändert\n", Count, size(), ChangeCount);
+ write_fortschritt("%d von %d Elemente, %d Elemente geändert\n", Count, size(), ChangeCount);
}
TElement* Element = *i;
@@ -1313,21 +1169,28 @@
double X = 0.0;
double Y = 0.0;
- if (CalcProfilSchnitt(Node1->X, Node1->Y, Node2->X, Node2->Y, BruchList, &X, &Y, &Lambda, &Meter))
+ double N12Dx = Node2->X - Node1->X;
+ double N12Dy = Node2->Y - Node1->Y;
+ if (fabs(N12Dx) < 0.00000001 && fabs(N12Dy) < 0.00000001)
{
+ write_error(3214, "Knotenabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Node1->X, Node1->Y, Node2->X, Node2->Y);
+ }
+
+ if (CalcProfilSchnitt(Node1->X, Node1->Y, Node2->X, Node2->Y, GrabenList, &X, &Y, &Lambda, &Meter))
+ {
if (fabs(Node1->X - X) < 0.1 && fabs(Node1->Y - Y) < 0.1)
{
- Node1->Z = BruchZ;
+ Node1->Z = GrabenZ;
if (DebugLevel >= 8) write_fortschritt("Knoten %d wird abgesenkt (Lambda = %.5f)\n", Node1->Nr, Lambda);
}
else if (fabs(Node2->X - X) < 0.1 && fabs(Node2->Y - Y) < 0.1)
{
- Node2->Z = BruchZ;
+ Node2->Z = GrabenZ;
if (DebugLevel >= 8) write_fortschritt("Knoten %d wird abgesenkt (Lambda = %.5f)\n", Node2->Nr, Lambda);
}
else
{
- TNode* Node = new TNode(NodeList->size()+1, X, Y, BruchZ);
+ TNode* Node = new TNode(++MaxNodeNr, X, Y, GrabenZ);
NodeList->push_back(Node);
NewElement = new TElement(Node1, Node, Node3);
@@ -1344,21 +1207,28 @@
}
}
- if (CalcProfilSchnitt(Node2->X, Node2->Y, Node3->X, Node3->Y, BruchList, &X, &Y, &Lambda, &Meter))
+ double N23Dx = Node3->X - Node2->X;
+ double N23Dy = Node3->Y - Node2->Y;
+ if (fabs(N23Dx) < 0.00000001 && fabs(N23Dy) < 0.00000001)
{
+ write_error(3214, "Knotenabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Node2->X, Node2->Y, Node3->X, Node3->Y);
+ }
+
+ if (CalcProfilSchnitt(Node2->X, Node2->Y, Node3->X, Node3->Y, GrabenList, &X, &Y, &Lambda, &Meter))
+ {
if (fabs(Node2->X - X) < 0.1 && fabs(Node2->Y - Y) < 0.1)
{
- Node2->Z = BruchZ;
+ Node2->Z = GrabenZ;
if (DebugLevel >= 8) write_fortschritt("Knoten %d wird abgesenkt (Lambda = %.5f)\n", Node2->Nr, Lambda);
}
else if (fabs(Node3->X - X) < 0.1 && fabs(Node3->Y - Y) < 0.1)
{
- Node3->Z = BruchZ;
+ Node3->Z = GrabenZ;
if (DebugLevel >= 8) write_fortschritt("Knoten %d wird erhöht (Lambda = %.5f)\n", Node3->Nr, Lambda);
}
else
{
- TNode* Node = new TNode(NodeList->size()+1, X, Y, BruchZ);
+ TNode* Node = new TNode(++MaxNodeNr, X, Y, GrabenZ);
NodeList->push_back(Node);
NewElement = new TElement(Node2, Node, Node1);
@@ -1375,21 +1245,28 @@
}
}
- if (CalcProfilSchnitt(Node3->X, Node3->Y, Node1->X, Node1->Y, BruchList, &X, &Y, &Lambda, &Meter))
+ double N31Dx = Node1->X - Node3->X;
+ double N31Dy = Node1->Y - Node3->Y;
+ if (fabs(N31Dx) < 0.00000001 && fabs(N31Dy) < 0.00000001)
{
+ write_error(3214, "Knotenabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", Node3->X, Node3->Y, Node1->X, Node1->Y);
+ }
+
+ if (CalcProfilSchnitt(Node3->X, Node3->Y, Node1->X, Node1->Y, GrabenList, &X, &Y, &Lambda, &Meter))
+ {
if (fabs(Node3->X - X) < 0.1 && fabs(Node3->Y - Y) < 0.1)
{
- Node3->Z = BruchZ;
+ Node3->Z = GrabenZ;
if (DebugLevel >= 8) write_fortschritt("Knoten %d wird abgesenkt (Lambda = %.5f)\n", Node3->Nr, Lambda);
}
else if (fabs(Node1->X - X) < 0.1 && fabs(Node1->Y - Y) < 0.1)
{
- Node1->Z = BruchZ;
+ Node1->Z = GrabenZ;
if (DebugLevel >= 8) write_fortschritt("Knoten %d wird abgesenkt (Lambda = %.5f)\n", Node1->Nr, Lambda);
}
else
{
- TNode* Node = new TNode(NodeList->size()+1, X, Y, BruchZ);
+ TNode* Node = new TNode(++MaxNodeNr, X, Y, GrabenZ);
NodeList->push_back(Node);
NewElement = new TElement(Node3, Node, Node2);
@@ -1408,10 +1285,11 @@
Count++;
}
- write_fortschritt("%d von %d Elemente auf Brüche getestet, %d Elemente geändert\n", Count, size(), ChangeCount);
- write_fortschritt("Elemente wurden an Brüche angepasst\n");
+ write_fortschritt("%d von %d, %d Elemente geändert\n", Count, size(), ChangeCount);
- write_fortschritt("Elemente wurden an Sperren und Brüche angepasst\n");
+ write_fortschritt("<-Anpassung der Elemente an Gräben beendet\n");
+
+ write_fortschritt("<-Anpassung der Elemente an Sperren und Gräben beendet\n");
}
//---------------------------------------------------------------------
@@ -1532,19 +1410,6 @@
Node1 = node1;
Node2 = node2;
-/*
- if (node1->Nr < node2->Nr)
- {
- Node1 = node1;
- Node2 = node2;
- }
- else
- {
- Node1 = node2;
- Node2 = node1;
- }
-*/
-
double Dx = Node2->X - Node1->X;
double Dy = Node2->Y - Node1->Y;
Distance = sqrt (Dx*Dx +Dy*Dy);
@@ -1678,7 +1543,10 @@
Anz = EdgeListNrSorted.size();
}
- EdgeListDistanceSorted.insert(edge);
+ else
+ {
+ EdgeListDistanceSorted.insert(edge);
+ }
}
//---------------------------------------------------------------------
@@ -1767,6 +1635,15 @@
}
//---------------------------------------------------------------------
+void TEdgeList::EraseWithIndex(TEdge* edge)
+{
+ edge->Node1->EraseEdgeIndex(edge);
+ edge->Node2->EraseEdgeIndex(edge);
+
+ Erase(edge);
+}
+
+//---------------------------------------------------------------------
TEdge* TEdgeList::Find(TEdge *edge)
{
if (Anz == 0) return(0);
@@ -1776,6 +1653,29 @@
TEdge *Edge = 0;
if (NrIt != EdgeListNrSorted.end()) Edge = *NrIt;
+/*
+ for (TEdgeListNrSorted::iterator i=EdgeListNrSorted.begin(); i!=EdgeListNrSorted.end(); i++)
+ {
+ TEdge* TestEdge = *i;
+
+ if (0 == Edge && edge->Node1->Nr == TestEdge->Node1->Nr && edge->Node2->Nr == TestEdge->Node2->Nr)
+ {
+ TEdgeListNrSorted::iterator NrIt = EdgeListNrSorted.find(edge);
+ for (TEdgeListNrSorted::iterator j=EdgeListNrSorted.begin(); j!=EdgeListNrSorted.end(); j++)
+ {
+ TEdge* E = *j;
+ write_fortschritt("E %d - %d\n", E->Node1->Nr, E->Node2->Nr);
+ }
+ }
+ }
+
+ if (Edge && (Edge->Node1->Nr != edge->Node1->Nr || Edge->Node2->Nr != edge->Node2->Nr))
+ {
+ TEdgeListNrSorted::iterator NrIt = EdgeListNrSorted.find(edge);
+ write_warning(9999, "Kante %d - %d gefunden\n", edge->Node1->Nr, edge->Node2->Nr);
+ }
+*/
+
return (Edge);
}
@@ -1915,7 +1815,15 @@
TPoint* NewPoint = new TPoint(X, Y, 0.0, meter);
+ unsigned int Anz = PointList->size();
+
PointList->insert(NewPoint);
+
+ // Wenn sich die Anzahl nicht erhöht hat,
+ // so wurde der Punkt auch nicht hinzugefügt
+ // -> er muss wieder gelöscht werden
+
+ if (PointList->size() == Anz) delete NewPoint;
}
//---------------------------------------------------------------------
@@ -2141,6 +2049,18 @@
double P1x = P1->X;
double P1y = P1->Y;
+ if (P0x < GewaesserAchse->MinX && P1x < GewaesserAchse->MinX) return (false);
+ if (P0x > GewaesserAchse->MaxX && P1x > GewaesserAchse->MaxX) return (false);
+ if (P0y < GewaesserAchse->MinY && P1y < GewaesserAchse->MinY) return (false);
+ if (P0y > GewaesserAchse->MaxY && P1y > GewaesserAchse->MaxY) return (false);
+
+ double PDx = P1x - P0x;
+ double PDy = P1y - P0y;
+ if (fabs(PDx) < 0.00000001 && fabs(PDy) < 0.00000001)
+ {
+ write_error(3207, "Profil-Punktabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", P0x, P0y, P1x, P1y);
+ }
+
// Es heisst hier s für spur und nicht g für gewässerachse
TPoint*S0 = 0;
@@ -2163,6 +2083,13 @@
double S1x = S1->X;
double S1y = S1->Y;
+ double SDx = S1x - S0x;
+ double SDy = S1y - S0y;
+ if (fabs(SDx) < 0.00000001 && fabs(SDy) < 0.00000001)
+ {
+ write_error(3208, "Gewässerachsen-Stützpunkteabstand (%.3f %.3f) - (%.3f %.3f) ist zu klein\n", S0x, S0y, S1x, S1y);
+ }
+
double X, Y, LambdaP, LambdaS;
bool Found = Calc2Schnitt(P0x, P0y, P1x, P1y, S0x, S0y, S1x, S1y, &X, &Y, &LambdaP, &LambdaS);
@@ -2223,8 +2150,10 @@
//---------------------------------------------------------------------
void TProfilList::InterpoliereProfile(double SollAbstand)
{
- write_fortschritt("->Interpoliere Profile\n");
+ write_fortschritt("->Interpolation der Profile gestartet\n");
+ write_fortschritt("Gewünschter Abstand der Profile: %.4f\n", SollAbstand);
+
TProfil *FirstProfil = 0;
TProfil *NextProfil = 0;
@@ -2255,6 +2184,14 @@
FirstProfilNeu->EqualizeProfil(NextProfil);
NextProfilNeu->EqualizeProfil(FirstProfil);
+ unsigned int Anz1 = FirstProfilNeu->PointList->size();
+ unsigned int Anz2 = NextProfilNeu->PointList->size();
+
+ if (Anz1 != Anz2)
+ {
+ dump_error(__FILE__, __LINE__, "Angeglichene Profile sind nicht identisch\n");
+ }
+
for (int j=1; j<=Anz; j++)
{
double Prozent = j * Abstand / Diff;
@@ -2280,22 +2217,19 @@
NewProfilList->clear();
delete NewProfilList;
- write_fortschritt("Profile interpoliert\n");
+ write_fortschritt("<-Interpolation der Profile beendet\n");
}
//---------------------------------------------------------------------
-void TProfilList::FillProfile(double SollAbstand, int SollAnz, bool Debug)
+void TProfilList::FillProfile(double SollAbstand, int SollAnz, int DebugLevel)
{
- write_fortschritt("->Die Profile werden mit Stützstellen aufgefüllt\n");
+ write_fortschritt("->Auffüllen der Profile mit Stützstellen gestartet\n");
double Abstand = 1.0;
int Count = 0;
for (iterator i = begin(); i != end(); i++)
{
- if (Debug && Count % 100 == 0) write_fortschritt("Profil %d von %d wird aufgefüllt.\n", Count, size());
- else if (Count % 1000 == 0) write_fortschritt("Profil %d von %d wird aufgefüllt.\n", Count, size());
-
TProfil* Profil = *i;
TPoint* LastPoint = *Profil->PointList->rbegin();
@@ -2343,12 +2277,18 @@
j = Profil->PointList->begin();
}
}
+
Count++;
+
+ if (DebugLevel >= 9 || (DebugLevel >= 1 && Count % 500 == 0) || (Count > 0 && Count % 5000 == 0))
+ {
+ write_fortschritt("Profil %d von %d aufgefüllt\n", Count, size());
+ }
}
- write_fortschritt("Profil %d von %d wurde aufgefüllt.\n", Count, size());
+ write_fortschritt("Profil %d von %d aufgefüllt\n", Count, size());
- write_fortschritt("Die Profile wurden mit Stützstellen aufgefüllt\n");
+ write_fortschritt("<-Auffüllen der Profile mit Stützstellen beendet\n");
}
//---------------------------------------------------------------------
@@ -2410,6 +2350,10 @@
{
Gewaesser = gewaesser;
ID = id;
+ MinX = 99999999.9;
+ MaxX = -99999999.9;
+ MinY = 99999999.9;
+ MaxY = -99999999.9;
PointList = 0;
}
@@ -2420,6 +2364,11 @@
Gewaesser = gewaesserAchse->Gewaesser;
ID = gewaesserAchse->ID;
+ MinX = 99999999.9;
+ MaxX = -99999999.9;
+ MinY = 99999999.9;
+ MaxY = -99999999.9;
+
PointList = new TPointList;
for (TPointList::iterator i=gewaesserAchse->PointList->begin(); i != gewaesserAchse->PointList->end(); i++)
{
@@ -2428,6 +2377,21 @@
TPoint *NewPoint = new TPoint(OldPoint);
PointList->insert(NewPoint);
+
+ if (i == gewaesserAchse->PointList->begin())
+ {
+ MinX = NewPoint->X;
+ MaxX = NewPoint->X;
+ MinY = NewPoint->Y;
+ MaxY = NewPoint->Y;
+ }
+ else
+ {
+ if (MinX > NewPoint->X) MinX = NewPoint->X;
+ if (MaxX < NewPoint->X) MaxX = NewPoint->X;
+ if (MinY > NewPoint->Y) MinY = NewPoint->Y;
+ if (MaxY < NewPoint->Y) MaxY = NewPoint->Y;
+ }
}
}
@@ -2445,6 +2409,10 @@
delete PointList;
}
+ MinX = 99999999.9;
+ MaxX = -99999999.9;
+ MinY = 99999999.9;
+ MaxY = -99999999.9;
}
//---------------------------------------------------------------------
@@ -2459,6 +2427,11 @@
TPoint* NewPoint = new TPoint(X, Y, 0.0, meter);
PointList->insert(NewPoint);
+
+ if (MinX > NewPoint->X) MinX = NewPoint->X;
+ if (MaxX < NewPoint->X) MaxX = NewPoint->X;
+ if (MinY > NewPoint->Y) MinY = NewPoint->Y;
+ if (MaxY < NewPoint->Y) MaxY = NewPoint->Y;
}
//---------------------------------------------------------------------
@@ -2494,6 +2467,11 @@
TPoint* NewPoint = new TPoint(x, y, z, Meter);
PointList->insert(NewPoint);
+
+ if (MinX > NewPoint->X) MinX = NewPoint->X;
+ if (MaxX < NewPoint->X) MaxX = NewPoint->X;
+ if (MinY > NewPoint->Y) MinY = NewPoint->Y;
+ if (MaxY < NewPoint->Y) MaxY = NewPoint->Y;
}
//---------------------------------------------------------------------
@@ -2620,4 +2598,3 @@
return (0);
}
-
Modified: trunk/src/xy.h
===================================================================
--- trunk/src/xy.h 2006-05-07 19:02:03 UTC (rev 47)
+++ trunk/src/xy.h 2006-05-11 21:32:40 UTC (rev 48)
@@ -36,18 +36,41 @@
typedef enum { NOT_INSIDE, INSIDE, ON_LINE, UNDEFINED } TInsideTyp;
//----------------------------------------------------------------------------
+class TXY;
+class TNode;
+class TPoint;
+class TPointCompMeter;
+// typedef set TPointList;
+class TElement;
class TEdge;
class TEdgeIndex;
+// template class TXYKombiIndex;
class TXYList;
-class TXYZList;
+class TErgebnisPolygon;
class TNodeList;
+class TElementList;
+class TEdgeCompNr;
+class TEdgeCompdistance;
+class TEdgeList;
+class TErgebnisPolygonList;
+class TEdgeIndex;
+class TProfil;
+class TProfilCompStation;
class TProfilList;
+// typedef TProfilMap
+class TBereichCompStation;
+class TBereichsList;
+class TGewaesserAchse;
+class TGewaesserAchseComp;
class TGewaesserAchseList;
//----------------------------------------------------------------------------
static const unsigned int MaxXYKombiIndexAnzahlKonst = 10;
//----------------------------------------------------------------------------
+// TXY wird für Stützstellen von Polygonen, Knoten und Profilspuren benötigt.
+// Hier werden reine X,Y-Koordinaten gespeichert.
+//----------------------------------------------------------------------------
class TXY
{
public:
@@ -65,23 +88,15 @@
};
//----------------------------------------------------------------------------
-class TXYZ : public TXY
-{
- public:
-
- double Z;
-
- TXYZ(double X, double Y);
- TXYZ(double X, double Y, double Z);
- TXYZ(TXYZ *Xyz);
-};
-
+// TNode wird für die Knoten in vermaschten Netzen genutzt
+// Die Speicherung erfolgt im Allgemeinen in einer TNodeList
//----------------------------------------------------------------------------
-class TNode : public TXYZ
+class TNode : public TXY
{
public:
int Nr;
- double Wsp;
+ double Z;
+ double Wsp;
TEdgeIndex *EdgeIndex;
TNode(int Nr, double X, double Y, double Z);
@@ -95,9 +110,13 @@
//----------------------------------------------------------------------------
-class TPoint : public TXYZ
+// TPoint wird für die Stützstellen von Profilspuren und anderen Spuren genutzt,
+// die interpoliert oder verdichtet werden sollen.
+//----------------------------------------------------------------------------
+class TPoint : public TXY
{
public:
+ double Z;
double Meter;
TPoint(double X, double Y, double Meter);
@@ -106,19 +125,34 @@
};
//----------------------------------------------------------------------------
+// Hilfsklasse für das automatische Sortieren von 'Points' nach Metern
+// Wird von der TPointList benötigt
+//----------------------------------------------------------------------------
class TPointCompMeter
{
public:
bool operator()(TPoint* const &Point1, TPoint* const &Point2) const
{
- return (Point1->Meter < Point2->Meter);
+ return (Point1->Meter < Point2->Meter - 0.01);
}
};
//----------------------------------------------------------------------------
+// Hier werden die TPoints drin verwaltet
+// durch die Verwendung von 'set' ist immer gewährleistet, dass keine Punkte doppelt
+// sind und die Punkte immer nach Metern sortiert sind
+//----------------------------------------------------------------------------
typedef std::set<TPoint *, TPointCompMeter> TPointList;
//----------------------------------------------------------------------------
+// Diese Klasse speichert Drei- oder Vierecke (wobei die Vierecke noch nicht
+// überall im Programm unterstützt werden
+// Schön wäre es, wenn man diese Klasse komplett wegoptimieren würde
+//
+// !!! Achtung !!! Die Pointer auf die Knoten sind nur geliehen.
+// Der Speicher der Knoten wird über eine TNodeList verwaltet und darf nicht
+// von TElement freigegeben werden.
+//----------------------------------------------------------------------------
class TElement
{
public:
@@ -134,6 +168,12 @@
};
//----------------------------------------------------------------------------
+// TEdge dient dem Verwalten von Kanten
+//
+// !!! Achtung !!! Die Pointer auf die Knoten sind nur geliehen.
+// Der Speicher der Knoten wird über eine TNodeList verwaltet und darf nicht
+// von TEdge freigegeben werden.
+//----------------------------------------------------------------------------
class TEdge
{
public:
@@ -151,6 +191,11 @@
};
//----------------------------------------------------------------------------
+// Dieses Template dient dem schnellen Zugriff auf Punkte mit X,Y-Koordinaten
+// Es wird bei Knoten (TNode) und einfache Stützstellen (TXY) verwendet
+// Das Template setzt voraus, dass es ein Feld gibt das nach XYKombi-Werten sortiert ist.
+// Dieses Feld wird indiziert (Build) und schnell abgefragt (Search und SearchAll)
+//----------------------------------------------------------------------------
template <class TXyList, class TXy> class TXYKombiIndex
{
public:
@@ -376,6 +421,8 @@
};
//----------------------------------------------------------------------------
+// TXYList verwaltet die TXY
+//----------------------------------------------------------------------------
class TXYList : public std::vector<TXY *>
{
private:
@@ -400,6 +447,8 @@
};
//----------------------------------------------------------------------------
+// Ein spezielles Polygon zum Speichern der Ergebnispolygone der Nass/Trockenberechnung
+//----------------------------------------------------------------------------
class TErgebnisPolygon : public TXYList
{
public:
@@ -412,29 +461,8 @@
};
//----------------------------------------------------------------------------
-class TXYZList : public std::vector<TXYZ *>
-{
- private:
- TXYKombiIndex<TXYZList, TXYZ> *XYKombiIndex;
-
- public:
- double MinX;
- double MaxX;
- double MinY;
- double MaxY;
-
- TXYZList(void);
- ~TXYZList(void);
- void Clear(void);
- TXYZList* Copy(void);
-
- void Add(TXYZ *Xyz);
- void Add(double X, double Y, double Z);
- void SortByXY(void);
- TXYZ* FindByXY(double X, double Y, double Eps = 0.01);
- TInsideTyp IsInsideXYZList(double X, double Y);
-};
-
+// TnodeList dient zum Verwalten der Knoten (TNode)
+// Nur TNodeList gibt den Speicher für die Knoten wieder frei
//----------------------------------------------------------------------------
class TNodeList : public std::vector<TNode *>
{
@@ -455,12 +483,14 @@
TNode* FindByNr(int Nr);
bool Interpolate(TProfilList* SperrenList, double X, double Y, double R, double *Z, double *Wsp);
void ClearEdgeIndex(void);
- double GetMaxDepth(bool Debug);
- double GetMaxWsp(bool Debug);
- double GetMaxZ(bool Debug);
+ double GetMaxDepth(int DebugLevel);
+ double GetMaxWsp(int DebugLevel);
+ double GetMaxZ(int DebugLevel);
};
//----------------------------------------------------------------------------
+// TElementList verwaltet die Elemente (TElement)
+//----------------------------------------------------------------------------
class TElementList : public std::vector<TElement *>
{
public:
@@ -471,6 +501,8 @@
//----------------------------------------------------------------------------
+// Hilfsfunktion zum automatischen Sortieren der Kanten nach Nummern
+//----------------------------------------------------------------------------
class TEdgeCompNr
{
public:
@@ -485,6 +517,8 @@
};
//----------------------------------------------------------------------------
+// Hilfsfunktion zum automatischen Sortieren der Kanten nach Längen
+//----------------------------------------------------------------------------
class TEdgeCompDistance
{
public:
@@ -501,16 +535,25 @@
};
//----------------------------------------------------------------------------
+// Ein 'set', das die Kanten nach Nummern sortiert speichert
+//----------------------------------------------------------------------------
typedef std::set<TEdge *, TEdgeCompNr> TEdgeListNrSorted;
//----------------------------------------------------------------------------
+// Ein 'set', das die Kanten nach Längen sortiert speichert
+//----------------------------------------------------------------------------
typedef std::set<TEdge *, TEdgeCompDistance> TEdgeListDistanceSorted;
//----------------------------------------------------------------------------
+// Die EdgeList besteht aus zwei internen 'sets', die für einen schnellen
+// Zugriff auf die Kanten dienen
+//----------------------------------------------------------------------------
class TEdgeList
{
private:
// Diese beiden Knoten und die Kante dienen nur als Hüllen für das Suchen
+ // damit das aufrufende Programm sich nicht erst immer wieder Speicher holen muss
+ // und intern immer die gleichen Suchroutinen benutzt werden können
TNode *SearchNode1;
TNode *SearchNode2;
TEdge *SearchEdge;
@@ -536,12 +579,15 @@
TEdge* Find(TNode *Node1, TNode *Node2);
TEdge* FindWithIndex(TNode *Node1, TNode *Node2);
void Erase(TEdge *Edge);
+ void EraseWithIndex(TEdge *Edge);
void BuildDistanceSortedList(void);
void BuildEdgeIndex(void);
};
//----------------------------------------------------------------------------
+// List von Ergebnispolygonen
+//----------------------------------------------------------------------------
class TErgebnisPolygonList : public std::vector<TErgebnisPolygon *>
{
public:
@@ -554,6 +600,9 @@
};
//----------------------------------------------------------------------------
+// Dieser Index schafft eine Schnelle Verbindung zwischen Knoten und
+// Kanten (genau in diese Richtung und nicht von Kanten zu Knoten)
+//----------------------------------------------------------------------------
class TEdgeIndex
{
public:
@@ -564,6 +613,10 @@
};
//----------------------------------------------------------------------------
+// Hier werden Linienobjekte gespeichert
+// Profile, aber auch Sperren und Brüche
+// und kurzfristig auch mal Wasserstände
+//----------------------------------------------------------------------------
class TProfil
{
public:
@@ -590,6 +643,8 @@
};
//----------------------------------------------------------------------------
+// Hilfsklasse zum automatischen Sortieren nach Stationen (Flusskilometern)
+//----------------------------------------------------------------------------
class TProfilCompStation
{
public:
@@ -602,6 +657,8 @@
};
//----------------------------------------------------------------------------
+// TProfilList verwaltet die Profile (TProfil)
+//----------------------------------------------------------------------------
class TProfilList : public std::set<TProfil *, TProfilCompStation>
{
public:
@@ -610,13 +667,19 @@
void Clear(void);
TProfil* Find(std::string Gewaesser, int Station);
void InterpoliereProfile(double SollAbstand);
- void FillProfile(double SollAbstand, int SollAnz, bool Debug);
- double GetMaxWsp(bool Debug);
+ void FillProfile(double SollAbstand, int SollAnz, int DebugLevel);
+ double GetMaxWsp(int DebugLevel);
};
+//----------------------------------------------------------------------------
+// TProfilMap trennt die Profile nach Gewässern und benutzt die
+// Standardsortierung von std::string
+//----------------------------------------------------------------------------
typedef std::map<std::string, TProfilList *> TProfilMap;
//----------------------------------------------------------------------------
+// Hilfsklasse für die Sortierung von Bearbeitungsbereichen
+//----------------------------------------------------------------------------
class TBereichCompStation
{
public:
@@ -629,6 +692,8 @@
};
//----------------------------------------------------------------------------
+// Hier werden die Profile den Bereich zu geordnet
+//----------------------------------------------------------------------------
class TBereichsList : public std::map<TProfilList::iterator, TProfilList::iterator, TBereichCompStation>
{
private:
@@ -639,11 +704,18 @@
};
//----------------------------------------------------------------------------
+// Hier wird eine Gewaesserachse gespeichert
+// Eine Punktliste und ein paar Zusatzinformationen
+//----------------------------------------------------------------------------
class TGewaesserAchse
{
public:
std::string Gewaesser;
int ID;
+ double MinX;
+ double MaxX;
+ double MinY;
+ double MaxY;
TPointList* PointList;
@@ -660,6 +732,8 @@
};
//----------------------------------------------------------------------------
+// Hilfsklasse für das automatische Sortieren der Gewässerachsen
+//----------------------------------------------------------------------------
class TGewaesserAchseComp
{
public:
@@ -672,13 +746,15 @@
};
//----------------------------------------------------------------------------
+// Hier werden die Gewässerachsen drin verwaltet
+//----------------------------------------------------------------------------
class TGewaesserAchseList : public std::set<TGewaesserAchse *, TGewaesserAchseComp>
{
public:
- ~TGewaesserAchseList(void);
+ ~TGewaesserAchseList(void);
- void Clear(void);
- TGewaesserAchse* Find(std::string Gewaesser, int ID);
+ void Clear(void);
+ TGewaesserAchse* Find(std::string Gewaesser, int ID);
};
#endif
More information about the Wsplgen-commits
mailing list