3168 lines
127 KiB
C++
Executable File
3168 lines
127 KiB
C++
Executable File
/* --------------------------------------------------------------------
|
|
// $HeadURL$
|
|
// --------------------------------------------------------------------
|
|
//!
|
|
// --------------------------------------------------------------------
|
|
// COPYRIGHT (C) 1999: STN ATLAS ELEKTRONIK GMBH, D-28305 BREMEN
|
|
// --------------------------------------------------------------------
|
|
//
|
|
// HIER/ITEM : CSU: RP 5182 P 005 SRC 01103
|
|
// BRIEF DESC: Funktionalitaet Minengenerator
|
|
// AUTHOR : Ingo Kannetzky
|
|
// RELEASE :
|
|
// MODIF/STAT: 29.02.00
|
|
// ORIGIN REF:
|
|
//
|
|
// Revision INFO:
|
|
// --------------
|
|
// $Revision$
|
|
// $Date$
|
|
// $Id$
|
|
//
|
|
// LANGUAGE: C++ (Compiler: XXX Version: XXX)
|
|
//
|
|
// PURPOSE:
|
|
// --------
|
|
// Aufgabe dieser Funktion ist es, aus den Daten der Minenstreifen Modellparameter fr ein Minensperre zu errechnen. Zus�zlich wird
|
|
// eine eindeutige Kennung berechnet und s�tliche Daten als Gefechtsfeldtelegramm "Wirkfeld Minensperre" aufbereitet und mittels
|
|
// "ZSSI_WI_Telegramme_versenden" in das Empfangs- und in das Sende-verzeichnis der SWKE Kommunikationssystem kopiert.
|
|
//
|
|
// ERROR HANDLING:
|
|
// ---------------
|
|
// (keine / Beschreibung)
|
|
//
|
|
// IMPLEMENTATION DETAILS:
|
|
// -----------------------
|
|
// (keine / Beschreibung)
|
|
//
|
|
//!
|
|
*/
|
|
|
|
//------------------ revision id-code ----------------------
|
|
|
|
#ifdef RCS_ID
|
|
static char rcs_id[] = "$Id$";
|
|
#endif
|
|
|
|
//------------------ includes ------------------------------
|
|
|
|
#include <QString>
|
|
|
|
#include <stdio.h>
|
|
#include <iostream>
|
|
#include <math.h>
|
|
#include "logger.h"
|
|
|
|
#include "zssi_wi_Minenfeld_Interpreter.h"
|
|
#include "zssi_wi_Minenfeld_Generator.h"
|
|
|
|
using namespace NGL;
|
|
|
|
using namespace std;
|
|
//------------------ externals (procs + vars) --------------
|
|
|
|
//------------------ constants/ defines --------------------
|
|
|
|
const int MAX_ANZAHL_SEGMENTE = 5;
|
|
const double max_verlegedichte = 0.99; // In Abhaengigkeit von FAKTOR_VERLEGEDICHTE = 100 in zssi_wi_Minenfeld_Interpreter
|
|
|
|
// Data original from zssi_wi.cfg
|
|
const int S_MVP_Seg = 5; //# gewuenschte maximale Entfernung einer
|
|
//# Minenverlegeposition von einem Segment in Metern
|
|
const int Delta_S_MVP_Seg = 1; //# falls s_mvp_seg nicht eingehalten werden kann
|
|
//# wird bei der Berechnung s_mvp_seg schrittweise
|
|
//# um diesen Betrag erhoeht
|
|
const int VERLEGETIEFE_WMVS = 25;//# einseitige, maximale Wurfweite des Scorpions
|
|
const int VERLEGETIEFE_MVAH = 12;//# gesamte Verlegebreite des Minenverlegeanhaengers
|
|
|
|
const int S_Fahrspur = 5; //# Sekunden, das das letzte Fahrspurtelegramm nach dem
|
|
//# Verlegeendetelegramm ankommen darf
|
|
const int S_Fahrspur_Vorher = 5; //# Sekunden, das das erste Fahrspurtelegramm vor dem
|
|
//# Verlegebeginntelegramm ankommen darf
|
|
|
|
|
|
//------------------ types ---------------------------------
|
|
|
|
//------------------ globals -------------------------------
|
|
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, VERLEGEDATEN_INTERN>
|
|
interne_datenbasis_Verlegedaten;
|
|
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>
|
|
interne_datenbasis_Fahrspur;
|
|
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN> segmentpunkte;
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN> segmentpunkte_eins;
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN> segmentpunkte_zwei;
|
|
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN> schnittpunkte;
|
|
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, Segment_rt> segmente;
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, Segment_rt> segmente_eins;
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, Segment_rt> segmente_zwei;
|
|
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, Segment_rt> segmentparameter;
|
|
|
|
static NGL::INGLLogger &logger()
|
|
{
|
|
return GuezMinelayerProcessing::getLogger("zssi_wi_Minenfeld_Generator");
|
|
}
|
|
|
|
//------------------ function prototypes -------------------
|
|
|
|
// copied from zssi_wi_Minen_math.cpp
|
|
float Punktabstand(float x1, float y1, float x2, float y2)
|
|
{
|
|
return (sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)));
|
|
}
|
|
|
|
float Punktabstand(const gps_position_rt &p1, const gps_position_rt &p2)
|
|
{
|
|
return Punktabstand(p1.utm_ostwert, p1.utm_nordwert,
|
|
p2.utm_ostwert, p2.utm_nordwert);
|
|
}
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static void verschiebe_Fahrspursegmente(const char richtung, const int betrag)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion verschiebt alle Segment-Startpunkte einer Fahrspur
|
|
// im map-container segmente um betrag Meter nach rechts bzw links(in
|
|
// Fahrtrichtung gesehen).
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// r : Rechtsverschiebung
|
|
// l : Linksverschiebung
|
|
//
|
|
// RETURN:
|
|
// Es wird auf den globalen map-container segmente
|
|
// zugegriffen
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
segmente.iter_reset();
|
|
for (; segmente.iter_modify(1);)
|
|
{
|
|
const int drehwinkel = segmente.getData()->drehwinkel;
|
|
gps_position_rt &startpunkt = segmente.getData()->startpunkt;
|
|
//1.Quadrant
|
|
if (drehwinkel >= 0 && drehwinkel < 9000)
|
|
{
|
|
const int ostwert = lrint(sin(drehwinkel / 18000.0 * M_PI) * betrag);
|
|
const int nrdwert = lrint(cos(drehwinkel / 18000.0 * M_PI) * betrag);
|
|
if (richtung == 'r')
|
|
{
|
|
startpunkt.utm_ostwert += ostwert;
|
|
startpunkt.utm_nordwert -= nrdwert;
|
|
}
|
|
else if (richtung == 'l')
|
|
{
|
|
startpunkt.utm_ostwert -= ostwert;
|
|
startpunkt.utm_nordwert += nrdwert;
|
|
}
|
|
}
|
|
else
|
|
|
|
//2.Quadrant
|
|
if (drehwinkel >= 9000 && drehwinkel < 18000)
|
|
{
|
|
const int ostwert = lrint(cos((drehwinkel - 9000) / 18000.0 * M_PI) * betrag);
|
|
const int nrdwert = lrint(sin((drehwinkel - 9000) / 18000.0 * M_PI) * betrag);
|
|
if (richtung == 'r')
|
|
{
|
|
startpunkt.utm_ostwert += ostwert;
|
|
startpunkt.utm_nordwert += nrdwert;
|
|
}
|
|
else if (richtung == 'l')
|
|
{
|
|
startpunkt.utm_ostwert -= ostwert;
|
|
startpunkt.utm_nordwert -= nrdwert;
|
|
}
|
|
}
|
|
else
|
|
|
|
//3.Quadrant
|
|
if (drehwinkel >= 18000 && drehwinkel < 27000)
|
|
{
|
|
const int ostwert = lrint(sin((drehwinkel - 18000) / 18000.0 * M_PI) * betrag);
|
|
const int nrdwert = lrint(cos((drehwinkel - 18000) / 18000.0 * M_PI) * betrag);
|
|
if (richtung == 'r')
|
|
{
|
|
startpunkt.utm_ostwert -= ostwert;
|
|
startpunkt.utm_nordwert += nrdwert;
|
|
}
|
|
else if (richtung == 'l')
|
|
{
|
|
startpunkt.utm_ostwert += ostwert;
|
|
startpunkt.utm_nordwert -= nrdwert;
|
|
}
|
|
}
|
|
else
|
|
|
|
//4.Quadrant
|
|
if (drehwinkel >= 27000 && drehwinkel < 36000)
|
|
{
|
|
const int ostwert = lrint(cos((drehwinkel - 27000) / 18000.0 * M_PI) * betrag);
|
|
const int nrdwert = lrint(sin((drehwinkel - 27000) / 18000.0 * M_PI) * betrag);
|
|
if (richtung == 'r')
|
|
{
|
|
startpunkt.utm_ostwert -= ostwert;
|
|
startpunkt.utm_nordwert -= nrdwert;
|
|
}
|
|
else if (richtung == 'l')
|
|
{
|
|
startpunkt.utm_ostwert += ostwert;
|
|
startpunkt.utm_nordwert += nrdwert;
|
|
}
|
|
}
|
|
}
|
|
}// end of verschiebe_Fahrspursegmente
|
|
//-------------------------------------------------------------------------
|
|
|
|
static void loesche_verlegedaten(const VERLEGEDATEN_KEY &key, const ausstattungs_id_t &fhrzg_identitaet)
|
|
{
|
|
if (interne_datenbasis_Verlegedaten.finden_eintrag_container(key))
|
|
{
|
|
do
|
|
{
|
|
if (!interne_datenbasis_Verlegedaten.iter_modify(-1))
|
|
break;
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.header.identitaet != fhrzg_identitaet)
|
|
break;
|
|
interne_datenbasis_Verlegedaten.iter_erase();
|
|
}
|
|
while (1);
|
|
}
|
|
//Nun noch den parameter-eintrag
|
|
interne_datenbasis_Verlegedaten.loeschen_eintrag_container(key);
|
|
}
|
|
|
|
// copied from zssi_wi_Minen_math.cpp
|
|
//f+-----------------------------------------------------------------------
|
|
int Abstand_des_Punktes_von_Strecke(
|
|
int px, int py, int x1, int y1, int x2, int y2)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion liefert den Abstand eines Punktes von einer Strecke
|
|
// zurueck. Ist kein senkrechter Abstand moeglich, wird -1
|
|
// zurueckgegeben.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
double a, b, e;
|
|
double fx1 = x1;
|
|
double fy1 = y1;
|
|
double fx2 = x2;
|
|
double fy2 = y2;
|
|
double fpx = px;
|
|
double fpy = py;
|
|
//float fussp_x_1, fussp_y_1, fussp_x_2, fussp_y_2;
|
|
//int fusspunkt_x, fusspunkt_y;
|
|
|
|
if (x2 - x1 == 0) return (std::abs(px - x1));
|
|
a = (fy2 - fy1) / (fx2 - fx1);
|
|
b = (-fx1 / (fx2 - fx1) * (fy2 - fy1)) + fy1;
|
|
e = fabs(-a * fpx + fpy - b) / sqrt(1 + a * a);
|
|
|
|
return (lrint(e));
|
|
}// end Abstand_des_Punktes_von_Strecke
|
|
//-------------------------------------------------------------------------
|
|
|
|
// copied from zssi_wi_Minen_math.cpp
|
|
//f+-----------------------------------------------------------------------
|
|
int Winkel_ostbezogen(int x1, int y1, int x2, int y2)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion liefert den Winkel den die Strecke x1/y1->x2/y2
|
|
// gegenueber Osten einnimmt (mathematischer Winkel zwischen 0 und 35999
|
|
// Hunderstel-Grad)
|
|
// zurueck.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
double alfa;
|
|
double fx1 = x1;
|
|
double fy1 = y1;
|
|
double fx2 = x2;
|
|
double fy2 = y2;
|
|
|
|
if (fabs(fx2 - fx1) <= 0.000000000001)
|
|
{
|
|
if (fy2 > fy1)
|
|
alfa = 90.0; else
|
|
alfa = 270.0;
|
|
}
|
|
else
|
|
{
|
|
alfa = (atan((fy2 - fy1) / (fx2 - fx1)) * 360.0) / (atan(1.0) * 8);
|
|
if (alfa < 0)
|
|
alfa = 360.0 - std::abs(alfa);
|
|
if ((alfa < 90) && (fx2 < fx1))
|
|
alfa = alfa + 180.0;
|
|
if ((alfa > 270) && (fx2 < fx1))
|
|
alfa = alfa - 180.0;
|
|
}
|
|
return (lrint(alfa * 100.0));
|
|
}// end of Winkel_ostbezogen
|
|
//-------------------------------------------------------------------------
|
|
|
|
// copied from zssi_wi_Minen_math.cpp
|
|
//f+-----------------------------------------------------------------------
|
|
void Schnittpunkt_Winkelhalbierende_Strecke(
|
|
int P1x, int P1y, int P2x, int P2y, int P3x, int P3y,
|
|
int Ax, int Ay, int Bx, int By, float *sx, float *sy)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion liefert den Schnittpunkt zwischen der
|
|
// Winkelhalbierenden, welche durch Punkt P2 geht, und einer
|
|
// gegenueberliegenden Strecke.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
float Wx, Wy;
|
|
float v, l;
|
|
/* Berechnung eines zweiten Punktes der Winkelhalbierenden */
|
|
v = Punktabstand(P1x, P1y, P2x, P2y) / (float)Punktabstand(P3x, P3y, P2x, P2y);
|
|
l = Punktabstand(P3x, P3y, P1x, P1y) / (1 + (1 / v));
|
|
|
|
Wx = (l / Punktabstand(P3x, P3y, P1x, P1y)) * (P3x - P1x) + P1x;
|
|
Wy = (l / Punktabstand(P3x, P3y, P1x, P1y)) * (P3y - P1y) + P1y;
|
|
|
|
/*
|
|
cerr<< "\nerster Punkt fuer Winkelhalbierende: " << P2x << "/" << P2y ;
|
|
cerr<< "\nzweiter Punkt fuer Winkelhalbierende: " << Wx << "/" << Wy ;
|
|
cerr<< "\nerster Punkte fuer Strecke: " << Ax << "/" << Ay ;
|
|
cerr<< "\nzweiter Punkte fuer Strecke: " << Bx << "/" << By ;
|
|
*/
|
|
|
|
if (((-Wy + P2y) * (-Ax + Bx) + (Ay - By) * (-Wx + P2x)) != 0)
|
|
{
|
|
*sx = float(((Wy * (Wx - P2x) - Wx * (Wy - P2y)) * (-Ax + Bx)
|
|
- (Ay * (Ax - Bx) - Ax * (Ay - By)) * (-Wx + P2x))
|
|
/
|
|
((-Wy + P2y) * (-Ax + Bx) + (Ay - By) * (-Wx + P2x)));
|
|
}
|
|
else
|
|
{
|
|
//Die Winkelhalbierende ist waagerecht
|
|
*sy = Wy ;
|
|
//sx liegt auf der Geraden, die durch A und B geht
|
|
//Wx = sy/a-b
|
|
float a, b;
|
|
|
|
if ((Ax - Bx) != 0)
|
|
{
|
|
a = (float(Ay - By) / float(Ax - Bx));
|
|
b = Ay - a * Ax;
|
|
if (a != 0)
|
|
Wx = *sy / a - b;
|
|
else
|
|
{
|
|
//Die Winkelhalbierende und Strecke liegen parallel
|
|
*sx = -1;
|
|
*sy = -1;
|
|
goto ende;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Die Strecke steht senkrecht
|
|
*sx = Ax;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if ((-Wx + P2x) != 0)
|
|
{
|
|
*sy = ((-Wy + P2y) * (*sx) - (Wy * (Wx - P2x) - Wx * (Wy - P2y)))
|
|
/
|
|
(-Wx + P2x);
|
|
}
|
|
else
|
|
{
|
|
//Die Winkelhalbierende ist senkrecht
|
|
*sx = Wx ;
|
|
//sy liegt auf der Geraden, die durch A und B geht
|
|
//sy = a*Wx+b
|
|
float a, b;
|
|
|
|
if ((Ax - Bx) != 0)
|
|
{
|
|
a = (float(Ay - By) / float(Ax - Bx));
|
|
b = Ay - a * Ax;
|
|
*sy = a * Wx + b;
|
|
}
|
|
else
|
|
{
|
|
//Winkelhalbierende und Strecke liegen parallel
|
|
*sx = -1;
|
|
*sy = -1;
|
|
goto ende;
|
|
}
|
|
}
|
|
//liegt der ermittelte Schnittpunkt ausserhalb der Strecke A->B
|
|
//wird -1, -1 als Schnittpunkt zurueckgegeben
|
|
if (
|
|
(Punktabstand(Ax, Ay, *sx, *sy) >
|
|
Punktabstand(Ax, Ay, Bx, By))
|
|
|| (Punktabstand(Bx, By, *sx, *sy) >
|
|
Punktabstand(Ax, Ay, Bx, By))
|
|
)
|
|
{
|
|
*sx = -1;
|
|
*sy = -1;
|
|
}
|
|
|
|
ende:
|
|
//Falls kein Schnittpunkt ermittelt werden konnte, wird A oder B als
|
|
//Schnittpunkt angenommen (je nach dem welcher naeher an P2 liegt)
|
|
if (*sx == -1)
|
|
{
|
|
if (Punktabstand(Ax, Ay, *sx, *sy) < Punktabstand(Bx, By, *sx, *sy))
|
|
{
|
|
*sx = Ax;
|
|
*sy = Ay;
|
|
}
|
|
else
|
|
{
|
|
*sx = Bx;
|
|
*sy = By;
|
|
}
|
|
}
|
|
|
|
|
|
}// end Schnittpunkt_Winkelhalbierende_Strecke
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static int Punktauswahl_fuer_Segmente(
|
|
VERLEGEDATEN_KEY endpunkt_key, VERLEGEDATEN_KEY anfangspunkt_key)
|
|
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion glaettet die zwischen Anfangspunkt und Endpunkt liegenden
|
|
// Minenverlegepositionen(MVP) durch maximal MAX_ANZAHL_SEGMENTE
|
|
// Streckenabschnitte(+1 Punkte)
|
|
// nach folgendem Algorithmus:
|
|
// 0. Anfangspunkt und Endpunkt der Verlegespur werden durch eine Strecke
|
|
// verbunden. Segmentzaehler = 1!
|
|
// 1. Suche der MVP, die am weitesten von einer (Strecke) Gerade entfernt
|
|
// ist.
|
|
// 2. Ist diese Entfernung kleiner als S_MVP_Seg dann Sprung zum Ende.
|
|
// 3. Bilde aus der Strecke, auf die sich bezogen wurde, zwei Strecken,
|
|
// indem der neue Endpunkt und der neue Anfangspunkt diese MVP ist.
|
|
// 4. Segmentzaehler erhoehen.
|
|
// 5. Ist der Segmentzaehler > MAX_ANZAHL_SEGMENTE, dann S_MVP_Seg um
|
|
// Delta_S_MVP_Seg erhoehen und Sprung zu 0.
|
|
// 6. Sprung zu 1.
|
|
// ENDE
|
|
// Die gefundenen Stuetzpunkte werden in den map-container segmentpunkte
|
|
// eingetragen
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// Anzahl der vergebenen Segmente
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
int anzahl;
|
|
int korr_max_s;
|
|
int groesster_abstand;
|
|
gps_position_rt anfangspunkt;
|
|
gps_position_rt endpunkt;
|
|
VERLEGEDATEN_KEY groesster_abstand_key;
|
|
VERLEGEDATEN_KEY streckenende_key;
|
|
double min_abstand = 20.0;
|
|
|
|
korr_max_s = S_MVP_Seg;
|
|
|
|
marke_0:
|
|
segmentpunkte.clear();
|
|
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
segmentpunkte.eintrag_container(interne_datenbasis_Fahrspur.getKey(),
|
|
*interne_datenbasis_Fahrspur.getData());
|
|
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
segmentpunkte.eintrag_container(interne_datenbasis_Fahrspur.getKey(),
|
|
*interne_datenbasis_Fahrspur.getData());
|
|
|
|
|
|
anzahl = 1;
|
|
|
|
marke_1:
|
|
groesster_abstand = 0;
|
|
|
|
segmentpunkte.finden_eintrag_container(anfangspunkt_key);
|
|
anfangspunkt = segmentpunkte.getData()->daten.gps_position;
|
|
|
|
segmentpunkte.iter_modify(1);//auf das 1.Streckenende
|
|
|
|
streckenende_key = segmentpunkte.getKey();
|
|
endpunkt = segmentpunkte.getData()->daten.gps_position;
|
|
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(1)) &&
|
|
(interne_datenbasis_Fahrspur.getKey() != endpunkt_key)
|
|
)
|
|
{
|
|
//auf naechste Strecke weiterschalten falls Streckenende erreicht ist
|
|
if (interne_datenbasis_Fahrspur.getKey() == streckenende_key)
|
|
{
|
|
segmentpunkte.finden_eintrag_container(streckenende_key);
|
|
anfangspunkt = segmentpunkte.getData()->daten.gps_position;
|
|
if (segmentpunkte.iter_modify(1))
|
|
{
|
|
streckenende_key = segmentpunkte.getKey();
|
|
endpunkt = segmentpunkte.getData()->daten.gps_position;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
const FAHRSPUR_INTERN *dataPtr = interne_datenbasis_Fahrspur.getData();
|
|
|
|
int curAbstand = Abstand_des_Punktes_von_Strecke(
|
|
dataPtr->daten.gps_position.utm_ostwert,
|
|
dataPtr->daten.gps_position.utm_nordwert,
|
|
anfangspunkt.utm_ostwert, anfangspunkt.utm_nordwert,
|
|
endpunkt.utm_ostwert, endpunkt.utm_nordwert);
|
|
if (curAbstand >= groesster_abstand)
|
|
{
|
|
if (Punktabstand(dataPtr->daten.gps_position, anfangspunkt) >= min_abstand
|
|
&& Punktabstand(dataPtr->daten.gps_position, endpunkt) >= min_abstand)
|
|
{
|
|
groesster_abstand = curAbstand;
|
|
groesster_abstand_key = interne_datenbasis_Fahrspur.getKey();
|
|
}
|
|
}
|
|
}
|
|
|
|
//Test ob der maximale Sollabstand ueberschritten wird
|
|
if (groesster_abstand <= korr_max_s)
|
|
return (anzahl);
|
|
else
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
groesster_abstand_key);
|
|
|
|
if (segmentpunkte.eintrag_container(interne_datenbasis_Fahrspur.getKey(),
|
|
*interne_datenbasis_Fahrspur.getData()))
|
|
{
|
|
anzahl ++;
|
|
if (anzahl > MAX_ANZAHL_SEGMENTE)
|
|
{
|
|
korr_max_s = korr_max_s + Delta_S_MVP_Seg;
|
|
goto marke_0;
|
|
}
|
|
}
|
|
}
|
|
goto marke_1;
|
|
|
|
return (anzahl);
|
|
}// end of Punktauswahl_fuer_Segmente
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
static void KontrollausgabeFahrspur(GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN> &cont,
|
|
const QString &art, int id)
|
|
{
|
|
NGL::INGLLogger &m_logger(logger());
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Fahrspurcontainer am %1 von IS==%2:").arg(art).arg(id);
|
|
for (const auto &d : cont.c())
|
|
INFO_LOG(m_logger) << d.second.daten.gps_position.utm_ostwert << "/" << d.second.daten.gps_position.utm_nordwert
|
|
<< " is: " << d.second.intstat;
|
|
}
|
|
|
|
static void KontrollausgabeVerlegedaten(GFS_Map_Container<VERLEGEDATEN_KEY, VERLEGEDATEN_INTERN> &cont,
|
|
const QString &art, int id)
|
|
{
|
|
NGL::INGLLogger &m_logger(logger());
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Verlegedatencontainer am %1 von IS==%2:").arg(art).arg(id);
|
|
for (const auto &d : cont.c())
|
|
INFO_LOG(m_logger) << d.second.daten.gps_position.utm_ostwert << "/" << d.second.daten.gps_position.utm_nordwert
|
|
<< " Fz: " << d.second.daten.header.identitaet;
|
|
}
|
|
|
|
static void KontrollausgabeSegmente(const GFS_Map_Container<VERLEGEDATEN_KEY, Segment_rt> &segmente)
|
|
{
|
|
NGL::INGLLogger &m_logger(logger());
|
|
|
|
for (const auto &d : segmente.c())
|
|
INFO_LOG(m_logger) << d.second.startpunkt.utm_ostwert << "/" << d.second.startpunkt.utm_nordwert
|
|
<< " Winkel: " << d.second.drehwinkel
|
|
<< " Laenge: " << d.second.anzahl;
|
|
}
|
|
|
|
|
|
static void KontrollausgabeSegmente(const std::vector<Segment_rt> &segmente)
|
|
{
|
|
NGL::INGLLogger &m_logger(logger());
|
|
|
|
for (size_t s = 0; s < segmente.size(); s++)
|
|
{
|
|
const auto &seg = segmente.at(s);
|
|
INFO_LOG(m_logger) << "Segment[" << s << "] Startpunkt: " << seg.startpunkt.utm_ostwert << "/" << seg.startpunkt.utm_nordwert
|
|
<< " Drehwinkel: " << seg.drehwinkel << " Anzahl: " << seg.anzahl;
|
|
}
|
|
}
|
|
|
|
static void KontrollausgabeSegmentPunkte(const GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN> &cont)
|
|
{
|
|
NGL::INGLLogger &m_logger(logger());
|
|
|
|
for (const auto &d : cont.c())
|
|
INFO_LOG(m_logger) << d.second.daten.gps_position.utm_ostwert << "/" << d.second.daten.gps_position.utm_nordwert;
|
|
}
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Generator::processData(void)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion wird von ZSSI_WI_Minen_Interpreter aufgerufen.
|
|
// Die Eintraege im internen Map-Container interne_datenbasis_Fahrspur
|
|
// sind mit ihrem aktuellen Interpretationsstatus versehen.
|
|
// Der Interpretationsstatus hat folgende Bedeutung:
|
|
// 0: Diese Minenverlegeposition(MVP) wurde empfangen.
|
|
// 1: Diese MVP gehoert keiner Verlegespur an und wird geloescht.
|
|
// 2: Diese MVP wird einer Verlegespur zugeordnet.
|
|
// 3: Diese MVP ist ein Anfangspunkt einer Verlegespur.
|
|
// 4: Diese MVP ist ein Endpunkt einer Verlgegspur.
|
|
// 5: Diese MVP ist ein Endpunkt einer Verlegespur, die nicht durch das
|
|
// selbe Fz zu einer mehrspurigen Minensperre weiter ausgebaut wird.
|
|
// 6: Die Minensperre wird ab diesem Verlegeendpunkt durch
|
|
// das selbe Fz mehrspurig ausgebaut.
|
|
// 7: Die MVP ist der Endpunkt einer durch ein Fz mehrspurig ausgebauten
|
|
// Minensperre
|
|
// 8: Die Minensperre zu der dieser Verlege-Endpunkt gehoert, wird durch
|
|
// mehrere Fz ausgebaut.
|
|
// 9: Diese MVP ist ein Endpunkt einer einspurigen Minensperre
|
|
// 10: Diese MVP ist einer der Endpunkte einer durch mehrere Fz verlegten
|
|
// Minensperre, von der bereits zwei Fahrspuren komplett verlegt sind.
|
|
// 11: Diese MVP ist einer der Endpunkte einer durch mehrere Fz fertig
|
|
// verlegten Minensperre
|
|
//
|
|
// Es werden die Modelle fuer Minensperren erstellt
|
|
//
|
|
//
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
wirkfeld_minensperre_rt telegramm;
|
|
bes_wirkfeld_minensperre_rt &sperrenmodell = telegramm.beschreibung;
|
|
|
|
ausstattungs_id_t fahrzeug_identitaet;
|
|
unsigned int verlege_anfangszeit, verlege_endzeit;
|
|
|
|
VERLEGEDATEN_KEY anfangspunkt_key;
|
|
//VERLEGEDATEN_KEY mittlerer_anfangspunkt_key;
|
|
VERLEGEDATEN_KEY zweiter_anfangspunkt_key;
|
|
|
|
VERLEGEDATEN_KEY endpunkt_key;
|
|
//VERLEGEDATEN_KEY mittlerer_endpunkt_key;
|
|
VERLEGEDATEN_KEY erster_endpunkt_key;
|
|
|
|
VERLEGEDATEN_KEY parameter_key;
|
|
VERLEGEDATEN_KEY parameter_eins_key;
|
|
VERLEGEDATEN_KEY parameter_zwei_key;
|
|
VERLEGEDATEN_KEY parameter_drei_key;
|
|
|
|
VERLEGEDATEN_KEY kleinster_abstand_key;
|
|
FAHRSPUR_INTERN punktdaten;
|
|
VERLEGEDATEN_KEY punktkey;
|
|
|
|
FAHRSPUR_INTERN luecken_punkt;
|
|
FAHRSPUR_INTERN schnittpkt;
|
|
FAHRSPUR_INTERN segmentstartpunkt;
|
|
unsigned long count;
|
|
|
|
Segment_rt segment;
|
|
//int anzahl;
|
|
//int anzahl_zwei;
|
|
int lueckenzaehler;
|
|
int gesamte_verlege_strecke;
|
|
int gesamte_minenanzahl;
|
|
bool map_test;
|
|
bool fz_test;
|
|
//cWirkfeld_Minensperre *Minensperre;
|
|
|
|
short Fz_art = 0;
|
|
float rest = 0;
|
|
int minenzaehler = 0;
|
|
int groesster_spurabstand = 0;
|
|
int hilfswinkel_eins;
|
|
int hilfswinkel_zwei;
|
|
int copy_of_erste_verlegeart;
|
|
int copy_of_zweite_verlegeart;
|
|
int copy_of_dritte_verlegeart;
|
|
|
|
//Kontrollausgabe
|
|
//lout << setprio(LM_INFO)
|
|
// << "Funktion 'ZSSI_WI_Minen_Generator' aufgerufen"
|
|
// << endl;
|
|
|
|
|
|
|
|
minengenerator_anfang:
|
|
|
|
NGL::INGLLogger &m_logger(logger());
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
//Es werden alle vorhandenen einspurigen Minensperren abgearbeitet.
|
|
///////////////////////////////////////////////////////////////////
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
|
|
while (interne_datenbasis_Fahrspur.iter_modify(1))
|
|
{
|
|
//Suche nach einem Verlegeende einer einspurigen Minensperre
|
|
map_test = interne_datenbasis_Fahrspur.size() > 0;
|
|
|
|
while ((map_test) && (interne_datenbasis_Fahrspur.getData()->intstat != 9))
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 9)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Einspurige Minensperre wird berechnet");
|
|
|
|
|
|
gesamte_minenanzahl = 0;
|
|
|
|
endpunkt_key = interne_datenbasis_Fahrspur.getKey();
|
|
anfangspunkt_key = Key_des_zugehoerigen_Verlegebeginns(endpunkt_key);
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
fahrzeug_identitaet =
|
|
interne_datenbasis_Fahrspur.getData()->daten.header.identitaet;
|
|
verlege_anfangszeit =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
verlege_endzeit =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeFahrspur(interne_datenbasis_Fahrspur, QStringLiteral("Beginn"), 9);
|
|
KontrollausgabeVerlegedaten(interne_datenbasis_Verlegedaten, QStringLiteral("Beginn"), 9);
|
|
|
|
|
|
//Ermitteln der maximal 5 Segmente
|
|
Punktauswahl_fuer_Segmente(endpunkt_key, anfangspunkt_key);
|
|
|
|
|
|
//Ermitteln der Parameter der Minensperre durch das Suchen eines
|
|
//Verlegeende-Telegramms
|
|
//im Map-Container interne_datenbasis_Verlegedaten
|
|
parameter_key = anfangspunkt_key; // nur damit er einen gueltigen Wert hat.
|
|
map_test = interne_datenbasis_Verlegedaten.size() > 0;
|
|
//Die Luecken der Minensperre werden gezaehlt, wobei davon ausgegangen wird
|
|
//dass vor jeder Luecke ein Verlegeendetelegramm gesendet wurde, welches im
|
|
//Zeitraum zwischen Minensperrenanfang und Minensperrenende gesendet wurde.
|
|
lueckenzaehler = 0;
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
//juengsten Ende-Eintrag fuer dieses Fz finden, der waehrend oder nach der
|
|
//Verlegeende-MVP gesendet wurde, dabei auf gleichen minentyp testen
|
|
int minentyp = -1;
|
|
while ((map_test) && (parameter_key == anfangspunkt_key))
|
|
{
|
|
//Das erste Verlegeende-Telegramm, das nach dem Zeitpunkt der ermittelten
|
|
//Verlegeende-MVP
|
|
//gesendet wurde, stellt die Parameter fuer diese Minensperre bereit.
|
|
if (interne_datenbasis_Verlegedaten.getData()->daten.header.identitaet
|
|
== fahrzeug_identitaet)
|
|
{
|
|
|
|
if ((interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
> verlege_anfangszeit + S_Fahrspur_Vorher)
|
|
&&
|
|
(interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
< verlege_endzeit)
|
|
|
|
)
|
|
{
|
|
//Die Lueckenanfaenge (Verlegeendemeldungen) werden mit IS 100 in den
|
|
//map-container segmentpunkte eingetragen, die
|
|
//Lueckenenden(Verlegeanfangsmeldungen) mit IS 101
|
|
//Sind diese Punkte schon vorhanden, so werden sie als Originalpunkte
|
|
//mit IS+100 versehen
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0)
|
|
{
|
|
if ((minentyp != -1) && (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
//es muss im Falle verschiedener Minentypen ein IS 9 mit folgendem
|
|
//IS 3 in den Fahrspurcontainer eingetragen werden, und zwar an
|
|
//der Stelle, an der das vorherige Verlegeendetelegramm kam
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Fahrspur wird in zwei Minensperren geteilt, da der Minentyp gewechselt wurde!");
|
|
interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen == 0)//also ein Beginn
|
|
interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
do
|
|
{
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
}
|
|
while ((map_test)
|
|
&&
|
|
(!((interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_zeit.gps_zeit
|
|
>
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.gps_zeit.gps_zeit)
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet))
|
|
)
|
|
);
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 3;
|
|
interne_datenbasis_Fahrspur.iter_modify(-1);
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
|
|
goto minengenerator_anfang;
|
|
}
|
|
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
|
|
gesamte_minenanzahl =
|
|
gesamte_minenanzahl + interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
lueckenzaehler++;
|
|
|
|
//falls dieser Key schon vorhanden ist, wird der alte Eintrag
|
|
//ueberschrieben
|
|
if (segmentpunkte.loeschen_eintrag_container(interne_datenbasis_Verlegedaten.getKey()))
|
|
luecken_punkt.intstat = 200;
|
|
else
|
|
luecken_punkt.intstat = 100;
|
|
luecken_punkt.daten.header.identitaet =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.header.identitaet;
|
|
luecken_punkt.daten.gps_zeit.gps_zeit =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.gps_zeit.gps_zeit;
|
|
luecken_punkt.daten.gps_position =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.gps_position;
|
|
|
|
segmentpunkte.eintrag_container(interne_datenbasis_Verlegedaten.getKey(), luecken_punkt);
|
|
}
|
|
else
|
|
{
|
|
//falls dieser Key schon vorhanden ist, wird der alte Eintrag
|
|
// ueberschrieben
|
|
if (segmentpunkte.loeschen_eintrag_container(interne_datenbasis_Verlegedaten.getKey()))
|
|
luecken_punkt.intstat = 201;
|
|
else
|
|
luecken_punkt.intstat = 101;
|
|
luecken_punkt.daten.header.identitaet =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.header.identitaet;
|
|
luecken_punkt.daten.gps_zeit.gps_zeit =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.gps_zeit.gps_zeit;
|
|
luecken_punkt.daten.gps_position =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.gps_position;
|
|
|
|
segmentpunkte.eintrag_container(interne_datenbasis_Verlegedaten.getKey(), luecken_punkt);
|
|
}
|
|
}
|
|
|
|
if ((interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
>= verlege_endzeit - S_Fahrspur)
|
|
&&
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0)
|
|
)
|
|
{
|
|
if ((minentyp != -1) && (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
//es muss im Falle verschiedener Minentypen ein IS 9 mit folgendem
|
|
//IS 3 in den Fahrspurcontainer eingetragen werden, und zwar an
|
|
//der Stelle, an der das vorherige Verlegeendetelegramm kam
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Fahrspur wird in zwei Minensperren geteilt, da der Minentyp gewechselt wurde!");
|
|
interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen == 0) //also ein Beginn
|
|
interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
do
|
|
{
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
}
|
|
while ((map_test)
|
|
&&
|
|
(!(
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_zeit.gps_zeit
|
|
>
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.gps_zeit.gps_zeit)
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet)
|
|
))
|
|
);
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 3;
|
|
interne_datenbasis_Fahrspur.iter_modify(-1);
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
|
|
goto minengenerator_anfang;
|
|
}
|
|
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
|
|
parameter_key = interne_datenbasis_Verlegedaten.getKey();
|
|
gesamte_minenanzahl =
|
|
gesamte_minenanzahl + interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
}
|
|
}
|
|
map_test = interne_datenbasis_Verlegedaten.iter_modify(1);
|
|
}
|
|
|
|
if (parameter_key != anfangspunkt_key)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Parameter fuer einspurige Minensperre gefunden. ");
|
|
|
|
|
|
//Die erkannten Segmente haben Vorrang gegenueber den Luecken, will
|
|
//heissen, dass nur dann Luecken beachtet werden, wenn die maximale Anzahl
|
|
// von Segmenten noch nicht erreicht ist.
|
|
|
|
segmentpunkte.iter_reset();
|
|
segmente.clear();
|
|
if (segmentpunkte.size() > MAX_ANZAHL_SEGMENTE + 1)
|
|
//dann werden nur die Originalpunkte beachtet
|
|
{
|
|
do
|
|
{
|
|
if ((segmentpunkte.getData()->intstat != 100)
|
|
&&
|
|
(segmentpunkte.getData()->intstat != 101))
|
|
{
|
|
segment.startpunkt = segmentpunkte.getData()->daten.gps_position;
|
|
|
|
segmente.eintrag_container(segmentpunkte.getKey(), segment);
|
|
|
|
}
|
|
}
|
|
while (segmentpunkte.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Startpunkt eines Segmentes
|
|
segmente.iter_modify(-1);
|
|
segmente.loeschen_eintrag_container(segmente.getKey());
|
|
}
|
|
else
|
|
//dann koennen auch alle Luecken beachtet werden
|
|
{
|
|
do
|
|
{
|
|
//Lueckenanfaenge sind keine Segment-Anfangspunkte und werden
|
|
// uebersprungen.
|
|
if ((segmentpunkte.getData()->intstat == 100)
|
|
|| (segmentpunkte.getData()->intstat == 200))
|
|
segmentpunkte.iter_modify(1);
|
|
|
|
segment.startpunkt = segmentpunkte.getData()->daten.gps_position;
|
|
|
|
segmente.eintrag_container(segmentpunkte.getKey(), segment);
|
|
|
|
}
|
|
while (segmentpunkte.iter_modify(1));
|
|
//Der letzte Eintrag ist auch kein Startpunkt eines Segmentes
|
|
segmente.iter_modify(-1);
|
|
segmente.loeschen_eintrag_container(segmente.getKey());
|
|
}
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte.finden_eintrag_container(segmente.getKey());
|
|
segmentpunkte.iter_modify(1);
|
|
segmente.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente.getData()->
|
|
startpunkt.utm_ostwert,
|
|
segmente.getData()->
|
|
startpunkt.utm_nordwert,
|
|
segmentpunkte.getData()->
|
|
daten.gps_position.utm_ostwert,
|
|
segmentpunkte.getData()->
|
|
daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente.getData()->anzahl =
|
|
Punktabstand(segmente.getData()->startpunkt,
|
|
segmentpunkte.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente.getData()->anzahl;
|
|
INFO_LOG(m_logger) << QStringLiteral("Punktabstand (%1, %2, %3, %4)").arg(segmente.getData()->startpunkt.utm_ostwert).arg(segmente.getData()->startpunkt.utm_nordwert).arg(segmentpunkte.getData()->daten.gps_position.utm_ostwert).arg(segmentpunkte.getData()->daten.gps_position.utm_nordwert);
|
|
}
|
|
while (segmente.iter_modify(1));
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Gesamtlaenge: %1").arg(gesamte_verlege_strecke);
|
|
INFO_LOG(m_logger) << QStringLiteral("Gesamtanzahl: %1").arg(gesamte_minenanzahl);
|
|
//Ersetzen der Segmentlaengen durch die Anzahl der Minen
|
|
segmente.iter_reset();
|
|
do
|
|
{
|
|
//Der Rest darf nicht verloren gehen, sondern muss dem naechsten
|
|
//Segment zugerechnet, bzw abgerechnet werden, da die Summe der Minen
|
|
//exakt die Gesamtmenge ergeben soll!
|
|
float f_anzahl = float((segmente.getData()->
|
|
anzahl + rest) / (float) gesamte_verlege_strecke)
|
|
* gesamte_minenanzahl;
|
|
rest = f_anzahl - int(f_anzahl + 0.5);
|
|
segmente.getData()->anzahl = int(f_anzahl + 0.5);
|
|
minenzaehler = minenzaehler + segmente.getData()->anzahl;
|
|
}
|
|
while (segmente.iter_modify(1));
|
|
//Bei dem letzten Segment werden lediglich die Rundungsfehler
|
|
//ausgeglichen.
|
|
//Iterator steht bereits auf dem letzten Eintrag
|
|
segmente.getData()->anzahl =
|
|
segmente.getData()->anzahl + (gesamte_minenanzahl - minenzaehler);
|
|
|
|
|
|
|
|
interne_datenbasis_Verlegedaten.finden_eintrag_container(parameter_key);
|
|
|
|
//Die Startpunkte der Segmente muessen dann verschoben werden, wenn die
|
|
//Verlegeart links oder rechts ist
|
|
INFO_LOG(m_logger) << QStringLiteral("Ausstossart: %1").arg(interne_datenbasis_Verlegedaten.getData()-> daten.verlegedaten.ausstossart);
|
|
|
|
switch (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart)
|
|
{
|
|
case 0: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_MVAH; //Mitte, nur MVAH ;
|
|
break;
|
|
case 1: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS; //Rechts
|
|
verschiebe_Fahrspursegmente('r',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 2: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS; //Links
|
|
verschiebe_Fahrspursegmente('l',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 3: sperrenmodell.verlegetiefe =
|
|
2 * VERLEGETIEFE_WMVS; //Rechts&Links
|
|
break;
|
|
default: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_MVAH;
|
|
|
|
}
|
|
|
|
|
|
segmentparameter = segmente;
|
|
segmente.clear();
|
|
|
|
//sperrenmodell.kennung = ;
|
|
//sperrenmodell.bezeichner =;
|
|
sperrenmodell.wirkbeginn =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.wirkbeginn;
|
|
sperrenmodell.wirkdauer =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.wirkzeit;
|
|
sperrenmodell.eckpunkt.utm_ostwert = 0;
|
|
sperrenmodell.eckpunkt.utm_nordwert = 0;
|
|
sperrenmodell.wirkfeldbreite = 0;
|
|
sperrenmodell.wirkfeldtiefe = 0;
|
|
|
|
|
|
sperrenmodell.verlegedichte = lrint(max_verlegedichte * FAKTOR_VERLEGEDICHTE); //default
|
|
|
|
if (gesamte_verlege_strecke != 0)
|
|
//verlegedichte entspricht Minen je 10 Meter
|
|
{
|
|
// if((gesamte_minenanzahl)*100/gesamte_verlege_strecke <
|
|
// 65){sperrenmodell.verlegedichte = 6;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 55){sperrenmodell.verlegedichte = 5;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 45){sperrenmodell.verlegedichte = 4;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 35){sperrenmodell.verlegedichte = 3;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 25){sperrenmodell.verlegedichte = 2;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 15){sperrenmodell.verlegedichte = 1;}
|
|
sperrenmodell.verlegedichte = lrint(((double)gesamte_minenanzahl / gesamte_verlege_strecke * FAKTOR_VERLEGEDICHTE));
|
|
if (sperrenmodell.verlegedichte > max_verlegedichte * FAKTOR_VERLEGEDICHTE)
|
|
sperrenmodell.verlegedichte = lrint(max_verlegedichte * FAKTOR_VERLEGEDICHTE);
|
|
else if (sperrenmodell.verlegedichte < 1)
|
|
sperrenmodell.verlegedichte = 1;
|
|
INFO_LOG(m_logger) << QStringLiteral("verlegedichte = %1 anz=%2 strecke=%3").arg(sperrenmodell.verlegedichte).arg(gesamte_minenanzahl).arg(gesamte_verlege_strecke);
|
|
}
|
|
sperrenmodell.minentyp =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
sperrenmodell.minenanzahl = gesamte_minenanzahl;
|
|
|
|
sperrenmodell.segmente.reserve(segmentparameter.size());
|
|
for (const auto &val : segmentparameter.c())
|
|
sperrenmodell.segmente.push_back(val.second);
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Einspuriges Minensperrenmodell wurde erstellt. Wirkbeginn: %1 Wirkdauer:%2 Verlegetiefe:%3 Verlegedichte:%4 Minentyp:%5 Minenanzahl:%6 Segmentanzahl:%7").arg(sperrenmodell.wirkbeginn.gps_zeit).arg(sperrenmodell.wirkdauer).arg(sperrenmodell.verlegetiefe).arg(sperrenmodell.verlegedichte).arg(sperrenmodell.minentyp).arg(sperrenmodell.minenanzahl).arg(sperrenmodell.segmente.size());
|
|
KontrollausgabeSegmente(sperrenmodell.segmente);
|
|
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart == 0)
|
|
Fz_art = 1;
|
|
else
|
|
Fz_art = 2;
|
|
//Aufruf des Construktors(sperrenmodell, fahrzeug_identitaet, Fz_art)
|
|
|
|
telegramm.beschreibung.kennung = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.sperren_id;
|
|
|
|
telegramm.header.identitaet = fahrzeug_identitaet;
|
|
|
|
emit sendeWirkfeld(telegramm, Fz_art);
|
|
sperrenmodell.segmente.clear();
|
|
}
|
|
else
|
|
WARNING_LOG(m_logger) << QStringLiteral("Minensperre ohne Parameter!");
|
|
|
|
|
|
//Alle Fahrspureintraege dieser Minensperre werden geloescht
|
|
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
anfangspunkt_key);
|
|
do
|
|
{
|
|
interne_datenbasis_Fahrspur.iter_erase();
|
|
}
|
|
while (interne_datenbasis_Fahrspur.contains(endpunkt_key));
|
|
|
|
//Die Verlegedaten der Minensperre werden geloescht
|
|
if (interne_datenbasis_Verlegedaten.finden_eintrag_container(
|
|
parameter_key))
|
|
{
|
|
do
|
|
{
|
|
interne_datenbasis_Verlegedaten.finden_eintrag_container(parameter_key);
|
|
map_test = interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
fz_test = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet;
|
|
|
|
if ((map_test) && (fz_test))
|
|
interne_datenbasis_Verlegedaten.iter_erase();
|
|
}
|
|
while (fz_test && map_test);
|
|
}
|
|
//Nun noch den Parameter-Eintrag
|
|
interne_datenbasis_Verlegedaten.loeschen_eintrag_container(interne_datenbasis_Verlegedaten.getKey());
|
|
|
|
segmentparameter.clear();
|
|
segmentpunkte.clear();
|
|
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeFahrspur(interne_datenbasis_Fahrspur, QStringLiteral("Ende"), 9);
|
|
KontrollausgabeVerlegedaten(interne_datenbasis_Verlegedaten, QStringLiteral("Ende"), 9);
|
|
|
|
} //if IS == 9
|
|
}//end while
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
//Es werden alle vorhandenen, durch ein Fz mehrspurig verlegte
|
|
//Minensperren abgearbeitet.
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
|
|
while (interne_datenbasis_Fahrspur.iter_modify(1))
|
|
{
|
|
//Suche nach einem Verlegeende einer mehrspurigen, durch ein Fz verlegte
|
|
//Minensperre
|
|
map_test = interne_datenbasis_Fahrspur.size() > 0;
|
|
|
|
while (map_test && interne_datenbasis_Fahrspur.getData()->intstat != 7)
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 7)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Mehrspurige Minensperre, durch ein Fz verlegt, wird berechnet");
|
|
|
|
gesamte_minenanzahl = 0;
|
|
|
|
endpunkt_key = interne_datenbasis_Fahrspur.getKey();
|
|
|
|
anfangspunkt_key = Key_des_zugehoerigen_Verlegebeginns(interne_datenbasis_Fahrspur.getKey());
|
|
//das ist noch nicht der Minensperrenanfang...
|
|
//Suchen nach dem ersten Verlegebeginn der Minensperre
|
|
while (Eintrag_vor_zugehoerigem_Verlegebeginn(interne_datenbasis_Fahrspur.getKey()) == 6)
|
|
{
|
|
anfangspunkt_key = Key_des_zugehoerigen_Verlegebeginns(interne_datenbasis_Fahrspur.getKey());
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
interne_datenbasis_Fahrspur.iter_modify(-1);
|
|
}
|
|
anfangspunkt_key = Key_des_zugehoerigen_Verlegebeginns(interne_datenbasis_Fahrspur.getKey());
|
|
|
|
// Der Anfangspunkt entspricht nun dem Beginn der Minensperre
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
fahrzeug_identitaet =
|
|
interne_datenbasis_Fahrspur.getData()->daten.header.identitaet;
|
|
verlege_anfangszeit =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
verlege_endzeit =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
|
|
//Nun werden die beiden aeusseren Fahrspuren durch ihre Anfangs- u.
|
|
//Endpunkte bestimmt
|
|
erster_endpunkt_key =
|
|
Key_des_zugehoerigen_Verlegeendes(anfangspunkt_key);
|
|
zweiter_anfangspunkt_key =
|
|
Key_des_zugehoerigen_Verlegebeginns(endpunkt_key);
|
|
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeFahrspur(interne_datenbasis_Fahrspur, QStringLiteral("Beginn"), 7);
|
|
KontrollausgabeVerlegedaten(interne_datenbasis_Verlegedaten, QStringLiteral("Beginn"), 7);
|
|
|
|
//Ermitteln der maximal 5 Segmente fuer die zweite Fahrspur
|
|
//Die Funktion legt die Ergebnisse in segmentpunkte ab
|
|
Punktauswahl_fuer_Segmente(
|
|
erster_endpunkt_key, anfangspunkt_key);
|
|
segmentpunkte_zwei = segmentpunkte;
|
|
|
|
//Ermitteln der maximal 5 Segmente fuer die erste Fahrspur
|
|
//Die Funktion legt die Ergebnisse in segmentpunkte ab
|
|
Punktauswahl_fuer_Segmente(
|
|
endpunkt_key, zweiter_anfangspunkt_key);
|
|
segmentpunkte_eins = segmentpunkte;
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Stuetzpunkte fuer die eine Fahrspur wurden gebildet.");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte_eins);
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Stuetzpunkte fuer die andere Fahrspur wurden gebildet.");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte_zwei);
|
|
|
|
|
|
//Aus dem Fahrspurkontainer wird nun ermittelt um wieviele Fahrspuren
|
|
//es sich handelt, die Verlegeendetelegramme sind hierfuer nicht
|
|
//geeignet!! (rein informativ)
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
int anzahl_verlegespur = 1;
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(-1))
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet)
|
|
)
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 6)
|
|
anzahl_verlegespur ++;
|
|
}
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Anzahl der Fahrspuren: %1").arg(anzahl_verlegespur);
|
|
|
|
|
|
//Ermitteln der Parameter der Minensperre durch das Suchen eines
|
|
//Verlegeende-Telegramms
|
|
//im Map-Container interne_datenbasis_Verlegedaten
|
|
parameter_key = anfangspunkt_key; // nur damit er einen gueltigen Wert hat.
|
|
map_test = interne_datenbasis_Verlegedaten.size() > 0;
|
|
int minentyp = -1;
|
|
int erste_verlegeart = -1;
|
|
int zweite_verlegeart = -1;
|
|
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
//juengsten Ende-Eintrag fuer dieses Fz finden, der waehrend oder nach der
|
|
//Verlegeende-MVP gesendet wurde
|
|
//Werden zugehoerige Verlegeende-Telegramme mit unterschiedlichen Minentypen
|
|
//gefunden, wird die Minensperre in mehrere Minensperren geteilt
|
|
while ((map_test) && (parameter_key == anfangspunkt_key))
|
|
{
|
|
//Das erste Verlegeende-Telegramm, das nach dem Zeitpunkt der ermittelten
|
|
//Verlegeende-MVP
|
|
//gesendet wurde, stellt die Parameter fuer diese Minensperre bereit.
|
|
if ((interne_datenbasis_Verlegedaten.getData()->daten.header.identitaet
|
|
== fahrzeug_identitaet) &&
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0))
|
|
{
|
|
if ((interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
< verlege_endzeit)
|
|
&&
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0)
|
|
)
|
|
{
|
|
gesamte_minenanzahl =
|
|
gesamte_minenanzahl + interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
|
|
//Um spaeter die Segmente fahrspurweise verschieben zu koennen, wird
|
|
//die Verlegeart der ersten Fahrspur festhalten.
|
|
if (erste_verlegeart == -1)
|
|
{
|
|
erste_verlegeart = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart;
|
|
}
|
|
//Test auf gleichen Minentyp
|
|
if ((minentyp != -1)
|
|
&&
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//Die letzte Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restlichen MVP werden am Ende des Minenfeldgenerators
|
|
//alle auf 0 gesetzt, so dass sie bei Aufruf des
|
|
//Minenfeldinterpreters neu interpretiert werden koennen.
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da verschiedene Minentypen vorkommen...Neubeginn");
|
|
goto minengenerator_anfang;
|
|
}
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
}
|
|
|
|
if ((interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
>= verlege_endzeit - S_Fahrspur)
|
|
&&
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0)
|
|
)
|
|
{
|
|
parameter_key = interne_datenbasis_Verlegedaten.getKey();
|
|
gesamte_minenanzahl =
|
|
gesamte_minenanzahl + interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
//Um spaeter die Segmente fahrspurweise verschieben zu koennen, wird
|
|
//die Verlegeart der letzten Fahrspur festhalten.
|
|
//Falls die erste Spur keine Parameter erhielt
|
|
if (erste_verlegeart == -1)
|
|
{
|
|
erste_verlegeart = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart;
|
|
}
|
|
|
|
zweite_verlegeart = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart;
|
|
|
|
|
|
//Test auf gleichen Minentyp
|
|
if ((interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//Die letzte Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restlichen MVP werden am Ende des Minenfeldgenerators
|
|
//alle auf 0 gesetzt, so dass sie bei Aufruf des
|
|
//Minenfeldinterpreters neu interpretiert werden koennen.
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da verschiedene Minentypen vorkommen...Neubeginn");
|
|
goto minengenerator_anfang;
|
|
}
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
}
|
|
}
|
|
map_test = interne_datenbasis_Verlegedaten.iter_modify(1);
|
|
}
|
|
|
|
if (parameter_key != anfangspunkt_key)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Parameter fuer mehrspurige durch ein Fz angelegte Minensperre gefunden. ");
|
|
|
|
|
|
//VERSCHIEBEN DER SEGMENTE DER ERSTEN FAHRSPUR
|
|
segmentpunkte_eins.iter_reset();
|
|
segmente_eins.clear();
|
|
do
|
|
{
|
|
segment.startpunkt = segmentpunkte_eins.getData()->daten.gps_position;
|
|
|
|
segmente_eins.eintrag_container(segmentpunkte_eins.getKey(), segment);
|
|
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Startpunkt eines Segmentes
|
|
//bleibt aber als Hilfspunkt mit erhalten
|
|
//segmente_eins.iter_modify(-1);
|
|
//segmente_eins.loeschen_eintrag_container(*segmente_eins.getKey());
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte_eins immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente_eins.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte_eins.finden_eintrag_container(segmente_eins.getKey());
|
|
segmentpunkte_eins.iter_modify(1);
|
|
segmente_eins.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente_eins.getData()->startpunkt.utm_ostwert,
|
|
segmente_eins.getData()->startpunkt.utm_nordwert,
|
|
segmentpunkte_eins.getData()->
|
|
daten.gps_position.utm_ostwert,
|
|
segmentpunkte_eins.getData()->
|
|
daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente_eins.getData()->anzahl =
|
|
Punktabstand(segmente_eins.getData()->startpunkt,
|
|
segmentpunkte_eins.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente_eins.getData()->anzahl;
|
|
}
|
|
while (segmente_eins.iter_modify(1));
|
|
|
|
//Der Hilfspunkt wird mit dem selben Winkel versehen, wie der Vorgaenger,
|
|
//da er genauso verschoben werden soll
|
|
segmente_eins.iter_modify(-1);
|
|
hilfswinkel_eins = segmente_eins.getData()->drehwinkel;
|
|
segmente_eins.iter_modify(1);
|
|
segmente_eins.getData()->drehwinkel = hilfswinkel_eins;
|
|
segmente_eins.getData()->anzahl = 0;
|
|
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Segmente der einen Fahrspur berechnet... (das letzte Segment ist nur ein Hilfssegment) ");
|
|
map_test = segmente_eins.size() > 0;
|
|
segmente_eins.iter_reset();
|
|
while (map_test)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2 Winkel: %3 Laenge: %4").arg(segmente_eins.getData()->startpunkt.utm_ostwert).arg(segmente_eins.getData()->startpunkt.utm_nordwert).arg(segmente_eins.getData()->drehwinkel).arg(segmente_eins.getData()->anzahl);
|
|
map_test = segmente_eins.iter_modify(1);
|
|
}
|
|
|
|
//Die Startpunkte der Segmente muessen dann verschoben werden, wenn die
|
|
//Verlegeart links oder rechts ist
|
|
//Die Verlegeart der ersten Fahrspur steht in erste_verlegeart
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Ausstossart der ersten Fahrspur: %1").arg(erste_verlegeart);
|
|
|
|
segmente = segmente_eins;
|
|
|
|
switch (erste_verlegeart)
|
|
{
|
|
case 0: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_MVAH / 2; //Mitte, nur MVAH ;
|
|
break;
|
|
case 1: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS / 2; //Rechts
|
|
verschiebe_Fahrspursegmente('r',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 2: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS / 2; //Links
|
|
verschiebe_Fahrspursegmente('l',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 3: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS; //Rechts&Links
|
|
break;
|
|
default: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_MVAH;
|
|
|
|
}
|
|
|
|
segmente_eins = segmente;
|
|
segmente.clear();
|
|
|
|
|
|
//VERSCHIEBEN DER SEGMENTE DER ZWEITEN FAHRSPUR
|
|
segmentpunkte_zwei.iter_reset();
|
|
segmente_zwei.clear();
|
|
do
|
|
{
|
|
segment.startpunkt = segmentpunkte_zwei.getData()->daten.gps_position;
|
|
|
|
segmente_zwei.eintrag_container(segmentpunkte_zwei.getKey(), segment);
|
|
|
|
}
|
|
while (segmentpunkte_zwei.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Startpunkt eines Segmentes
|
|
//bleibt aber als Hilfspunkt mit erhalten
|
|
//segmente_zwei.iter_modify(-1);
|
|
//segmente_zwei.loeschen_eintrag_container(*segmente_zwei.getKey());
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte_zwei immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente_zwei.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte_zwei.finden_eintrag_container(segmente_zwei.getKey());
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
segmente_zwei.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente_zwei.getData()->startpunkt.utm_ostwert,
|
|
segmente_zwei.getData()->startpunkt.utm_nordwert,
|
|
segmentpunkte_zwei.getData()->
|
|
daten.gps_position.utm_ostwert,
|
|
segmentpunkte_zwei.getData()->
|
|
daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente_zwei.getData()->anzahl =
|
|
Punktabstand(segmente_zwei.getData()->startpunkt,
|
|
segmentpunkte_zwei.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente_zwei.getData()->anzahl;
|
|
}
|
|
while (segmente_zwei.iter_modify(1));
|
|
//Der Hilfspunkt wird mit dem selben Winkel versehen, wie der Vorgaenger,
|
|
//da er genauso verschoben werden soll
|
|
segmente_zwei.iter_modify(-1);
|
|
hilfswinkel_zwei = segmente_zwei.getData()->drehwinkel;
|
|
segmente_zwei.iter_modify(1);
|
|
segmente_zwei.getData()->drehwinkel = hilfswinkel_zwei;
|
|
segmente_zwei.getData()->anzahl = 0;
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Segmente der anderen Fahrspur berechnet... (das letzte Segment ist nur ein Hilfssegment) ");
|
|
map_test = segmente_zwei.size() > 0;
|
|
segmente_zwei.iter_reset();
|
|
while (map_test)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2 Winkel: %3 Laenge: %4").arg(segmente_zwei.getData()->startpunkt.utm_ostwert).arg(segmente_zwei.getData()->startpunkt.utm_nordwert).arg(segmente_zwei.getData()->drehwinkel).arg(segmente_zwei.getData()->anzahl);
|
|
map_test = segmente_zwei.iter_modify(1);
|
|
}
|
|
|
|
//Die Startpunkte der Segmente muessen dann verschoben werden, wenn die
|
|
//Verlegeart links oder rechts ist
|
|
//Die Verlegeart der letzten Fahrspur steht in zweite_verlegeart
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Ausstossart der zweiten Fahrspur: %1").arg(zweite_verlegeart);
|
|
|
|
segmente = segmente_zwei;
|
|
|
|
switch (zweite_verlegeart)
|
|
{
|
|
case 0: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_MVAH / 2; //Mitte, nur MVAH ;
|
|
break;
|
|
case 1: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_WMVS / 2; //Rechts
|
|
verschiebe_Fahrspursegmente('r',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 2: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_WMVS / 2; //Links
|
|
verschiebe_Fahrspursegmente('l',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 3: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_WMVS; //Rechts&Links
|
|
break;
|
|
default: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_MVAH;
|
|
|
|
}
|
|
|
|
segmente_zwei = segmente;
|
|
segmente.clear();
|
|
|
|
|
|
//NUN SIND DIE SEGMENTANFANGSPUNKTE DER EINZELNEN FAHRSPUREN VERSCHOBEN
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("verschobene Segmente der einen Fahrspur berechnet... ");
|
|
map_test = segmente_eins.size() > 0;
|
|
segmente_eins.iter_reset();
|
|
while (map_test)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2 Winkel: %3 Laenge: %4").arg(segmente_eins.getData()->startpunkt.utm_ostwert).arg(segmente_eins.getData()->startpunkt.utm_nordwert).arg(segmente_eins.getData()->drehwinkel).arg(segmente_eins.getData()->anzahl);
|
|
map_test = segmente_eins.iter_modify(1);
|
|
}
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("verschobeneSegmente der anderen Fahrspur berechnet... ");
|
|
map_test = segmente_zwei.size() > 0;
|
|
segmente_zwei.iter_reset();
|
|
while (map_test)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2 Winkel: %3 Laenge: %4").arg(segmente_zwei.getData()->startpunkt.utm_ostwert).arg(segmente_zwei.getData()->startpunkt.utm_nordwert).arg(segmente_zwei.getData()->drehwinkel).arg(segmente_zwei.getData()->anzahl);
|
|
map_test = segmente_zwei.iter_modify(1);
|
|
}
|
|
|
|
//Die Endpunkte der Fahrspuren werden benoetigt, um alle verschobenen
|
|
//Werte wieder in die map-container segmentpunkte_eins und
|
|
//segmentpunkte_zwei einzutragen dazu dienen die beiden Hilfspunkte.
|
|
|
|
segmentpunkte_eins.clear();
|
|
segmente_eins.iter_reset();
|
|
do
|
|
{
|
|
segmentstartpunkt.daten.gps_position = segmente_eins.getData()->startpunkt;
|
|
|
|
segmentpunkte_eins.eintrag_container(segmente_eins.getKey(),
|
|
segmentstartpunkt);
|
|
}
|
|
while (segmente_eins.iter_modify(1));
|
|
segmente_eins.clear();
|
|
|
|
segmentpunkte_zwei.clear();
|
|
segmente_zwei.iter_reset();
|
|
do
|
|
{
|
|
segmentstartpunkt.daten.gps_position = segmente_zwei.getData()->startpunkt;
|
|
|
|
segmentpunkte_zwei.eintrag_container(segmente_zwei.getKey(),
|
|
segmentstartpunkt);
|
|
}
|
|
while (segmente_zwei.iter_modify(1));
|
|
segmente_zwei.clear();
|
|
|
|
|
|
|
|
//Nun muss die Anzahl der Punkte angepasst werden, so dass beide
|
|
//Verlegespuren die gleiche Anzahl von Stuetzpunkten aufweisen.
|
|
//Dabei wird nach folgendem Algorithmus verfahren:
|
|
//1.Ist die Anzahl der Streckenpunkte der Verlegespuren verschieden, so
|
|
// wird die Verlegespur mit der hoeheren Anzahl ausgewaehlt, und in jedem
|
|
// Streckenpunkt, ausser dem Anfangs- und dem Endpunkt, eine
|
|
// winkelhalbierende Gerade berechnet, die einen Schnittpunkt mit einem
|
|
// der Strecken der gegenueberliegenden Verlegespur, bildet. Ist dieser
|
|
// Schnittpunkt auf Grund der besonderen Form der Verlegespur nicht
|
|
// vorhanden, so wird der Anfangs- oder der Endpunkt - je nach dem
|
|
// welcher naeher an der Winkelhalbierenden liegt, als Schnittpunkt
|
|
// angenommen.
|
|
//2.Der zwischen Winkelhalbierender und Strecke gebildete Schnittpunkt,
|
|
// der am weitesten von einem bereits existiernden Streckenpunkt der
|
|
// Verlegespur entfernt ist, wird als zusaetzlicher Streckenpunkt
|
|
// eingefuegt. Trifft dieser Punkt mit einem bereits bestehenden
|
|
// Streckenpunkt zusammen, muss dessen Wertigkeitszaehler erhoeht
|
|
// werden. Ist die Anzahl der Streckenpunkte (die Wertigkeitszaehler
|
|
// muessen beruecksichtigt werden) beider Verlegespuren noch nicht
|
|
// gleich, dann nocheinmal 2.
|
|
//3.An dieser Stelle ist die Anzahl der Streckenpunkte beider
|
|
// Verlegespuren gleich, auch wenn nicht alle Streckenpunkte der einen
|
|
// Verlegespur oertlich verschieden sein muessen (Wertigkeitszaehler).
|
|
// Nun werden die Mittelpunkte jeweils zwei gegenueberliegender
|
|
// Streckenpunkte berechnet und als Segmentpunkt interpretiert, wonach
|
|
// die herangezogenen Streckenpunkte gelowscht werden bzw. ihr
|
|
// Wertigkeiszaehler erniedigt wird. Dabei wird je Verlegespur nach
|
|
// entweder steigender oder fallender zeitlicher Reihenfolge der
|
|
// Eintraege vorgegangen.
|
|
// Es wird mit den beiden Punkten begonnen, die Anfangs- oder Endpunkte
|
|
// bilden(IS!=2) und oertlich am nahesten zusammenliegen.
|
|
|
|
|
|
if (segmentpunkte_eins.size() != segmentpunkte_zwei.size())
|
|
{
|
|
//Die beiden map-container werden so umkopiert, dass der Inhalt mit
|
|
//den meisten Eintraegen in segmentpunkte_zwei steht.
|
|
if (segmentpunkte_zwei.size() < segmentpunkte_eins.size())
|
|
{
|
|
segmentpunkte = segmentpunkte_zwei;
|
|
segmentpunkte_zwei = segmentpunkte_eins;
|
|
segmentpunkte_eins = segmentpunkte;
|
|
}
|
|
//Nun werden die moeglichen neuen Stuetzpunkte berechnet
|
|
//und in dem map-container schnittpunkte abgelegt
|
|
|
|
for (size_t i = 0; i < segmentpunkte_zwei.size() - 2; i++)
|
|
{
|
|
int P1x, P1y, P2x, P2y, P3x, P3y;
|
|
int Ax, Ay, Bx, By;
|
|
float sx, sy;
|
|
|
|
//Der Iterator muss auf den ersten Punkt des Winkels
|
|
segmentpunkte_zwei.iter_reset();
|
|
for (size_t j = 0; j < i; j++)
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
|
|
P1x = segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert;
|
|
P1y = segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
P2x = segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert;
|
|
P2y = segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
P3x = segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert;
|
|
P3y = segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_eins.iter_reset();
|
|
Ax = segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert;
|
|
Ay = segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_eins.iter_modify(1);
|
|
Bx = segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert;
|
|
By = segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert;
|
|
|
|
Schnittpunkt_Winkelhalbierende_Strecke(
|
|
P1x, P1y, P2x, P2y, P3x, P3y,
|
|
Ax, Ay, Bx, By, &sx, &sy);
|
|
|
|
schnittpkt.daten.gps_position.utm_ostwert = lrint(sx);
|
|
schnittpkt.daten.gps_position.utm_nordwert = lrint(sy);
|
|
|
|
schnittpunkte.eintrag_container(segmentpunkte_zwei.getKey(), schnittpkt);
|
|
}
|
|
|
|
//Kontrollausgabe
|
|
//schnittpunkte.iter_reset();
|
|
//do
|
|
//{
|
|
// lout << setprio(LM_INFO)
|
|
// << "ein Schnittpunkt:"
|
|
// << schnittpunkte.getData()->daten.gps_position.utm_ostwert
|
|
// << "/" << schnittpunkte.getData()->daten.gps_position.utm_nordwert
|
|
// << endl;
|
|
//} while (schnittpunkte.iter_modify(1));
|
|
|
|
|
|
|
|
//Aus den gefundenen Schnittpunkten werden die erforderlichen
|
|
//ausgewaehlt, und in segmentpunkte_eins eingetragen. Es sind mindestens
|
|
//soviel Eintraege in schnittpunkte wie benoetigt werden.
|
|
//Es wird immer der Eintrag herangezogen, der am weitesten von einem
|
|
//bereits vorhandenen Eintrag in segmentpunkte entfernt ist
|
|
//Achtung! Die Eintraege in segmentpunkte_eins sind dann nicht wirklich
|
|
//chronologisch sortiert
|
|
VERLEGEDATEN_KEY groesster_abstand_key;
|
|
while (segmentpunkte_zwei.size() > segmentpunkte_eins.size())
|
|
{
|
|
int groesster_abstand = 0;
|
|
segmentpunkte_eins.iter_reset();
|
|
do
|
|
{
|
|
schnittpunkte.iter_reset();
|
|
do
|
|
{
|
|
int curAbstand = Punktabstand(
|
|
schnittpunkte.getData()->daten.gps_position,
|
|
segmentpunkte_eins.getData()->daten.gps_position);
|
|
if (groesster_abstand < curAbstand)
|
|
{
|
|
groesster_abstand = curAbstand;
|
|
groesster_abstand_key = schnittpunkte.getKey();
|
|
}
|
|
}
|
|
while (schnittpunkte.iter_modify(1));
|
|
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1));
|
|
|
|
schnittpunkte.finden_eintrag_container(groesster_abstand_key);
|
|
segmentpunkte_eins.eintrag_container(groesster_abstand_key,
|
|
*schnittpunkte.getData());
|
|
schnittpunkte.loeschen_eintrag_container(groesster_abstand_key);
|
|
}
|
|
}
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Die ausgewaehlten Stuetzpunkte fuer die glattere Fahrspur:");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte_eins);
|
|
|
|
//Sortieren des map-containers segmentpunkte_eins nach den am nahest
|
|
//gelegenen Eintraegen in segmentpunkte_zwei
|
|
segmentpunkte_zwei.iter_reset();
|
|
int kleinster_abstand;
|
|
VERLEGEDATEN_KEY kleinster_abstand_key;
|
|
FAHRSPUR_INTERN punktdaten;
|
|
VERLEGEDATEN_KEY punktkey;
|
|
punktkey.zeitpunkt.gps_zeit = 0;
|
|
do
|
|
{
|
|
kleinster_abstand = 1000000;
|
|
segmentpunkte_eins.iter_reset();
|
|
do
|
|
{
|
|
int curAbstand = Punktabstand(segmentpunkte_zwei.getData()->daten.gps_position,
|
|
segmentpunkte_eins.getData()->daten.gps_position);
|
|
if (curAbstand < kleinster_abstand)
|
|
{
|
|
kleinster_abstand = curAbstand;
|
|
kleinster_abstand_key = segmentpunkte_eins.getKey();
|
|
}
|
|
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1));
|
|
|
|
segmentpunkte_eins.finden_eintrag_container(kleinster_abstand_key);
|
|
punktdaten = *segmentpunkte_eins.getData();
|
|
//generieren eines eigenen Keys erforderlich
|
|
punktkey.fz_id = 0;
|
|
punktkey.zeitpunkt.gps_zeit += 1;
|
|
//lout << "generierter Key: " << punktkey.zeitpunkt.gps_zeit <<endl;
|
|
segmentpunkte_eins.eintrag_container(punktkey, punktdaten);
|
|
|
|
|
|
}
|
|
while (segmentpunkte_zwei.iter_modify(1));
|
|
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Die sortierten Stuetzpunkte der glatteren Fahrspur: ");
|
|
segmentpunkte_zwei.iter_reset();//in _eins sind mehr Eintraege!
|
|
segmentpunkte_eins.iter_reset();
|
|
do
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2").arg(segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert).arg(segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert);
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1)
|
|
&&
|
|
segmentpunkte_zwei.iter_modify(1));
|
|
|
|
|
|
//Berechnung des weitesten Abstandes der Segmente
|
|
//wird fuer die Verlegebreite benoetigt
|
|
|
|
segmentpunkte_eins.iter_reset();
|
|
segmentpunkte_zwei.iter_reset();
|
|
do
|
|
{
|
|
int curAbstand = Punktabstand(
|
|
segmentpunkte_eins.getData()->daten.gps_position,
|
|
segmentpunkte_zwei.getData()->daten.gps_position);
|
|
if (groesster_spurabstand < curAbstand)
|
|
groesster_spurabstand = curAbstand;
|
|
}
|
|
while ((segmentpunkte_eins.iter_modify(1))
|
|
&& (segmentpunkte_zwei.iter_modify(1)));
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Groesster Spurabstand: %1").arg(groesster_spurabstand);
|
|
|
|
//Nun sind in den beiden segmentpunkte-map-containern gleichviele Eintraege
|
|
//deren jeweiligen Mittelpunkte die Segmentpunkte bilden sollen
|
|
//Diese Mittelpunkte werden in segmentpunkte eingetragen
|
|
segmentpunkte.clear();
|
|
segmentpunkte_eins.iter_reset();
|
|
segmentpunkte_zwei.iter_reset();
|
|
do
|
|
{
|
|
segmentstartpunkt.daten.gps_position.utm_ostwert =
|
|
(segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert
|
|
+ segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert) / 2;
|
|
segmentstartpunkt.daten.gps_position.utm_nordwert =
|
|
(segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert
|
|
+ segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert) / 2;
|
|
|
|
segmentpunkte.eintrag_container(segmentpunkte_zwei.getKey(),
|
|
segmentstartpunkt);
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1)
|
|
&& segmentpunkte_zwei.iter_modify(1));
|
|
|
|
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Die endgueltigen Segmentstuetzpunkte sind folgende:");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte);
|
|
|
|
//BERECHNEN DER ENDGUELTIGEN SEGMENTE DES MINENSPERRENMODELLS
|
|
segmentpunkte.iter_reset();
|
|
segmente.clear();
|
|
do
|
|
{
|
|
segment.startpunkt = segmentpunkte.getData()->daten.gps_position;
|
|
|
|
segmente.eintrag_container(segmentpunkte.getKey(), segment);
|
|
|
|
}
|
|
while (segmentpunkte.iter_modify(1));
|
|
|
|
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte.finden_eintrag_container(segmente.getKey());
|
|
segmentpunkte.iter_modify(1);
|
|
segmente.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente.getData()->startpunkt.utm_ostwert,
|
|
segmente.getData()->startpunkt.utm_nordwert,
|
|
segmentpunkte.getData()->daten.gps_position.utm_ostwert,
|
|
segmentpunkte.getData()->daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente.getData()->anzahl =
|
|
Punktabstand(segmente.getData()->startpunkt,
|
|
segmentpunkte.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente.getData()->anzahl;
|
|
}
|
|
while (segmente.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Segment und wird geloescht
|
|
segmente.loeschen_eintrag_container(segmente.getKey());
|
|
|
|
|
|
segmentparameter = segmente;
|
|
|
|
//Ersetzen der Segmentlaengen durch die Anzahl der Minen
|
|
segmentparameter.iter_reset();
|
|
rest = 0;
|
|
minenzaehler = 0;
|
|
do
|
|
{
|
|
//Der Rest darf nicht verloren gehen, sondern muss dem naechsten
|
|
//Segment zugerechnet, bzw abgerechnet werden, da die Summe der Minen
|
|
//exakt die Gesamtmenge ergeben soll!
|
|
float f_anzahl = float((segmentparameter.getData()->
|
|
anzahl + rest) / gesamte_verlege_strecke)
|
|
* gesamte_minenanzahl;
|
|
rest = f_anzahl - int(f_anzahl + 0.5);
|
|
segmentparameter.getData()->anzahl = int(f_anzahl + 0.5);
|
|
minenzaehler = minenzaehler + segmentparameter.getData()->anzahl;
|
|
}
|
|
while (segmentparameter.iter_modify(1));
|
|
//Bei dem letzten Segment werden lediglich die Rundungsfehler
|
|
//ausgeglichen.
|
|
//Iterator steht bereits auf dem letzten Eintrag
|
|
segmentparameter.getData()->anzahl =
|
|
segmentparameter.getData()->anzahl + (gesamte_minenanzahl - minenzaehler);
|
|
|
|
|
|
interne_datenbasis_Verlegedaten.finden_eintrag_container(parameter_key);
|
|
//sperrenmodell.kennung = ;
|
|
//sperrenmodell.bezeichner =;
|
|
sperrenmodell.wirkbeginn =
|
|
interne_datenbasis_Verlegedaten.getData()->daten.verlegedaten.wirkbeginn;
|
|
sperrenmodell.wirkdauer =
|
|
interne_datenbasis_Verlegedaten.getData()->daten.verlegedaten.wirkzeit;
|
|
sperrenmodell.eckpunkt.utm_ostwert = 0;
|
|
sperrenmodell.eckpunkt.utm_nordwert = 0;
|
|
sperrenmodell.wirkfeldbreite = 0;
|
|
sperrenmodell.wirkfeldtiefe = 0;
|
|
|
|
sperrenmodell.verlegetiefe += groesster_spurabstand;
|
|
|
|
//verlegedichte entspricht Minen je 10 Meter
|
|
// sperrenmodell.verlegedichte = 6; //default
|
|
// if((gesamte_minenanzahl)*100/gesamte_verlege_strecke <
|
|
// 65){sperrenmodell.verlegedichte = 6;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 55){sperrenmodell.verlegedichte = 5;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 45){sperrenmodell.verlegedichte = 4;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 35){sperrenmodell.verlegedichte = 3;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 25){sperrenmodell.verlegedichte = 2;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 15){sperrenmodell.verlegedichte = 1;}
|
|
//Hier der Test ob die Fahrspuren ueberhaupt zusammengehoeren koennen
|
|
//Die Verlegedichte darf nicht ueber 6 Minen/10 Meter liegen!
|
|
sperrenmodell.verlegedichte = lrint(((double)gesamte_minenanzahl / gesamte_verlege_strecke * FAKTOR_VERLEGEDICHTE));
|
|
if (sperrenmodell.verlegedichte > max_verlegedichte * FAKTOR_VERLEGEDICHTE)
|
|
sperrenmodell.verlegedichte = lrint(max_verlegedichte * FAKTOR_VERLEGEDICHTE);
|
|
else if (sperrenmodell.verlegedichte < 1)
|
|
sperrenmodell.verlegedichte = 1;
|
|
INFO_LOG(m_logger) << QStringLiteral("verlegedichte = %1 anz=%2 strecke=%3").arg(sperrenmodell.verlegedichte).arg(gesamte_minenanzahl).arg(gesamte_verlege_strecke);
|
|
if ((gesamte_minenanzahl * 100) / gesamte_verlege_strecke >
|
|
max_verlegedichte * 100 + 50 / FAKTOR_VERLEGEDICHTE)
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//Die letzte Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restlichen MVP werden am Ende des Minenfeldgenerators
|
|
//alle auf 0 gesetzt, so dass sie bei Aufruf des
|
|
//Minenfeldinterpreters neu interpretiert werden koennen.
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da die Minendichte %1 uebersteigt...Neubeginn").arg(max_verlegedichte);
|
|
goto minengenerator_anfang;
|
|
}
|
|
|
|
sperrenmodell.minentyp =
|
|
interne_datenbasis_Verlegedaten.getData()->daten.verlegedaten.minentyp;
|
|
sperrenmodell.minenanzahl = gesamte_minenanzahl;
|
|
|
|
|
|
sperrenmodell.segmente.reserve(segmentparameter.size());
|
|
for (const auto &val : segmentparameter.c())
|
|
sperrenmodell.segmente.push_back(val.second);
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Mehrspuriges Minensperrenmodell (ein Fz) wurde erstellt. Wirkbeginn:%1 Wirkdauer:%2 Eckpunkt:%3 %4 Wirkfeldbreite:%5 Wirkfeldtiefe:%6 Verlegetiefe:%7 Verlegedichte:%8 Minentyp:%9 Minenanzahl:%10 Segmentanzahl:%11").arg(sperrenmodell.wirkbeginn.gps_zeit).arg(sperrenmodell.wirkdauer).arg(sperrenmodell.eckpunkt.utm_ostwert).arg(sperrenmodell.eckpunkt.utm_nordwert).arg(sperrenmodell.wirkfeldbreite).arg(sperrenmodell.wirkfeldtiefe).arg(sperrenmodell.verlegetiefe).arg(sperrenmodell.verlegedichte).arg(sperrenmodell.minentyp).arg(sperrenmodell.minenanzahl).arg(sperrenmodell.segmente.size());
|
|
KontrollausgabeSegmente(sperrenmodell.segmente);
|
|
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart == 0)
|
|
Fz_art = 1;
|
|
else
|
|
Fz_art = 2;
|
|
|
|
//Aufruf des Construktors(sperrenmodell, fahrzeug_identitaet, Fz_art)
|
|
telegramm.beschreibung.kennung = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.sperren_id;
|
|
|
|
telegramm.header.identitaet = fahrzeug_identitaet;
|
|
|
|
emit sendeWirkfeld(telegramm, Fz_art);
|
|
sperrenmodell.segmente.clear();
|
|
}
|
|
else
|
|
WARNING_LOG(m_logger) << QStringLiteral("Minensperre ohne Parameter!");
|
|
|
|
//Alle Fahrspureintraege dieser Minensperre werden geloescht
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
anfangspunkt_key);
|
|
do
|
|
{
|
|
interne_datenbasis_Fahrspur.iter_erase();
|
|
}
|
|
while (interne_datenbasis_Fahrspur.contains(endpunkt_key));
|
|
|
|
//Die Verlegedaten der Minensperre werden geloescht
|
|
if (interne_datenbasis_Verlegedaten.finden_eintrag_container(
|
|
parameter_key))
|
|
{
|
|
do
|
|
{
|
|
interne_datenbasis_Verlegedaten.finden_eintrag_container(
|
|
parameter_key);
|
|
map_test = interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
fz_test = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet;
|
|
if ((fz_test) && (map_test))
|
|
{
|
|
interne_datenbasis_Verlegedaten.loeschen_eintrag_container(interne_datenbasis_Verlegedaten.getKey());
|
|
}
|
|
}
|
|
while (fz_test && map_test);
|
|
}
|
|
//Nun noch den parameter-Eintrag
|
|
if (interne_datenbasis_Verlegedaten.finden_eintrag_container(
|
|
parameter_key))
|
|
{
|
|
interne_datenbasis_Verlegedaten.loeschen_eintrag_container(interne_datenbasis_Verlegedaten.getKey());
|
|
}
|
|
|
|
|
|
segmentparameter.clear();
|
|
segmentpunkte.clear();
|
|
segmentpunkte_zwei.clear();
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeFahrspur(interne_datenbasis_Fahrspur, QStringLiteral("Ende"), 7);
|
|
KontrollausgabeVerlegedaten(interne_datenbasis_Verlegedaten, QStringLiteral("Ende"), 7);
|
|
|
|
} //if IS == 7
|
|
|
|
}//end while
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
//Es wird die maximal eine, durch mehrere Fz verlegte
|
|
//Minensperren abgearbeitet.
|
|
//(Der Interpreter liefert maximal eine solche Minensperre)
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
//Zunaechst muss geklaert werden, welche Fahrspuren am weitesten auseinander
|
|
//liegen, da diese die Form des Minensperrenmodells bestimmen
|
|
//wird kein Eintrag mit IS 11 gefunden wird der Minenfeldgenerator beendet
|
|
int minentyp = -1;
|
|
int erste_verlegeart = 0;
|
|
int zweite_verlegeart = 0;
|
|
int dritte_verlegeart = 0;
|
|
int groesster_fahrspurabstand = 0;
|
|
VERLEGEDATEN_KEY erster_endeeintrag_key;
|
|
VERLEGEDATEN_KEY zweiter_endeeintrag_key;
|
|
//VERLEGEDATEN_KEY dritter_endeeintrag_key;
|
|
VERLEGEDATEN_KEY erster_endeeintrag_key_copy;
|
|
VERLEGEDATEN_KEY zweiter_endeeintrag_key_copy;
|
|
VERLEGEDATEN_KEY dritter_endeeintrag_key_copy;
|
|
|
|
//FAHRSPUR_INTERN erster_endeeintrag_daten;
|
|
//FAHRSPUR_INTERN zweiter_endeeintrag_daten;
|
|
//FAHRSPUR_INTERN dritter_endeeintrag_daten;
|
|
FAHRSPUR_INTERN erster_endeeintrag_daten_copy;
|
|
FAHRSPUR_INTERN zweiter_endeeintrag_daten_copy;
|
|
FAHRSPUR_INTERN dritter_endeeintrag_daten_copy;
|
|
|
|
//erster_endeeintrag_daten.daten.header.identitaet = -1;
|
|
//zweiter_endeeintrag_daten.daten.header.identitaet = -1;
|
|
//dritter_endeeintrag_daten.daten.header.identitaet = -1;
|
|
erster_endeeintrag_daten_copy.daten.header.identitaet = 0;
|
|
zweiter_endeeintrag_daten_copy.daten.header.identitaet = 0;
|
|
dritter_endeeintrag_daten_copy.daten.header.identitaet = 0;
|
|
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
map_test = interne_datenbasis_Fahrspur.size() > 0;
|
|
while (map_test && interne_datenbasis_Fahrspur.getData()->intstat != 11)
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
if (map_test)
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Minensperre, durch mehrere Fz verlegt, wird berechnet");
|
|
gesamte_minenanzahl = 0;
|
|
erster_endeeintrag_key = interne_datenbasis_Fahrspur.getKey();
|
|
erster_endeeintrag_key_copy = interne_datenbasis_Fahrspur.getKey();
|
|
//erster_endeeintrag_daten = *interne_datenbasis_Fahrspur.getData();
|
|
erster_endeeintrag_daten_copy = *interne_datenbasis_Fahrspur.getData();
|
|
}
|
|
else
|
|
goto minenfeldgenerator_ende;
|
|
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
while (map_test && interne_datenbasis_Fahrspur.getData()->intstat != 11)
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
if (map_test)
|
|
{
|
|
zweiter_endeeintrag_key = interne_datenbasis_Fahrspur.getKey();
|
|
zweiter_endeeintrag_key_copy = interne_datenbasis_Fahrspur.getKey();
|
|
//zweiter_endeeintrag_daten = *interne_datenbasis_Fahrspur.getData();
|
|
zweiter_endeeintrag_daten_copy = *interne_datenbasis_Fahrspur.getData();
|
|
}
|
|
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
while (map_test && interne_datenbasis_Fahrspur.getData()->intstat != 11)
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(1);
|
|
if (map_test)
|
|
{
|
|
//dritter_endeeintrag_key = *interne_datenbasis_Fahrspur.getKey();
|
|
dritter_endeeintrag_key_copy = interne_datenbasis_Fahrspur.getKey();
|
|
//dritter_endeeintrag_daten = *interne_datenbasis_Fahrspur.getData();
|
|
dritter_endeeintrag_daten_copy = *interne_datenbasis_Fahrspur.getData();
|
|
}
|
|
|
|
|
|
groesster_fahrspurabstand =
|
|
Punktabstand(erster_endeeintrag_daten_copy.daten.gps_position,
|
|
zweiter_endeeintrag_daten_copy.daten.gps_position);
|
|
|
|
if (map_test) //dann gibt es einen dritten Eintrag
|
|
{
|
|
int curAbstand = Punktabstand(zweiter_endeeintrag_daten_copy.daten.gps_position,
|
|
dritter_endeeintrag_daten_copy.daten.gps_position);
|
|
if (curAbstand > groesster_fahrspurabstand)
|
|
{
|
|
groesster_fahrspurabstand = curAbstand;
|
|
erster_endeeintrag_key = zweiter_endeeintrag_key_copy;
|
|
//erster_endeeintrag_daten = zweiter_endeeintrag_daten_copy;
|
|
zweiter_endeeintrag_key = dritter_endeeintrag_key_copy;
|
|
//zweiter_endeeintrag_daten = dritter_endeeintrag_daten_copy;
|
|
//dritter_endeeintrag_key = erster_endeeintrag_key_copy;
|
|
//dritter_endeeintrag_daten = erster_endeeintrag_daten_copy;
|
|
}
|
|
|
|
curAbstand = Punktabstand(dritter_endeeintrag_daten_copy.daten.gps_position,
|
|
erster_endeeintrag_daten_copy.daten.gps_position);
|
|
if (curAbstand > groesster_fahrspurabstand)
|
|
{
|
|
groesster_fahrspurabstand = curAbstand;
|
|
|
|
zweiter_endeeintrag_key = erster_endeeintrag_key_copy;
|
|
//zweiter_endeeintrag_daten = erster_endeeintrag_daten_copy;
|
|
erster_endeeintrag_key = dritter_endeeintrag_key_copy;
|
|
//erster_endeeintrag_daten = dritter_endeeintrag_daten_copy;
|
|
//dritter_endeeintrag_key = zweiter_endeeintrag_key_copy;
|
|
//dritter_endeeintrag_daten = zweiter_endeeintrag_daten_copy;
|
|
}
|
|
}
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Groesster Fahrspurabstand: %1").arg(groesster_fahrspurabstand);
|
|
|
|
|
|
ausstattungs_id_t fahrzeug_identitaet_eins;
|
|
ausstattungs_id_t fahrzeug_identitaet_zwei;
|
|
ausstattungs_id_t fahrzeug_identitaet_drei;
|
|
fahrzeug_identitaet_eins =
|
|
erster_endeeintrag_daten_copy.daten.header.identitaet;
|
|
fahrzeug_identitaet_zwei =
|
|
zweiter_endeeintrag_daten_copy.daten.header.identitaet;
|
|
fahrzeug_identitaet_drei =
|
|
dritter_endeeintrag_daten_copy.daten.header.identitaet;
|
|
|
|
|
|
//Nun werden die beiden aeusseren Fahrspuren durch ihre Anfangs- u.
|
|
//Endpunkte bestimmt
|
|
|
|
endpunkt_key = zweiter_endeeintrag_key;
|
|
erster_endpunkt_key = erster_endeeintrag_key;
|
|
//mittlerer_endpunkt_key = dritter_endeeintrag_key;
|
|
|
|
anfangspunkt_key =
|
|
Key_des_zugehoerigen_Verlegebeginns(erster_endpunkt_key);
|
|
zweiter_anfangspunkt_key =
|
|
Key_des_zugehoerigen_Verlegebeginns(endpunkt_key);
|
|
//mittlerer_anfangspunkt_key =
|
|
// Key_des_zugehoerigen_Verlegebeginns(mittlerer_endpunkt_key);
|
|
|
|
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
//die Identitaet und andere Daten werden von einem der aussen fahrenden Fz
|
|
//registriert
|
|
fahrzeug_identitaet =
|
|
interne_datenbasis_Fahrspur.getData()->daten.header.identitaet;
|
|
verlege_anfangszeit =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
verlege_endzeit =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeFahrspur(interne_datenbasis_Fahrspur, QStringLiteral("Beginn"), 11);
|
|
KontrollausgabeVerlegedaten(interne_datenbasis_Verlegedaten, QStringLiteral("Beginn"), 11);
|
|
|
|
//Ermitteln der maximal 5 Segmente fuer die eine Fahrspur
|
|
//Die Funktion legt die Ergebnisse in segmentpunkte ab
|
|
Punktauswahl_fuer_Segmente(
|
|
erster_endpunkt_key, anfangspunkt_key);
|
|
segmentpunkte_eins = segmentpunkte;
|
|
|
|
//Ermitteln der maximal 5 Segmente fuer die andere Fahrspur
|
|
//Die Funktion legt die Ergebnisse in segmentpunkte ab
|
|
Punktauswahl_fuer_Segmente(
|
|
endpunkt_key, zweiter_anfangspunkt_key);
|
|
segmentpunkte_zwei = segmentpunkte;
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Stuetzpunkte fuer die eine Fahrspur wurden gebildet.");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte_eins);
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Stuetzpunkte fuer die andere Fahrspur wurden gebildet.");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte_zwei);
|
|
|
|
//Es wird auf gleichen Minentyp geprueft und die Gesamtanzahl
|
|
//verlegter Minen ermittelt
|
|
minentyp = -1;
|
|
gesamte_minenanzahl = 0;
|
|
parameter_eins_key = anfangspunkt_key; //nur damit er einen gueltigen Wert hat
|
|
parameter_zwei_key = anfangspunkt_key; //nur damit er einen gueltigen Wert hat
|
|
parameter_drei_key = anfangspunkt_key; //nur damit er einen gueltigen Wert hat
|
|
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
while (interne_datenbasis_Verlegedaten.iter_modify(1))
|
|
{
|
|
if
|
|
((interne_datenbasis_Verlegedaten.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_eins)
|
|
&&
|
|
(
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0) //ein Ende-Telegramm
|
|
)
|
|
)
|
|
{
|
|
if (interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
>= verlege_endzeit - S_Fahrspur) // also das letzte Verlegeendetelegramm
|
|
{
|
|
//insbesondere zum loeschen der Verlegedaten am Ende
|
|
parameter_eins_key = interne_datenbasis_Verlegedaten.getKey();
|
|
|
|
//Um spaeter die Segmente fahrspurweise verschieben zu koennen, wird
|
|
//die Verlegeart fahrzeugbezogen festhalten.
|
|
erste_verlegeart =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart;
|
|
|
|
}
|
|
gesamte_minenanzahl +=
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
|
|
if ((minentyp != -1) && (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//eine Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restliche MVP mit IS == 11 muess nun auf 0 gesetzt werden, um
|
|
//nicht sofort erneut als mehrspureige Minensperre interpretiert zu
|
|
//werden.
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
do
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 11)
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 0;
|
|
}
|
|
while (interne_datenbasis_Fahrspur.iter_modify(1));
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da verschiedene Minentypen vorkommen...Neubeginn");
|
|
goto minengenerator_anfang;
|
|
}
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
}
|
|
}
|
|
if (parameter_eins_key == anfangspunkt_key)
|
|
{
|
|
//dies sollte der absolute Ausnahmefall sein...
|
|
WARNING_LOG(m_logger) << QStringLiteral("Minensperre ohne Parameter!");
|
|
//goto loeschen_mehrere_Fz; //erst mal nicht löschen
|
|
}
|
|
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
while (interne_datenbasis_Verlegedaten.iter_modify(1))
|
|
{
|
|
if
|
|
((interne_datenbasis_Verlegedaten.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_zwei)
|
|
&&
|
|
(
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0) // ein Ende-Telegramm
|
|
)
|
|
)
|
|
{
|
|
if (interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
>= verlege_endzeit - S_Fahrspur) // also das letzte Verlegeendetelegramm
|
|
{
|
|
//insbesondere zum loeschen der Verlegedaten am Ende
|
|
parameter_zwei_key = interne_datenbasis_Verlegedaten.getKey();
|
|
|
|
//Um spaeter die Segmente fahrspurweise verschieben zu koennen, wird
|
|
//die Verlegeart fahrzeugbezogen festhalten.
|
|
zweite_verlegeart =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart;
|
|
|
|
}
|
|
gesamte_minenanzahl +=
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
|
|
if ((minentyp != -1) && (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//eine Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restliche MVP mit IS == 11 muess nun auf 0 gesetzt werden, um
|
|
//nicht sofort erneut als mehrspureige Minensperre interpretiert zu
|
|
//werden.
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
do
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 11)
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 0;
|
|
}
|
|
while (interne_datenbasis_Fahrspur.iter_modify(1));
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da verschiedene Minentypen vorkommen...Neubeginn");
|
|
goto minengenerator_anfang;
|
|
}
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
}
|
|
}
|
|
if (parameter_zwei_key == anfangspunkt_key)
|
|
{
|
|
//dies sollte der absolute Ausnahmefall sein...
|
|
WARNING_LOG(m_logger) << QStringLiteral("Minensperre ohne Parameter!");
|
|
goto loeschen_mehrere_Fz;
|
|
}
|
|
|
|
if (fahrzeug_identitaet_drei != 0) //eine dritte Fahrspur muss es nicht geben
|
|
{
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
while (interne_datenbasis_Verlegedaten.iter_modify(1))
|
|
{
|
|
if
|
|
((interne_datenbasis_Verlegedaten.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_drei)
|
|
&&
|
|
(
|
|
(interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen > 0) //ein Ende-Telegramm
|
|
)
|
|
)
|
|
{
|
|
if (interne_datenbasis_Verlegedaten.getData()->daten.gps_zeit.gps_zeit
|
|
>= verlege_endzeit - S_Fahrspur) // also das letzte Verlegeendetelegramm
|
|
{
|
|
//insbesondere zum loeschen der Verlegedaten am Ende
|
|
parameter_drei_key = interne_datenbasis_Verlegedaten.getKey();
|
|
|
|
//Um spaeter die Segmente fahrspurweise verschieben zu koennen, wird
|
|
//die Verlegeart fahrzeugbezogen festhalten.
|
|
dritte_verlegeart =
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart;
|
|
|
|
}
|
|
gesamte_minenanzahl +=
|
|
interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.anzahl_verlegter_minen;
|
|
|
|
if ((minentyp != -1) && (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp != minentyp))
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//eine Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restliche MVP mit IS == 11 muess nun auf 0 gesetzt werden, um
|
|
//nicht sofort erneut als mehrspureige Minensperre interpretiert zu
|
|
//werden.
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
do
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 11)
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 0;
|
|
}
|
|
while (interne_datenbasis_Fahrspur.iter_modify(1));
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da verschiedene Minentypen vorkommen...Neubeginn");
|
|
goto minengenerator_anfang;
|
|
}
|
|
minentyp = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.minentyp;
|
|
}
|
|
}
|
|
if (parameter_drei_key == anfangspunkt_key)
|
|
{
|
|
//dies sollte der absolute Ausnahmefall sein...
|
|
WARNING_LOG(m_logger) << QStringLiteral("Minensperre ohne Parameter!");
|
|
goto loeschen_mehrere_Fz;
|
|
}
|
|
}
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Anzahl verlegter Minen: %1").arg(gesamte_minenanzahl);
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("1.Fz:%1").arg(fahrzeug_identitaet_eins);
|
|
INFO_LOG(m_logger) << QStringLiteral("2.Fz:%1").arg(fahrzeug_identitaet_zwei);
|
|
INFO_LOG(m_logger) << QStringLiteral("3.Fz:%1").arg(fahrzeug_identitaet_drei);
|
|
INFO_LOG(m_logger) << QStringLiteral("1.Verlegeart:%1").arg(erste_verlegeart);
|
|
INFO_LOG(m_logger) << QStringLiteral("2.Verlegeart:%1").arg(zweite_verlegeart);
|
|
INFO_LOG(m_logger) << QStringLiteral("3.Verlegeart:%1").arg(dritte_verlegeart);
|
|
|
|
|
|
//erste und zweite Verlegeart, muessen nun den beiden aeusseren Fahrspuren
|
|
//zugeordnet werden
|
|
copy_of_erste_verlegeart = erste_verlegeart;
|
|
copy_of_zweite_verlegeart = zweite_verlegeart;
|
|
copy_of_dritte_verlegeart = dritte_verlegeart;
|
|
|
|
if (interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
erster_endeeintrag_key))
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Erster Endeeintrag stammt von Fz %1").arg(interne_datenbasis_Fahrspur.getData()->daten.header.identitaet);
|
|
|
|
if (interne_datenbasis_Fahrspur.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_zwei)
|
|
erste_verlegeart = copy_of_zweite_verlegeart;
|
|
|
|
if (interne_datenbasis_Fahrspur.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_drei)
|
|
erste_verlegeart = copy_of_dritte_verlegeart;
|
|
|
|
}
|
|
|
|
if (interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
zweiter_endeeintrag_key))
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("Zweiter Endeeintrag stammt von Fz %1").arg(interne_datenbasis_Fahrspur.getData()->daten.header.identitaet);
|
|
|
|
if (interne_datenbasis_Fahrspur.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_eins)
|
|
zweite_verlegeart = copy_of_erste_verlegeart;
|
|
|
|
if (interne_datenbasis_Fahrspur.getData()->daten.header.identitaet ==
|
|
fahrzeug_identitaet_drei)
|
|
zweite_verlegeart = copy_of_dritte_verlegeart;
|
|
}
|
|
|
|
|
|
//VERSCHIEBEN DER SEGMENTE DER ERSTEN FAHRSPUR
|
|
segmentpunkte_eins.iter_reset();
|
|
segmente_eins.clear();
|
|
do
|
|
{
|
|
segment.startpunkt = segmentpunkte_eins.getData()->daten.gps_position;
|
|
segmente_eins.eintrag_container(segmentpunkte_eins.getKey(), segment);
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Startpunkt eines Segmentes
|
|
//bleibt aber als Hilfspunkt mit erhalten
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte_eins immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente_eins.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte_eins.finden_eintrag_container(segmente_eins.getKey());
|
|
segmentpunkte_eins.iter_modify(1);
|
|
segmente_eins.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente_eins.getData()->startpunkt.utm_ostwert,
|
|
segmente_eins.getData()->startpunkt.utm_nordwert,
|
|
segmentpunkte_eins.getData()->
|
|
daten.gps_position.utm_ostwert,
|
|
segmentpunkte_eins.getData()->
|
|
daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente_eins.getData()->anzahl =
|
|
Punktabstand(segmente_eins.getData()->startpunkt,
|
|
segmentpunkte_eins.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente_eins.getData()->anzahl;
|
|
}
|
|
while (segmente_eins.iter_modify(1));
|
|
|
|
//Der Hilfspunkt wird mit dem selben Winkel versehen, wie der Vorgaenger,
|
|
//da er genauso verschoben werden soll
|
|
segmente_eins.iter_modify(-1);
|
|
hilfswinkel_eins = segmente_eins.getData()->drehwinkel;
|
|
segmente_eins.iter_modify(1);
|
|
segmente_eins.getData()->drehwinkel = hilfswinkel_eins;
|
|
segmente_eins.getData()->anzahl = 0;
|
|
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Segmente der einen Fahrspur berechnet... (das letzte Segment ist nur ein Hilfssegment)");
|
|
KontrollausgabeSegmente(segmente_eins);
|
|
|
|
//Die Startpunkte der Segmente muessen dann verschoben werden, wenn die
|
|
//Verlegeart links oder rechts ist
|
|
//Die Verlegeart der ersten Fahrspur steht in erste_verlegeart
|
|
|
|
INFO_LOG(m_logger) << QStringLiteral("Ausstossart der ersten Fahrspur: %1").arg(erste_verlegeart);
|
|
|
|
segmente = segmente_eins;
|
|
|
|
switch (erste_verlegeart)
|
|
{
|
|
case 0: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_MVAH / 2; //Mitte, nur MVAH ;
|
|
break;
|
|
case 1: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS / 2; //Rechts
|
|
verschiebe_Fahrspursegmente('r',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 2: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS / 2; //Links
|
|
verschiebe_Fahrspursegmente('l',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 3: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_WMVS; //Rechts&Links
|
|
break;
|
|
default: sperrenmodell.verlegetiefe =
|
|
VERLEGETIEFE_MVAH;
|
|
break;
|
|
}
|
|
|
|
segmente_eins = segmente;
|
|
segmente.clear();
|
|
|
|
|
|
//VERSCHIEBEN DER SEGMENTE DER ZWEITEN FAHRSPUR
|
|
segmentpunkte_zwei.iter_reset();
|
|
segmente_zwei.clear();
|
|
do
|
|
{
|
|
segment.startpunkt = segmentpunkte_zwei.getData()->daten.gps_position;
|
|
segmente_zwei.eintrag_container(segmentpunkte_zwei.getKey(), segment);
|
|
}
|
|
while (segmentpunkte_zwei.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Startpunkt eines Segmentes
|
|
//bleibt aber als Hilfspunkt mit erhalten
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte_zwei immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente_zwei.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte_zwei.finden_eintrag_container(segmente_zwei.getKey());
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
segmente_zwei.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente_zwei.getData()->startpunkt.utm_ostwert,
|
|
segmente_zwei.getData()->startpunkt.utm_nordwert,
|
|
segmentpunkte_zwei.getData()->
|
|
daten.gps_position.utm_ostwert,
|
|
segmentpunkte_zwei.getData()->
|
|
daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente_zwei.getData()->anzahl =
|
|
Punktabstand(segmente_zwei.getData()->startpunkt,
|
|
segmentpunkte_zwei.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente_zwei.getData()->anzahl;
|
|
}
|
|
while (segmente_zwei.iter_modify(1));
|
|
//Der Hilfspunkt wird mit dem selben Winkel versehen, wie der Vorgaenger,
|
|
//da er genauso verschoben werden soll
|
|
segmente_zwei.iter_modify(-1);
|
|
hilfswinkel_zwei = segmente_zwei.getData()->drehwinkel;
|
|
segmente_zwei.iter_modify(1);
|
|
segmente_zwei.getData()->drehwinkel = hilfswinkel_zwei;
|
|
segmente_zwei.getData()->anzahl = 0;
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Segmente der anderen Fahrspur berechnet... (das letzte Segment ist nur ein Hilfssegment)");
|
|
KontrollausgabeSegmente(segmente_zwei);
|
|
|
|
//Die Startpunkte der Segmente muessen dann verschoben werden, wenn die
|
|
//Verlegeart links oder rechts ist
|
|
//Die Verlegeart der letzten Fahrspur steht in zweite_verlegeart
|
|
INFO_LOG(m_logger) << QStringLiteral("Ausstossart der zweiten Fahrspur: %1").arg(zweite_verlegeart);
|
|
|
|
segmente = segmente_zwei;
|
|
|
|
switch (zweite_verlegeart)
|
|
{
|
|
case 0: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_MVAH / 2; //Mitte, nur MVAH ;
|
|
break;
|
|
case 1: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_WMVS / 2; //Rechts
|
|
verschiebe_Fahrspursegmente('r',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 2: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_WMVS / 2; //Links
|
|
verschiebe_Fahrspursegmente('l',
|
|
VERLEGETIEFE_WMVS / 2);
|
|
break;
|
|
case 3: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_WMVS; //Rechts&Links
|
|
break;
|
|
default: sperrenmodell.verlegetiefe +=
|
|
VERLEGETIEFE_MVAH;
|
|
|
|
}
|
|
|
|
segmente_zwei = segmente;
|
|
segmente.clear();
|
|
|
|
|
|
//NUN SIND DIE SEGMENTANFANGSPUNKTE DER EINZELNEN FAHRSPUREN VERSCHOBEN
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("verschobene Segmente der einen Fahrspur berechnet... ");
|
|
KontrollausgabeSegmente(segmente_eins);
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("verschobeneSegmente der anderen Fahrspur berechnet... ");
|
|
KontrollausgabeSegmente(segmente_zwei);
|
|
|
|
//Die Endpunkte der Fahrspuren werden benoetigt, um alle verschobenen
|
|
//Werte wieder in die map-container segmentpunkte_eins und
|
|
//segmentpunkte_zwei einzutragen dazu dienen die beiden Hilfspunkte.
|
|
|
|
segmentpunkte_eins.clear();
|
|
segmente_eins.iter_reset();
|
|
do
|
|
{
|
|
segmentstartpunkt.daten.gps_position = segmente_eins.getData()->startpunkt;
|
|
segmentpunkte_eins.eintrag_container(segmente_eins.getKey(),
|
|
segmentstartpunkt);
|
|
}
|
|
while (segmente_eins.iter_modify(1));
|
|
segmente_eins.clear();
|
|
|
|
segmentpunkte_zwei.clear();
|
|
segmente_zwei.iter_reset();
|
|
do
|
|
{
|
|
segmentstartpunkt.daten.gps_position = segmente_zwei.getData()->startpunkt;
|
|
segmentpunkte_zwei.eintrag_container(segmente_zwei.getKey(),
|
|
segmentstartpunkt);
|
|
}
|
|
while (segmente_zwei.iter_modify(1));
|
|
segmente_zwei.clear();
|
|
|
|
|
|
//Nun muss die Anzahl der Punkte angepasst werden, so dass beide
|
|
//Verlegespuren die gleiche Anzahl von Stuetzpunkten aufweisen.
|
|
//Dabei wird nach folgendem Algorithmus verfahren:
|
|
//1.Ist die Anzahl der Streckenpunkte der Verlegespuren verschieden, so
|
|
// wird die Verlegespur mit der hoeheren Anzahl ausgewaehlt, und in jedem
|
|
// Streckenpunkt, ausser dem Anfangs- und dem Endpunkt, eine
|
|
// winkelhalbierende Gerade berechnet, die einen Schnittpunkt mit einem
|
|
// der Strecken der gegenueberliegenden Verlegespur, bildet. Ist dieser
|
|
// Schnittpunkt auf Grund der besonderen Form der Verlegespur nicht
|
|
// vorhanden, so wird der Anfangs- oder der Endpunkt - je nach dem
|
|
// welcher naeher an der Winkelhalbierenden liegt, als Schnittpunkt
|
|
// angenommen.
|
|
//2.Der zwischen Winkelhalbierender und Strecke gebildete Schnittpunkt,
|
|
// der am weitesten von einem bereits existiernden Streckenpunkt der
|
|
// Verlegespur entfernt ist, wird als zusaetzlicher Streckenpunkt
|
|
// eingefuegt. Trifft dieser Punkt mit einem bereits bestehenden
|
|
// Streckenpunkt zusammen, muss dessen Wertigkeitszaehler erhoeht
|
|
// werden. Ist die Anzahl der Streckenpunkte (die Wertigkeitszaehler
|
|
// muessen beruecksichtigt werden) beider Verlegespuren noch nicht
|
|
// gleich, dann nocheinmal 2.
|
|
//3.An dieser Stelle ist die Anzahl der Streckenpunkte beider
|
|
// Verlegespuren gleich, auch wenn nicht alle Streckenpunkte der einen
|
|
// Verlegespur oertlich verschieden sein muessen (Wertigkeitszaehler).
|
|
// Nun werden die Mittelpunkte jeweils zwei gegenueberliegender
|
|
// Streckenpunkte berechnet und als Segmentpunkt interpretiert, wonach
|
|
// die herangezogenen Streckenpunkte gelowscht werden bzw. ihr
|
|
// Wertigkeiszaehler erniedigt wird. Dabei wird je Verlegespur nach
|
|
// entweder steigender oder fallender zeitlicher Reihenfolge der
|
|
// Eintraege vorgegangen.
|
|
// Es wird mit den beiden Punkten begonnen, die Anfangs- oder Endpunkte
|
|
// bilden(IS!=2) und oertlich am nahesten zusammenliegen.
|
|
|
|
if (segmentpunkte_eins.size() != segmentpunkte_zwei.size())
|
|
{
|
|
//Die beiden map-container werden so umkopiert, dass der Inhalt mit
|
|
//den meisten Eintraegen in segmentpunkte_zwei steht.
|
|
if (segmentpunkte_zwei.size() < segmentpunkte_eins.size())
|
|
{
|
|
segmentpunkte = segmentpunkte_zwei;
|
|
segmentpunkte_zwei = segmentpunkte_eins;
|
|
segmentpunkte_eins = segmentpunkte;
|
|
}
|
|
//Nun werden die moeglichen neuen Stuetzpunkte berechnet
|
|
//und in dem map-container schnittpunkte abgelegt
|
|
|
|
for (size_t i = 0; i < segmentpunkte_zwei.size() - 2; i++)
|
|
{
|
|
int P1x, P1y, P2x, P2y, P3x, P3y;
|
|
int Ax, Ay, Bx, By;
|
|
float sx, sy;
|
|
//Der Iterator muss auf den ersten Punkt des Winkels
|
|
segmentpunkte_zwei.iter_reset();
|
|
for (size_t j = 0; j < i; j++)
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
|
|
P1x = segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert;
|
|
P1y = segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
P2x = segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert;
|
|
P2y = segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_zwei.iter_modify(1);
|
|
P3x = segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert;
|
|
P3y = segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_eins.iter_reset();
|
|
Ax = segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert;
|
|
Ay = segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert;
|
|
segmentpunkte_eins.iter_modify(1);
|
|
Bx = segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert;
|
|
By = segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert;
|
|
|
|
Schnittpunkt_Winkelhalbierende_Strecke(
|
|
P1x, P1y, P2x, P2y, P3x, P3y,
|
|
Ax, Ay, Bx, By, &sx, &sy);
|
|
schnittpkt.daten.gps_position.utm_ostwert = lrint(sx);
|
|
schnittpkt.daten.gps_position.utm_nordwert = lrint(sy);
|
|
|
|
schnittpunkte.eintrag_container(segmentpunkte_zwei.getKey(), schnittpkt);
|
|
}
|
|
|
|
//Kontrollausgabe
|
|
//schnittpunkte.iter_reset();
|
|
//do
|
|
//{
|
|
// lout << setprio(LM_INFO)
|
|
// << "ein Schnittpunkt:"
|
|
// << schnittpunkte.getData()->daten.gps_position.utm_ostwert
|
|
// << "/" << schnittpunkte.getData()->daten.gps_position.utm_nordwert
|
|
// << endl;
|
|
//} while (schnittpunkte.iter_modify(1));
|
|
|
|
|
|
|
|
//Aus den gefundenen Schnittpunkten werden die erforderlichen
|
|
//ausgewaehlt, und in segmentpunkte_eins eingetragen. Es sind mindestens
|
|
//soviel Eintraege in schnittpunkte wie benoetigt werden.
|
|
//Es wird immer der Eintrag herangezogen, der am weitesten von einem
|
|
//bereits vorhandenen Eintrag in segmentpunkte entfernt ist
|
|
//Achtung! Die Eintraege in segmentpunkte_eins sind dann nicht wirklich
|
|
//chronologisch sortiert
|
|
VERLEGEDATEN_KEY groesster_abstand_key;
|
|
while (segmentpunkte_zwei.size() > segmentpunkte_eins.size())
|
|
{
|
|
int groesster_abstand = 0;
|
|
segmentpunkte_eins.iter_reset();
|
|
do
|
|
{
|
|
schnittpunkte.iter_reset();
|
|
do
|
|
{
|
|
int curAbstand = Punktabstand(
|
|
schnittpunkte.getData()->daten.gps_position,
|
|
segmentpunkte_eins.getData()->daten.gps_position);
|
|
if (groesster_abstand < curAbstand)
|
|
{
|
|
groesster_abstand = curAbstand;
|
|
groesster_abstand_key = schnittpunkte.getKey();
|
|
}
|
|
}
|
|
while (schnittpunkte.iter_modify(1));
|
|
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1));
|
|
|
|
schnittpunkte.finden_eintrag_container(groesster_abstand_key);
|
|
segmentpunkte_eins.eintrag_container(groesster_abstand_key,
|
|
*schnittpunkte.getData());
|
|
schnittpunkte.loeschen_eintrag_container(groesster_abstand_key);
|
|
}
|
|
}
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeSegmentPunkte(segmentpunkte_eins);
|
|
|
|
//Sortieren des map-containers segmentpunkte_eins nach den am nahest
|
|
//gelegenen Eintraegen in segmentpunkte_zwei
|
|
segmentpunkte_zwei.iter_reset();
|
|
int kleinster_abstand;
|
|
punktkey.zeitpunkt.gps_zeit = 0;
|
|
do
|
|
{
|
|
kleinster_abstand = 1000000;
|
|
segmentpunkte_eins.iter_reset();
|
|
do
|
|
{
|
|
int curAbstand = Punktabstand(segmentpunkte_zwei.getData()->daten.gps_position,
|
|
segmentpunkte_eins.getData()->daten.gps_position);
|
|
if (curAbstand < kleinster_abstand)
|
|
{
|
|
kleinster_abstand = curAbstand;
|
|
kleinster_abstand_key = segmentpunkte_eins.getKey();
|
|
}
|
|
|
|
}
|
|
while (segmentpunkte_eins.iter_modify(1));
|
|
|
|
segmentpunkte_eins.finden_eintrag_container(kleinster_abstand_key);
|
|
punktdaten = *segmentpunkte_eins.getData();
|
|
//generieren eines eigenen Keys erforderlich
|
|
punktkey.fz_id = 0;
|
|
punktkey.zeitpunkt.gps_zeit += 1;
|
|
//lout << "generierter Key: " << punktkey.zeitpunkt.gps_zeit <<endl;
|
|
segmentpunkte_eins.eintrag_container(punktkey, punktdaten);
|
|
|
|
}
|
|
while (segmentpunkte_zwei.iter_modify(1));
|
|
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Die sortierten Stuetzpunkte der glatteren Fahrspur: ");
|
|
segmentpunkte_zwei.iter_reset();//wird zum zaehlen benutzt, da in _eins mehr
|
|
//Eintraege als gueltig
|
|
segmentpunkte_eins.iter_reset();
|
|
do
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2").arg(segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert).arg(segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert);
|
|
}
|
|
while ((segmentpunkte_eins.iter_modify(1))
|
|
&&
|
|
(segmentpunkte_zwei.iter_modify(1)));
|
|
|
|
//Berechnung des weitesten Abstandes der Segmente
|
|
//wird fuer die Verlegebreite benoetigt
|
|
groesster_spurabstand = 0;
|
|
segmentpunkte_eins.iter_reset();
|
|
segmentpunkte_zwei.iter_reset();
|
|
do
|
|
{
|
|
int curAbstand = Punktabstand(segmentpunkte_eins.getData()->daten.gps_position,
|
|
segmentpunkte_zwei.getData()->daten.gps_position);
|
|
if (groesster_spurabstand < curAbstand)
|
|
groesster_spurabstand = curAbstand;
|
|
}
|
|
while ((segmentpunkte_eins.iter_modify(1))
|
|
&& (segmentpunkte_zwei.iter_modify(1)));
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Groesster Spurabstand: %1").arg(groesster_spurabstand);
|
|
|
|
//Nun sind in den beiden segmentpunkte-map-containern gleichviele Eintraege
|
|
//deren jeweiligen Mittelpunkte die Segmentpunkte bilden sollen
|
|
//Diese Mittelpunkte werden in segmentpunkte eingetragen
|
|
segmentpunkte.clear();
|
|
segmentpunkte_eins.iter_reset();
|
|
segmentpunkte_zwei.iter_reset();
|
|
do
|
|
{
|
|
segmentstartpunkt.daten.gps_position.utm_ostwert =
|
|
(segmentpunkte_eins.getData()->daten.gps_position.utm_ostwert
|
|
+ segmentpunkte_zwei.getData()->daten.gps_position.utm_ostwert) / 2;
|
|
segmentstartpunkt.daten.gps_position.utm_nordwert =
|
|
(segmentpunkte_eins.getData()->daten.gps_position.utm_nordwert
|
|
+ segmentpunkte_zwei.getData()->daten.gps_position.utm_nordwert) / 2;
|
|
|
|
segmentpunkte.eintrag_container(segmentpunkte_zwei.getKey(),
|
|
segmentstartpunkt);
|
|
}
|
|
while ((segmentpunkte_eins.iter_modify(1))
|
|
&& (segmentpunkte_zwei.iter_modify(1)));
|
|
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Die endgueltigen Segmentstuetzpunkte sind folgende:");
|
|
KontrollausgabeSegmentPunkte(segmentpunkte);
|
|
|
|
|
|
//BERECHNEN DER ENDGUELTIGEN SEGMENTE DES MINENSPERRENMODELLS
|
|
segmentpunkte.iter_reset();
|
|
segmente.clear();
|
|
do
|
|
{
|
|
segment.startpunkt = segmentpunkte.getData()->daten.gps_position;
|
|
|
|
segmente.eintrag_container(segmentpunkte.getKey(), segment);
|
|
}
|
|
while (segmentpunkte.iter_modify(1));
|
|
|
|
|
|
|
|
//Berechnung der Drehwinkel der Segmente im Startpunkt Richtung Endpunkt
|
|
//Der Endpunkt folgt im map-container segmentpunkte immer auf den
|
|
//Startpunkt, auch wenn dieser selbst Startpunkt ist
|
|
gesamte_verlege_strecke = 0;
|
|
segmente.iter_reset();
|
|
do
|
|
{
|
|
segmentpunkte.finden_eintrag_container(segmente.getKey());
|
|
segmentpunkte.iter_modify(1);
|
|
segmente.getData()->drehwinkel =
|
|
Winkel_ostbezogen(segmente.getData()->startpunkt.utm_ostwert,
|
|
segmente.getData()->startpunkt.utm_nordwert,
|
|
segmentpunkte.getData()->daten.gps_position.utm_ostwert,
|
|
segmentpunkte.getData()->daten.gps_position.utm_nordwert);
|
|
//zunaechst wird an Stelle der Anzahl der Minen des Segmentes, seine
|
|
// Laenge eingegeben
|
|
segmente.getData()->anzahl =
|
|
Punktabstand(segmente.getData()->startpunkt,
|
|
segmentpunkte.getData()->daten.gps_position);
|
|
gesamte_verlege_strecke = gesamte_verlege_strecke +
|
|
segmente.getData()->anzahl;
|
|
}
|
|
while (segmente.iter_modify(1));
|
|
//Der letzte Eintrag ist kein Segment und wird geloescht
|
|
segmente.loeschen_eintrag_container(segmente.getKey());
|
|
|
|
|
|
segmentparameter = segmente;
|
|
|
|
//Ersetzen der Segmentlaengen durch die Anzahl der Minen
|
|
segmentparameter.iter_reset();
|
|
rest = 0;
|
|
minenzaehler = 0;
|
|
do
|
|
{
|
|
//Der Rest darf nicht verloren gehen, sondern muss dem naechsten
|
|
//Segment zugerechnet, bzw abgerechnet werden, da die Summe der Minen
|
|
//exakt die Gesamtmenge ergeben soll!
|
|
float f_anzahl = float((segmentparameter.getData()->
|
|
anzahl + rest) / gesamte_verlege_strecke)
|
|
* gesamte_minenanzahl;
|
|
rest = f_anzahl - int(f_anzahl + 0.5);
|
|
segmentparameter.getData()->anzahl = int(f_anzahl + 0.5);
|
|
minenzaehler = minenzaehler + segmentparameter.getData()->anzahl;
|
|
}
|
|
while (segmentparameter.iter_modify(1));
|
|
//Bei dem letzten Segment werden lediglich die Rundungsfehler
|
|
//ausgeglichen.
|
|
//Iterator steht bereits auf dem letzten Eintrag
|
|
segmentparameter.getData()->anzahl =
|
|
segmentparameter.getData()->anzahl + (gesamte_minenanzahl - minenzaehler);
|
|
|
|
interne_datenbasis_Verlegedaten.finden_eintrag_container(parameter_eins_key);
|
|
//sperrenmodell.kennung = ;
|
|
//sperrenmodell.bezeichner =;
|
|
sperrenmodell.wirkbeginn =
|
|
interne_datenbasis_Verlegedaten.getData()->daten.verlegedaten.wirkbeginn;
|
|
sperrenmodell.wirkdauer =
|
|
interne_datenbasis_Verlegedaten.getData()->daten.verlegedaten.wirkzeit;
|
|
sperrenmodell.eckpunkt.utm_ostwert = 0;
|
|
sperrenmodell.eckpunkt.utm_nordwert = 0;
|
|
sperrenmodell.wirkfeldbreite = 0;
|
|
sperrenmodell.wirkfeldtiefe = 0;
|
|
|
|
sperrenmodell.verlegetiefe += groesster_spurabstand;
|
|
|
|
if (gesamte_verlege_strecke != 0)
|
|
{
|
|
//verlegedichte entspricht Minen je 10 Meter
|
|
// sperrenmodell.verlegedichte = 6; //default
|
|
// if((gesamte_minenanzahl)*100/gesamte_verlege_strecke <
|
|
// 65){sperrenmodell.verlegedichte = 6;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 55){sperrenmodell.verlegedichte = 5;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 45){sperrenmodell.verlegedichte = 4;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 35){sperrenmodell.verlegedichte = 3;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 25){sperrenmodell.verlegedichte = 2;}
|
|
// if((gesamte_minenanzahl*100)/gesamte_verlege_strecke <
|
|
// 15){sperrenmodell.verlegedichte = 1;}
|
|
sperrenmodell.verlegedichte = lrint(((double)gesamte_minenanzahl / gesamte_verlege_strecke * FAKTOR_VERLEGEDICHTE));
|
|
if (sperrenmodell.verlegedichte > max_verlegedichte * FAKTOR_VERLEGEDICHTE)
|
|
sperrenmodell.verlegedichte = lrint(max_verlegedichte * FAKTOR_VERLEGEDICHTE);
|
|
else if (sperrenmodell.verlegedichte < 1)
|
|
sperrenmodell.verlegedichte = 1;
|
|
INFO_LOG(m_logger) << QStringLiteral("verlegedichte = %1 anz=%2 strecke=%3").arg(sperrenmodell.verlegedichte).arg(gesamte_minenanzahl).arg(gesamte_verlege_strecke);
|
|
//Hier der Test ob die Fahrspuren ueberhaupt zusammengehoeren koennen
|
|
//Die Verlegedichte darf nicht ueber 6 Minen/10 Meter liegen!
|
|
if ((gesamte_minenanzahl * 100) / gesamte_verlege_strecke >
|
|
max_verlegedichte * 100 + 50 / FAKTOR_VERLEGEDICHTE)
|
|
{
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(endpunkt_key);
|
|
//Die letzte Fahrspur bildet nun doch eine Einzelsperre
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 9;
|
|
//Die restlichen MVP werden am Ende des Minenfeldgenerators
|
|
//alle auf 0 gesetzt, so dass sie bei Aufruf des
|
|
//Minenfeldinterpreters neu interpretiert werden koennen.
|
|
INFO_LOG(m_logger) << QStringLiteral("Die Minensperre enthaelt mindestens eine einspurige Sperre da die Minendichte %1 uebersteigt...Ende").arg(max_verlegedichte);
|
|
|
|
}
|
|
}
|
|
sperrenmodell.minentyp =
|
|
interne_datenbasis_Verlegedaten.getData()->daten.verlegedaten.minentyp;
|
|
sperrenmodell.minenanzahl = gesamte_minenanzahl;
|
|
sperrenmodell.segmente.reserve(segmentparameter.size());
|
|
for (const auto &val : segmentparameter.c())
|
|
sperrenmodell.segmente.push_back(val.second);
|
|
|
|
//Kontrollausgabe
|
|
INFO_LOG(m_logger) << QStringLiteral("Mehrspuriges Minensperrenmodell (mehrere Fz) wurde erstellt. Wirkbeginn:%1 Wirkdauer:%2 Eckpunkt:%3 %4 Wirkfeldbreite:%5 Wirkfeldtiefe:%6 Verlegetiefe:%7 Verlegedichte:%8 Minentyp:%9 Minenanzahl:%10 Segmentanzahl:%11").arg(sperrenmodell.wirkbeginn.gps_zeit).arg(sperrenmodell.wirkdauer).arg(sperrenmodell.eckpunkt.utm_ostwert).arg(sperrenmodell.eckpunkt.utm_nordwert).arg(sperrenmodell.wirkfeldbreite).arg(sperrenmodell.wirkfeldtiefe).arg(sperrenmodell.verlegetiefe).arg(sperrenmodell.verlegedichte).arg(sperrenmodell.minentyp).arg(sperrenmodell.minenanzahl).arg(sperrenmodell.segmente.size());
|
|
KontrollausgabeSegmente(sperrenmodell.segmente);
|
|
|
|
|
|
if (interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.ausstossart == 0)
|
|
Fz_art = 1;
|
|
else
|
|
Fz_art = 2;
|
|
|
|
|
|
//Aufruf des Construktors(sperrenmodell, fahrzeug_identitaet, Fz_art)
|
|
telegramm.beschreibung.kennung = interne_datenbasis_Verlegedaten.getData()->
|
|
daten.verlegedaten.sperren_id;
|
|
|
|
telegramm.header.identitaet = fahrzeug_identitaet;
|
|
|
|
emit sendeWirkfeld(telegramm, Fz_art);
|
|
sperrenmodell.segmente.clear();
|
|
|
|
loeschen_mehrere_Fz:
|
|
|
|
//Die gesamten Fahrspurtelegramme der Minensperre werden geloescht
|
|
//Da nur eine solche Minensperre im map-container vorhanden ist, werden
|
|
//alle Fahrspuren geloescht, die einen Endeeintrag mit IS==11 haben.
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
do
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 11)
|
|
{
|
|
int fz = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
if (interne_datenbasis_Fahrspur.iter_modify(-1))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fz)
|
|
{
|
|
interne_datenbasis_Fahrspur.loeschen_eintrag_container(interne_datenbasis_Fahrspur.getKey());
|
|
goto loeschen_mehrere_Fz;
|
|
}
|
|
interne_datenbasis_Fahrspur.iter_modify(1);
|
|
}
|
|
}
|
|
}
|
|
while (interne_datenbasis_Fahrspur.iter_modify(1));
|
|
|
|
//Nun noch die Eintraege die IS==11 haben
|
|
count = interne_datenbasis_Fahrspur.size();
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
for (unsigned long i = 0; i < count; i++)
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 11)
|
|
interne_datenbasis_Fahrspur.iter_erase();
|
|
}
|
|
|
|
//Die gesamten Verlegedaten fuer die drei Fahrspuren werden geloescht
|
|
loesche_verlegedaten(parameter_eins_key, fahrzeug_identitaet_eins);
|
|
loesche_verlegedaten(parameter_zwei_key, fahrzeug_identitaet_zwei);
|
|
loesche_verlegedaten(parameter_drei_key, fahrzeug_identitaet_drei);
|
|
|
|
segmentparameter.clear();
|
|
segmentpunkte.clear();
|
|
segmentpunkte_zwei.clear();
|
|
|
|
//Kontrollausgabe
|
|
KontrollausgabeFahrspur(interne_datenbasis_Fahrspur, QStringLiteral("Ende"), 11);
|
|
KontrollausgabeVerlegedaten(interne_datenbasis_Verlegedaten, QStringLiteral("Ende"), 11);
|
|
|
|
|
|
minenfeldgenerator_ende: //wenn kein IS==11
|
|
|
|
|
|
//Nun wird noch aufgeraumt!
|
|
for (auto &data : interne_datenbasis_Fahrspur.c())
|
|
data.second.intstat = 0;
|
|
|
|
|
|
/*
|
|
//Kontrollausgabe
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
INFO_LOG(m_logger) << QStringLiteral("Fahrspurcontainer am Ende des Generators: ");
|
|
|
|
do
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2IS:%3").arg(interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_ostwert \).arg(interne_datenbasis_Fahrspur.getData()-> daten.gps_position.utm_nordwert \).arg(interne_datenbasis_Fahrspur.getData()->intstat \);
|
|
} while (interne_datenbasis_Fahrspur.iter_modify(1));
|
|
|
|
//Kontrollausgabe
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
INFO_LOG(m_logger) << QStringLiteral("Verlegedatencontainer am Ende des Generators: ");
|
|
|
|
do
|
|
{
|
|
INFO_LOG(m_logger) << QStringLiteral("%1/%2 Fz:%3").arg(interne_datenbasis_Verlegedaten.getData()-> daten.gps_position.utm_ostwert \).arg(interne_datenbasis_Verlegedaten.getData()-> daten.gps_position.utm_nordwert \).arg(interne_datenbasis_Verlegedaten.getData()-> daten.header.identitaet \);
|
|
} while (interne_datenbasis_Fahrspur.iter_modify(1));
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Generator::ZSSI_WI_Minenfeld_Generator(QObject *parent)
|
|
: QObject(parent)
|
|
{}
|
|
|
|
GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Generator::~ZSSI_WI_Minenfeld_Generator()
|
|
{}
|
|
|
|
// end of ZSSI_WI_Minen_Generator
|
|
//-------------------------------------------------------------------------
|
|
|