1643 lines
60 KiB
C++
Executable File
1643 lines
60 KiB
C++
Executable File
/* --------------------------------------------------------------------
|
|
// $HeadURL$
|
|
// --------------------------------------------------------------------
|
|
//!
|
|
// --------------------------------------------------------------------
|
|
// COPYRIGHT (C) 1999: STN ATLAS ELEKTRONIK GMBH, D-28305 BREMEN
|
|
// --------------------------------------------------------------------
|
|
//
|
|
// HIER/ITEM : CSU: RP 5182 P 005 SRC 01104
|
|
// BRIEF DESC: Funktionalitaet Mineninterpreter
|
|
// AUTHOR : Ingo Kannetzky
|
|
// RELEASE :
|
|
// MODIF/STAT: 22.02.00
|
|
// ORIGIN REF:
|
|
//
|
|
// Revision INFO:
|
|
// --------------
|
|
// $Revision$
|
|
// $Date$
|
|
// $Id$
|
|
//
|
|
// LANGUAGE: C++ (Compiler: XXX Version: XXX)
|
|
//
|
|
// PURPOSE:
|
|
// --------
|
|
// Funktionalitaet Mineninterpreter
|
|
//
|
|
// ERROR HANDLING:
|
|
// ---------------
|
|
// (keine / Beschreibung)
|
|
//
|
|
// IMPLEMENTATION DETAILS:
|
|
// -----------------------
|
|
// (keine / Beschreibung)
|
|
//
|
|
//!
|
|
*/
|
|
|
|
//------------------ revision id-code ----------------------
|
|
|
|
//------------------ includes ------------------------------
|
|
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
|
|
#include <iostream>
|
|
|
|
#include "zssi_wi_Minenfeld_Interpreter.h"
|
|
#include "zssi_wi_Minenfeld_Generator.h"
|
|
#include "logger.h"
|
|
|
|
//------------------ externals (procs + vars) --------------
|
|
|
|
//------------------ constants/ defines --------------------
|
|
const int T_allein_Luecke_max = 120; // in Sekunden
|
|
const int S_allein_Luecke_max = 30; // in Metern
|
|
const int T_allein_max = 180; // in Sekunden, groesser als t_allein_Luecke_max!
|
|
const int S_allein_max = 100; // in Metern, groesser als s_allein_Luecke_max!
|
|
const int W_allein_max = 40; // in Grad 0..89
|
|
const int T_zusammen_max = 240; // in Sekunden
|
|
const int S_zusammen_max = 100; // in Metern
|
|
const int W_zusammen_max = 20; // in Grad 0..89
|
|
|
|
//------------------ types ---------------------------------
|
|
|
|
//------------------ globals -------------------------------
|
|
|
|
extern
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, VERLEGEDATEN_INTERN>
|
|
interne_datenbasis_Verlegedaten;
|
|
|
|
extern
|
|
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>
|
|
interne_datenbasis_Fahrspur;
|
|
|
|
static NGL::INGLLogger &loggerMI()
|
|
{
|
|
return GuezMinelayerProcessing::getLogger("zssi_wi_Minenfeld_Interpreter");
|
|
}
|
|
|
|
struct PositionMitZeit
|
|
{
|
|
gps_position_rt pos;
|
|
time_t zeit = 0;
|
|
};
|
|
|
|
//------------------ function prototypes -------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
|
|
// copied from zssi_wi_Minen_math.cpp
|
|
//f+-----------------------------------------------------------------------
|
|
int Winkel_zwischen_Fahrspuren_eines_Fz(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Der Richtungssinn der Fahrspuren wird berueksichtigt so, dass
|
|
// mit engegengesetztem Richtungssinn angelegte, parallele Fahrspuren den
|
|
// Winkel 0 einschliessen, dagegen schliessen parallele Fahrspuren, welche
|
|
// mit dem selben Richtungssinn verlegt wurden, einen Winkel von 180 Grad
|
|
// ein.
|
|
// Sollten die zur Berechnung des Winkels erforderlichen Werte nicht
|
|
// gefunden werden, so gibt diese Funktion -1 zurueck
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
double F1x2 = -1;
|
|
double F1y2 = -1;
|
|
double F2x1 = -1;
|
|
double F2y1 = -1;
|
|
double F2x2 = -1;
|
|
double F2y2 = -1;
|
|
double delta_w;
|
|
|
|
//Als Fahrspur 1(F1xx) wird die aeltere Fahrspur angesehen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
|
|
//Es wird davon ausgegangen, dass der Iterator nun auf dem
|
|
//Verlegeende-Eintrag der Fahrspur 1 steht
|
|
|
|
|
|
double F1x1 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_ostwert;
|
|
double F1y1 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_nordwert;
|
|
|
|
//Nun wird der Iterator auf den zugehoerigen Verlegeanfang gesetzt
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(-1))
|
|
&& (F1x2 == -1))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
|
|
{
|
|
F1x2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_ostwert;
|
|
F1y2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_nordwert;
|
|
}
|
|
|
|
}
|
|
|
|
//Iterator wieder auf den aktuellen Endeeintrag setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
|
|
//Der naechste Eintrag sollte der Verlegeanfang der naechsten Fahrspur
|
|
//sein
|
|
if (interne_datenbasis_Fahrspur.iter_modify(+1))
|
|
{
|
|
if ((interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet)
|
|
&& (interne_datenbasis_Fahrspur.getData()->intstat == 3))
|
|
{
|
|
F2x1 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_ostwert;
|
|
F2y1 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_nordwert;
|
|
|
|
//Nun wird nach dem aktuellsten Eintrag fuer die Fahrspur 2 gesucht
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(+1))
|
|
&& (interne_datenbasis_Fahrspur.getData()->intstat == 2))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet)
|
|
{
|
|
F2x2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_ostwert;
|
|
F2y2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_nordwert;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Iterator wieder auf den aktuellen Endeeintrag setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
|
|
if (((F1x1 == -1) || (F1x2 == -1)) || ((F2x1 == -1) || (F2x2 == -1)))
|
|
delta_w = -1;
|
|
else
|
|
{
|
|
double m1, m2;
|
|
if (F1x2 - F1x1 != 0)
|
|
m1 = (F1y2 - F1y1) / (F1x2 - F1x1);
|
|
else
|
|
m1 = 100000; //um eine Fallunterscheidung zu vermeiden
|
|
|
|
if (F2x2 - F2x1 != 0)
|
|
m2 = (F2y2 - F2y1) / (F2x2 - F2x1);
|
|
else
|
|
m2 = 100000; //um eine Fallunterscheidung zu vermeiden
|
|
|
|
if (m1 * m2 != -1)
|
|
delta_w = atanf((m2 - m1) / (1 + (m1 * m2)));
|
|
else
|
|
delta_w = M_PI / 2;
|
|
|
|
// rad -> grad
|
|
delta_w *= 180 / M_PI;
|
|
|
|
//Der Anfangspunkt der Fahrspur 2 muss am weitesten vom Beginn der
|
|
//Fahrspur entfernt sein
|
|
|
|
if (Punktabstand(F1x2, F1y2, F2x1, F2y1) <
|
|
Punktabstand(F1x2, F1y2, F2x2, F2y2))
|
|
delta_w = 180 - delta_w;
|
|
}
|
|
|
|
return lrint(delta_w);
|
|
}//end Winkel_zwischen_Fahrspuren_eines_Fz
|
|
//-------------------------------------------------------------------------
|
|
|
|
// copied from zssi_wi_Minen_math.cpp
|
|
//f+-----------------------------------------------------------------------
|
|
int Winkel_zwischen_Fahrspuren_mehrerer_Fz(
|
|
const VERLEGEDATEN_KEY &F1_ende_key, const VERLEGEDATEN_KEY &F2_anfang_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Der Richtungssinn der Fahrspuren wird berueksichtigt so, dass
|
|
// mit gleichem Richtungssinn angelegte, parallele Fahrspuren den
|
|
// Winkel 0 einschliessen, dagegen schliessen parallele Fahrspuren, welche
|
|
// mit entgegengesetzten Richtungssinn verlegt wurden, einen Winkel von 180
|
|
// Grad ein.
|
|
// Sollten die zur Berechnung des Winkels erforderlichen Werte nicht
|
|
// gefunden werden, so gibt diese Funktion -1 zurueck
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
double F1x2 = -1;
|
|
double F1y2 = -1;
|
|
double F2x2 = -1;
|
|
double F2y2 = -1;
|
|
double delta_w;
|
|
|
|
//Iterator auf den aktuellen Endpunkt setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(F1_ende_key);
|
|
//F1_fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
// daten.header.identitaet;
|
|
|
|
double F1x1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_ostwert;
|
|
double F1y1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_nordwert;
|
|
|
|
//Nun wird der Iterator auf den zugehoerigen Verlegeanfang gesetzt
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(-1))
|
|
&& (F1x2 == -1))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
|
|
{
|
|
F1x2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_ostwert;
|
|
F1y2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_nordwert;
|
|
}
|
|
}
|
|
|
|
//Iterator auf den Anfangspunkt der zweiten Fahrspur setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(F2_anfang_key);
|
|
const ausstattungs_id_t F2_fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
|
|
double F2x1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_ostwert;
|
|
double F2y1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_nordwert;
|
|
|
|
//Nun wird nach dem aktuellsten Eintrag fuer die Fahrspur 2 gesucht
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(+1))
|
|
&& (interne_datenbasis_Fahrspur.getData()->intstat == 2))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == F2_fahrzeug_identitaet)
|
|
{
|
|
F2x2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_ostwert;
|
|
F2y2 = interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position.utm_nordwert;
|
|
}
|
|
}
|
|
|
|
if (((F1x1 == -1) || (F1x2 == -1)) || ((F2x1 == -1) || (F2x2 == -1)))
|
|
delta_w = -1;
|
|
else
|
|
{
|
|
double m1, m2;
|
|
if (F1x2 - F1x1 != 0)
|
|
m1 = (F1y2 - F1y1) / (F1x2 - F1x1);
|
|
else
|
|
m1 = 100000; //um eine Fallunterscheidung zu vermeiden
|
|
|
|
if (F2x2 - F2x1 != 0)
|
|
m2 = (F2y2 - F2y1) / (F2x2 - F2x1);
|
|
else
|
|
m2 = 100000; //um eine Fallunterscheidung zu vermeiden
|
|
|
|
if (m1 * m2 != -1)
|
|
delta_w = atanf((m2 - m1) / (1 + (m1 * m2)));
|
|
else
|
|
delta_w = M_PI / 2;
|
|
|
|
// rad -> deg
|
|
delta_w *= 180 / M_PI;
|
|
|
|
//Der Anfangspunkt der Fahrspur 2 muss am weitesten vom Ende der
|
|
//Fahrspur 1 entfernt sein
|
|
|
|
if (Punktabstand(F1x1, F1y1, F2x2, F2y2) >
|
|
Punktabstand(F1x1, F1y1, F2x1, F2y1))
|
|
delta_w = 180 - delta_w;
|
|
}
|
|
//Iterator auf den aktuellen Anfangseintrag setzen!!!!!!!!
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(F2_anfang_key);
|
|
return lrint(delta_w);
|
|
}//end Winkel_zwischen_Fahrspuren_mehrerer_Fz
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::ZSSI_WI_Erstelle_einzel_minensperre(const VERLEGEDATEN_KEY &key,
|
|
const VERLEGEDATEN_INTERN &daten)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Interpretationsstatus des Eintrages
|
|
// im Map-Container interne_datenbasis_Fahrspur, der unmittelbar vor dem
|
|
// Verlegebeginn der aktuellen Fahrspur liegt. Ist kein solcher Eintrag
|
|
// vorhanden liefert sie -1 zurueck.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = key.fz_id;
|
|
const short Fz_art = 2;
|
|
|
|
NGL::INGLLogger &m_logger(loggerMI());
|
|
|
|
wirkfeld_minensperre_rt telegramm;
|
|
bes_wirkfeld_minensperre_rt &sperrenmodell = telegramm.beschreibung;
|
|
// Minensperre = Quadrat 25x25m, 5 Minen => verlegedichte = 0.2, 1 Segment
|
|
sperrenmodell.wirkbeginn.gps_zeit = daten.daten.verlegedaten.wirkbeginn.gps_zeit;
|
|
sperrenmodell.wirkdauer = daten.daten.verlegedaten.wirkzeit;
|
|
sperrenmodell.minentyp = daten.daten.verlegedaten.minentyp;
|
|
sperrenmodell.eckpunkt.utm_nordwert = daten.daten.gps_position.utm_nordwert - 12;
|
|
sperrenmodell.eckpunkt.utm_ostwert = daten.daten.gps_position.utm_ostwert - 12;
|
|
sperrenmodell.wirkfeldbreite = 25;
|
|
sperrenmodell.wirkfeldtiefe = 25;
|
|
sperrenmodell.verlegetiefe = 25;
|
|
// sperrenmodell.verlegedichte = 2;
|
|
sperrenmodell.verlegedichte = lrint(0.2 * FAKTOR_VERLEGEDICHTE);
|
|
sperrenmodell.minenanzahl = 5;
|
|
|
|
sperrenmodell.segmente.resize(1);
|
|
|
|
sperrenmodell.segmente[0].startpunkt.utm_nordwert = daten.daten.gps_position.utm_nordwert;
|
|
sperrenmodell.segmente[0].startpunkt.utm_ostwert = daten.daten.gps_position.utm_ostwert - 12;
|
|
sperrenmodell.segmente[0].anzahl = 5;
|
|
sperrenmodell.segmente[0].drehwinkel = 0;
|
|
|
|
//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());
|
|
for (unsigned s = 0; s < sperrenmodell.segmente.size(); s++)
|
|
INFO_LOG(m_logger) << QStringLiteral("Segment[%1] Startpunkt: %2 %3 Drehwinkel:%4 Anzahl:%5").arg(s)
|
|
.arg(sperrenmodell.segmente.at(s).startpunkt.utm_ostwert)
|
|
.arg(sperrenmodell.segmente.at(s).startpunkt.utm_nordwert)
|
|
.arg(sperrenmodell.segmente.at(s).drehwinkel)
|
|
.arg(sperrenmodell.segmente.at(s).anzahl);
|
|
|
|
telegramm.beschreibung.kennung = daten.daten.verlegedaten.sperren_id;
|
|
telegramm.header.identitaet = fahrzeug_identitaet;
|
|
emit sendeWirkfeld(telegramm, Fz_art);
|
|
|
|
} // end ZSSI_WI_Erstelle_einzel_minensperre
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::ZSSI_WI_modifiziere_Verlegedaten(const VERLEGEDATEN_KEY &key,
|
|
const VERLEGEDATEN_INTERN &daten)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Interpretationsstatus des Eintrages
|
|
// im Map-Container interne_datenbasis_Fahrspur, der unmittelbar vor dem
|
|
// Verlegebeginn der aktuellen Fahrspur liegt. Ist kein solcher Eintrag
|
|
// vorhanden liefert sie -1 zurueck.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
int verlegedaten_size = interne_datenbasis_Verlegedaten.size();
|
|
bool gefunden = false;
|
|
VERLEGEDATEN_INTERN *hilfs_daten = nullptr;
|
|
NGL::INGLLogger &m_logger(loggerMI());
|
|
|
|
if (verlegedaten_size == 0)
|
|
{
|
|
ZSSI_WI_Erstelle_einzel_minensperre(key, daten);
|
|
return;
|
|
}
|
|
interne_datenbasis_Verlegedaten.iter_reset();
|
|
interne_datenbasis_Verlegedaten.iter_modify(verlegedaten_size);
|
|
|
|
while (verlegedaten_size > 0)
|
|
{
|
|
const VERLEGEDATEN_KEY &hilfs_key = interne_datenbasis_Verlegedaten.getKey();
|
|
if ((key.fz_id == hilfs_key.fz_id) &&
|
|
std::abs((int)(key.zeitpunkt.gps_zeit - hilfs_key.zeitpunkt.gps_zeit)) <= T_zusammen_max)
|
|
{
|
|
hilfs_daten = interne_datenbasis_Verlegedaten.getData();
|
|
if (hilfs_daten->daten.verlegedaten.anzahl_verlegter_minen != 0)
|
|
{
|
|
gefunden = true;
|
|
break;
|
|
}
|
|
}
|
|
interne_datenbasis_Verlegedaten.iter_modify(-1);
|
|
verlegedaten_size--;
|
|
}
|
|
|
|
if (gefunden)
|
|
{
|
|
hilfs_daten->daten.verlegedaten.anzahl_verlegter_minen += daten.daten.verlegedaten.anzahl_verlegter_minen;
|
|
INFO_LOG(m_logger) << QStringLiteral("Verlegeende gefunden! Anz_Minen = %1").arg(hilfs_daten->daten.verlegedaten.anzahl_verlegter_minen);
|
|
}
|
|
else
|
|
ZSSI_WI_Erstelle_einzel_minensperre(key, daten);
|
|
} // end ZSSI_WI_modifiziere_Verlegedaten
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
int Eintrag_vor_zugehoerigem_Verlegebeginn(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Interpretationsstatus des Eintrages
|
|
// im Map-Container interne_datenbasis_Fahrspur, der unmittelbar vor dem
|
|
// Verlegebeginn der aktuellen Fahrspur liegt. Ist kein solcher Eintrag
|
|
// vorhanden liefert sie -1 zurueck.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
VERLEGEDATEN_KEY anfangspunkt_key = intern_key;
|
|
|
|
// Map-Container auf aktuellen Eintrag setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
|
|
//Suchen des vorhergehenden Eintrages des Fz mit is == 3 (Anfangspunkt)
|
|
while (((interne_datenbasis_Fahrspur.iter_modify(-1))
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet))
|
|
&&
|
|
(intern_key == anfangspunkt_key)
|
|
)
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
|
|
anfangspunkt_key = interne_datenbasis_Fahrspur.getKey();
|
|
}
|
|
|
|
//Iterator auf den gefundenen Anfangspunkt positionieren
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);
|
|
|
|
//Interpretationsstatus vom Vorgaenger lesen
|
|
int is = 1;
|
|
if ((interne_datenbasis_Fahrspur.iter_modify(-1)) &&
|
|
(intern_key != anfangspunkt_key))
|
|
is = interne_datenbasis_Fahrspur.getData()->intstat;
|
|
|
|
return (is);
|
|
} // end Eintrag_vor_zugehoerigem_Verlegebeginn
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
int Eintrag_nach_dieser_MVP(VERLEGEDATEN_KEY intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Interpretationsstatus des Eintrages
|
|
// im Map-Container interne_datenbasis_Fahrspur, der unmittelbar nach
|
|
// dem aktuellen Eitrag fuer dieses Fz vorliegt. Ist kein solcher
|
|
// Eintrag vorhanden, liefert sie -1 zurueck.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
// Map-Container auf aktuellen Eintrag setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
|
|
//Auslesen des nachfolgenden Eintrags fuer dieses Fz falls dieser
|
|
//vorhanden ist
|
|
int is = -1;
|
|
if ((interne_datenbasis_Fahrspur.iter_modify(+1))
|
|
&& (interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet == fahrzeug_identitaet)
|
|
)
|
|
is = interne_datenbasis_Fahrspur.getData()->intstat;
|
|
|
|
return (is);
|
|
} // end Eintrag_nach_dieser_MVP
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
VERLEGEDATEN_KEY Key_des_zugehoerigen_Verlegebeginns(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Eintrag im Map-Container
|
|
// interne_datenbasis_Fahrspur, der zu der uebergebenen Verlegeende-MVP
|
|
// den zugehoerigen Verlegebeginn bildet und liefert den Key zurueck.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
VERLEGEDATEN_KEY anfangspunkt_key = intern_key;
|
|
|
|
auto it = interne_datenbasis_Fahrspur.c().find(intern_key);
|
|
if (it == interne_datenbasis_Fahrspur.c().end())
|
|
return anfangspunkt_key;
|
|
const ausstattungs_id_t fahrzeug_identitaet = it->second.daten.header.identitaet;
|
|
|
|
do
|
|
{
|
|
--it;
|
|
//Suchen des vorhergehenden Eintrages des Fz mit is == 3 (Anfangspunkt)
|
|
if (it->second.daten.header.identitaet != fahrzeug_identitaet)
|
|
break;
|
|
if (it->second.intstat == 3)
|
|
{
|
|
anfangspunkt_key = it->first;
|
|
break;
|
|
}
|
|
}
|
|
while (it != interne_datenbasis_Fahrspur.c().begin());
|
|
|
|
return anfangspunkt_key;
|
|
} // end of Key_des_zugehoerigen_Verlegebeginns
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
VERLEGEDATEN_KEY Key_des_zugehoerigen_Verlegeendes(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Eintrag im Map-Container
|
|
// interne_datenbasis_Fahrspur, der zu der uebergebenen Verlegeende-MVP
|
|
// das zugehoerige Verlegeende bildet und liefert den Key zurueck.
|
|
// Wird kein entsprechender Eintrag gefunden, wird der uebergebene Key
|
|
// zurueckgeliefert.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
VERLEGEDATEN_KEY endpunkt_key = intern_key;
|
|
|
|
auto it = interne_datenbasis_Fahrspur.c().find(intern_key);
|
|
if (it == interne_datenbasis_Fahrspur.c().end())
|
|
return endpunkt_key;
|
|
const ausstattungs_id_t fahrzeug_identitaet = it->second.daten.header.identitaet;
|
|
|
|
++it;
|
|
while (it != interne_datenbasis_Fahrspur.c().end())
|
|
{
|
|
if (it->second.daten.header.identitaet != fahrzeug_identitaet)
|
|
break;
|
|
if (it->second.intstat > 3)
|
|
{
|
|
endpunkt_key = it->first;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
return (endpunkt_key);
|
|
|
|
} // end of Key_des_zugehoerigen_Verlegeendes
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static int IS_des_zugehoerigen_Verlegeendes(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt den Interpretationsstatus des Eintrags im
|
|
// Map-Container interne_datenbasis_Fahrspur, der zu der uebergebenen
|
|
// Verlegeanfangs-MVP das zugehoerige Verlegeende bildet und liefert
|
|
// ihn zurueck.
|
|
// Falls das Verlegeende noch nicht vorhanden ist, wird -1
|
|
// zurueckgegeben.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
//Suchen des nachfolgenden Eintrages des Fz mit is >3
|
|
for (auto it = interne_datenbasis_Fahrspur.c().find(intern_key) ; it != interne_datenbasis_Fahrspur.c().end(); ++it)
|
|
{
|
|
const FAHRSPUR_INTERN &fs = it->second;
|
|
if (fs.daten.header.identitaet != intern_key.fz_id)
|
|
break;
|
|
if (fs.intstat <= 3)
|
|
continue;
|
|
return fs.intstat;
|
|
}
|
|
return -1;
|
|
} // end of IS_des_zugehoerigen_Verlegeendes
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
VERLEGEDATEN_KEY Key_eines_Verlegebeginns_im_Zeitfenster(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Es wird sich im folgenden auf den zugehoerigen Verlegebeginn zur
|
|
// uebergebenen Verlegeende-MVP bezogen.
|
|
// Diese Funktion ermittelt einen Verlegebeginn-Eintrag aus dem
|
|
// Map-Container interne_datenbasis_Fahrspur, der zu der (uebergebenen)
|
|
// Verlegeanfangs-MVP im Zeitbereich +/- T_zusammen_max liegt und die
|
|
// S_zusammen_max einhaelt sowie von einem anderen Fz stammt.
|
|
// Vom gefundenen Eintrag wird der Key zurueckgeliefert, bzw. der
|
|
// uebergebnene Key, wenn kein solcher Eintrag gefunden wird.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
VERLEGEDATEN_KEY anfangspunkt_key = intern_key;
|
|
|
|
//Der Eintrag darf nicht vom selben Fz stammen wie der Endeeintrag
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
|
|
// Map-Container auf den zum uebergebenen Endeeintrag passenden Anfang
|
|
// setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
Key_des_zugehoerigen_Verlegebeginns(intern_key));
|
|
const unsigned int zeitpunkt_verlegebeginn =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
const gps_position_rt ort_verlegebeginn =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_position;
|
|
|
|
// Map-Container auf den Anfang setzen
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
bool map_test = interne_datenbasis_Fahrspur.size() > 0;
|
|
|
|
//Suchen des naechsten Eintrages eines anderen Fz mit is == 3
|
|
while ((map_test) && (anfangspunkt_key == intern_key))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
|
|
{
|
|
if((interne_datenbasis_Fahrspur.getData()->daten.header.identitaet != fahrzeug_identitaet) &&
|
|
(interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit <= T_zusammen_max + zeitpunkt_verlegebeginn) &&
|
|
(interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit > zeitpunkt_verlegebeginn - T_zusammen_max) &&
|
|
(Punktabstand(interne_datenbasis_Fahrspur.getData()->daten.gps_position, ort_verlegebeginn) < S_zusammen_max) &&
|
|
(IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != 6) &&
|
|
(IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != 7))
|
|
{
|
|
|
|
if((Winkel_zwischen_Fahrspuren_mehrerer_Fz(intern_key,interne_datenbasis_Fahrspur.getKey()) <= W_zusammen_max) &&
|
|
(Winkel_zwischen_Fahrspuren_mehrerer_Fz(intern_key,interne_datenbasis_Fahrspur.getKey()) != -1))
|
|
anfangspunkt_key = interne_datenbasis_Fahrspur.getKey();
|
|
|
|
}
|
|
}
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(+1);
|
|
}
|
|
|
|
return (anfangspunkt_key);
|
|
} // end of Key_eines_Verlegebeginns_im_Zeitfenster
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static VERLEGEDATEN_KEY Eine_Nachbarspur_ist_unvollstaendig(
|
|
const VERLEGEDATEN_KEY &intern_key, int IS1, int IS2)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Es wird sich im folgenden auf den zugehoerigen Verlegebeginn zur
|
|
// uebergebenen Verlegeende-MVP bezogen.
|
|
// Diese Funktion ermittelt einen Verlegebeginn-Eintrag aus dem
|
|
// Map-Container interne_datenbasis_Fahrspur, der zu der (uebergebenen)
|
|
// Verlegeanfangs-MVP im Zeitbereich +/- T_zusammen_max liegt und die
|
|
// S_zusammen_max einhaelt sowie von einem anderen Fz stammt
|
|
// UND keinen zugehoerigen Verlegeendeeintrag aufweist der
|
|
// Interpretationsstatus 8 oder 10 hat.
|
|
// Vom gefundenen Eintrag wird der Key zurueckgeliefert, bzw. der
|
|
// uebergebnene Key, wenn kein solcher Eintrag gefunden wird.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
VERLEGEDATEN_KEY langsamerer_partner_key = intern_key;
|
|
|
|
|
|
//Der Eintrag darf nicht vom selben Fz stammen wie der Endeeintrag
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
|
|
const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet;
|
|
|
|
// Map-Container auf den zum uebergebenen Endeeintrag passenden Anfang
|
|
// setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
Key_des_zugehoerigen_Verlegebeginns(intern_key));
|
|
const unsigned int zeitpunkt_verlegebeginn =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
const gps_position_rt ort_verlegebeginn =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_position;
|
|
|
|
// Map-Container auf den Anfang setzen
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
bool map_test = interne_datenbasis_Fahrspur.size() > 0;
|
|
|
|
//Suchen des naechsten Eintrages eines anderen Fz mit is == 3
|
|
while ((map_test) && (langsamerer_partner_key == intern_key))
|
|
{
|
|
if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
|
|
{
|
|
if
|
|
(
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.header.identitaet != fahrzeug_identitaet)
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_zeit.gps_zeit <=
|
|
T_zusammen_max + zeitpunkt_verlegebeginn)
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_zeit.gps_zeit >
|
|
zeitpunkt_verlegebeginn - T_zusammen_max)
|
|
|
|
&&
|
|
(Punktabstand(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position,
|
|
ort_verlegebeginn)
|
|
< S_zusammen_max)
|
|
&&
|
|
(IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != IS1)
|
|
&&
|
|
(IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != IS2)
|
|
)
|
|
{
|
|
|
|
if
|
|
((Winkel_zwischen_Fahrspuren_mehrerer_Fz(
|
|
intern_key, interne_datenbasis_Fahrspur.getKey())
|
|
<= W_zusammen_max)
|
|
&&
|
|
(Winkel_zwischen_Fahrspuren_mehrerer_Fz(
|
|
intern_key, interne_datenbasis_Fahrspur.getKey()) != -1)
|
|
)
|
|
langsamerer_partner_key = interne_datenbasis_Fahrspur.getKey();
|
|
|
|
}
|
|
}
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(+1);
|
|
}
|
|
|
|
return (langsamerer_partner_key);
|
|
} // end of Eine_Nachbarspur_ist_unvollstaendig
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static void Gib_den_Partnern_IS11(VERLEGEDATEN_KEY intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion ermittelt alle Verlegebeginn-Eintraege aus dem
|
|
// Map-Container interne_datenbasis_Fahrspur, die zur selben Minensperre // gehoeren, wie die eine MVP mit IS 11 und versieht diese ebenfalls mit // IS 11.
|
|
//
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
DEBUG_LOG(loggerMI()) << "Gib_den_Partnern_IS11: " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit;
|
|
VERLEGEDATEN_KEY endpunkt_key_eines_partners = intern_key;
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
intern_key = endpunkt_key_eines_partners;
|
|
// Map-Container auf den zum uebergebenen Endeeintrag passenden Anfang
|
|
// setzen
|
|
interne_datenbasis_Fahrspur.finden_eintrag_container(
|
|
Key_des_zugehoerigen_Verlegebeginns(endpunkt_key_eines_partners));
|
|
const unsigned int zeitpunkt_verlegebeginn =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
|
|
const gps_position_rt ort_verlegebeginn =
|
|
interne_datenbasis_Fahrspur.getData()->daten.gps_position;
|
|
// Map-Container auf den Anfang setzen
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
bool map_test = interne_datenbasis_Fahrspur.size() > 0;
|
|
|
|
//Suchen des naechsten Eintrages eines anderen Fz mit is == 3
|
|
while (map_test)
|
|
{
|
|
if ((interne_datenbasis_Fahrspur.getData()->intstat == 3)
|
|
&& (IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) == 10))
|
|
{
|
|
if
|
|
(
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_zeit.gps_zeit <=
|
|
T_zusammen_max + zeitpunkt_verlegebeginn)
|
|
&&
|
|
(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_zeit.gps_zeit >
|
|
zeitpunkt_verlegebeginn - T_zusammen_max)
|
|
&&
|
|
(Punktabstand(interne_datenbasis_Fahrspur.getData()->
|
|
daten.gps_position,
|
|
ort_verlegebeginn)
|
|
< S_zusammen_max)
|
|
&&
|
|
(Winkel_zwischen_Fahrspuren_mehrerer_Fz(
|
|
intern_key,interne_datenbasis_Fahrspur.getKey())
|
|
<= W_zusammen_max)
|
|
&&
|
|
(Winkel_zwischen_Fahrspuren_mehrerer_Fz(
|
|
intern_key,interne_datenbasis_Fahrspur.getKey()) != -1)
|
|
)
|
|
{
|
|
//Der zugehoerige Verlegeende-Eintrag wird mit
|
|
//Interpretationsstatus 11 versehen
|
|
|
|
//Suchen des nachfolgenden Eintrages des Fz mit is ==10
|
|
while ((interne_datenbasis_Fahrspur.iter_modify(+1))
|
|
&& (interne_datenbasis_Fahrspur.getData()->intstat != 10))
|
|
;
|
|
|
|
endpunkt_key_eines_partners =
|
|
interne_datenbasis_Fahrspur.getKey();
|
|
|
|
interne_datenbasis_Fahrspur.getData()->intstat = 11;
|
|
interne_datenbasis_Fahrspur.iter_reset();
|
|
}
|
|
}
|
|
map_test = interne_datenbasis_Fahrspur.iter_modify(+1);
|
|
}
|
|
}
|
|
} // end of Gib_den_Partnern_IS11
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
static inline PositionMitZeit getPrev(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator it,
|
|
ausstattungs_id_t identitaet)
|
|
{
|
|
PositionMitZeit ret;
|
|
if (it == interne_datenbasis_Fahrspur.c().begin())
|
|
return ret;
|
|
--it;
|
|
if (it->second.daten.header.identitaet != identitaet)
|
|
return ret;
|
|
ret.pos = it->second.daten.gps_position;
|
|
ret.zeit = it->second.daten.gps_zeit.gps_zeit;
|
|
return ret;
|
|
}
|
|
|
|
static inline PositionMitZeit getCurr(const std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator &it)
|
|
{
|
|
PositionMitZeit ret;
|
|
ret.pos = it->second.daten.gps_position;
|
|
ret.zeit = it->second.daten.gps_zeit.gps_zeit;
|
|
return ret;
|
|
}
|
|
|
|
static inline PositionMitZeit getNext(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator it,
|
|
ausstattungs_id_t identitaet)
|
|
{
|
|
PositionMitZeit ret;
|
|
if (it == interne_datenbasis_Fahrspur.c().end())
|
|
return ret;
|
|
++it;
|
|
if (it == interne_datenbasis_Fahrspur.c().end() || it->second.daten.header.identitaet != identitaet)
|
|
return ret;
|
|
ret.pos = it->second.daten.gps_position;
|
|
ret.zeit = it->second.daten.gps_zeit.gps_zeit;
|
|
return ret;
|
|
}
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B1(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag eine
|
|
// Minenverlegeposition(MVP) ist, die keiner Verlegespur zugeordnet
|
|
// werden kann.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Das Fz innerhalb von T_allein_Luecke_max keine nachfolgende MVP
|
|
// gesendet hat ODER die nachfolgende MVP gegen S_allein_Luecke_max
|
|
// verstoesst)
|
|
// UND
|
|
// (Die Vorgaengler-MVP gegen T_allein_Luecke_max verstoesst bzw. diese
|
|
// nicht vorhanden ist ODER die Vorgaenger-MVP gegen S_allein_Luecke_max
|
|
// verstoesst)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
// Map-Container auf aktuellen Eintrag setzen
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
/*
|
|
if( ( (
|
|
((time(0) > zeit2 + T_allein_Luecke_max) && (zeit3 == 0)) ||
|
|
((zeit3 - zeit2 > T_allein_Luecke_max) && (zeit3 != 0))
|
|
) ||
|
|
(Punktabstand(ort2, ort3) > S_allein_Luecke_max)
|
|
)
|
|
&&
|
|
(
|
|
((zeit1 != 0) && (zeit2 - zeit1 > T_allein_Luecke_max))
|
|
||
|
|
((Punktabstand(ort2, ort1) > S_allein_Luecke_max) || (zeit1 == 0))
|
|
)
|
|
)
|
|
return (true);*/
|
|
// Keine MVP-Zuordnung wenn:
|
|
// Vorgaenger: nicht vorhanden oder raeumlicher oder zeiticher Abstand zu groß
|
|
// falls zutreffend Nachfolger: nicht vorhanden oder raeumlicher oder zeiticher Abstand zu groß
|
|
// falls zutreffend Alter der pruefen
|
|
|
|
// Pruefung auf Vorgaenger
|
|
if ((p1.zeit == 0) || (Punktabstand(p2.pos, p1.pos) > S_allein_Luecke_max) || (p2.zeit - p1.zeit > T_allein_Luecke_max))
|
|
//Pruefung auf Nachfolger
|
|
if ((p3.zeit == 0) || (Punktabstand(p2.pos, p3.pos) > S_allein_Luecke_max) || (p3.zeit - p2.zeit > T_allein_Luecke_max))
|
|
// Pruefung auf zu alt
|
|
if (time(nullptr) > (p2.zeit + T_allein_Luecke_max))
|
|
return (true);
|
|
|
|
return (false);
|
|
} // end of B1
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B2(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag einer
|
|
// Verlegespur zugerechnet werden kann.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Das Fz eine Vorgaenger-MVP gesendet hat, die T_allein_Luecke_max
|
|
// UND S_allein_Luecke_max einhaelt)
|
|
// ODER
|
|
// (Das Fz eine Nachfolge-MVP gesendet hat, die T_allein_Luecke_max
|
|
// UND S_allein_Luecke_max einhaelt)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
if (
|
|
(
|
|
((p1.zeit != 0) && (p2.zeit - p1.zeit <= T_allein_Luecke_max))
|
|
&&
|
|
(Punktabstand(p2.pos, p1.pos) <= S_allein_Luecke_max)
|
|
)
|
|
||
|
|
(
|
|
((p3.zeit != 0) && (p3.zeit - p2.zeit <= T_allein_Luecke_max))
|
|
&&
|
|
(Punktabstand(p2.pos, p3.pos) <= S_allein_Luecke_max)
|
|
)
|
|
)
|
|
return (true);
|
|
return (false);
|
|
} // end of B2
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B3(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Anfangspunkt einer Verlegespur ist.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Das Fz keine Vorgaenger-MVP gesendet hat ODER eine Vorgaenger-MVP
|
|
// gesendet hat, die gegen T_allein_Luecke_max ODER S_allein_Luecke max
|
|
// verstoesst)
|
|
// UND
|
|
// (Das Fz eine Nachfolge-MVP gesendet hat, die T_allein_Luecke_max
|
|
// UND S_allein_Luecke_max einhaelt)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
if (
|
|
(
|
|
((p1.zeit == 0) || (p2.zeit - p1.zeit > T_allein_Luecke_max))
|
|
||
|
|
(Punktabstand(p2.pos, p1.pos) > S_allein_Luecke_max)
|
|
)
|
|
&&
|
|
(
|
|
((p3.zeit != 0) && (p3.zeit - p2.zeit <= T_allein_Luecke_max))
|
|
&&
|
|
(Punktabstand(p2.pos, p3.pos) <= S_allein_Luecke_max)
|
|
)
|
|
)
|
|
return (true);
|
|
return (false);
|
|
} // end of B3
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B4(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer Verlegespur ist.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Das Fz innerhalb von T_allein_Luecke_max keine Nachfolger-MVP
|
|
// gesendet hat ODER eine Nachfolger-MVP
|
|
// gesendet hat, die gegen T_allein_Luecke_max ODER S_allein_Luecke max
|
|
// verstoesst)
|
|
// UND
|
|
// (Das Fz eine Vorgaenger-MVP gesendet hat, die T_allein_Luecke_max
|
|
// UND S_allein_Luecke_max einhaelt)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
if (
|
|
(
|
|
(p1.zeit != 0)
|
|
&& (p2.zeit - p1.zeit <= T_allein_Luecke_max)
|
|
&& (Punktabstand(p2.pos, p1.pos) <= S_allein_Luecke_max)
|
|
)
|
|
&&
|
|
(
|
|
(((p3.zeit == 0) && (time(nullptr) > p2.zeit + T_allein_Luecke_max))
|
|
|| ((p3.zeit != 0) && (p3.zeit - p2.zeit > T_allein_Luecke_max))
|
|
)
|
|
||
|
|
((p3.zeit != 0) && (Punktabstand(p2.pos, p3.pos) > S_allein_Luecke_max))
|
|
)
|
|
)
|
|
return (true);
|
|
return (false);
|
|
} // end of B4
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B5(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer Verlegespur ist, die nicht durch das selbe Fahrzeug zu
|
|
// einer mehrspurigen Minensperre ausgebaut wird.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// [(Das Fz innerhalb von T_allein_max keine Nachfolger-MVP gesendet hat
|
|
// ODER eine Nachfolger-MVP gesendet hat, die gegen T_allein_max
|
|
// ODER S_allein_max verstoesst)
|
|
// ODER
|
|
// (Die Nachfolger-MVP den Interpretationsstatus 3 hat UND W_allein_max
|
|
// nicht eingehalten wird)]
|
|
// UND
|
|
// [(unmittelbar vor dem zugehoerigen Verlegeanfang keine MVP fuer
|
|
// dieses Fz mit Interpretationsstatus 6 im Map-Container vorliegt)]
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
if (
|
|
((Eintrag_vor_zugehoerigem_Verlegebeginn(itFs->first) != 6)
|
|
&& (Eintrag_vor_zugehoerigem_Verlegebeginn(itFs->first) != 4))
|
|
&&
|
|
(
|
|
((p3.zeit == 0) && (time(nullptr) > p2.zeit + T_allein_max))
|
|
||
|
|
((p3.zeit != 0) && (p3.zeit - p2.zeit > T_allein_max))
|
|
||
|
|
((p3.zeit != 0) && (Punktabstand(p2.pos, p3.pos) > S_allein_max))
|
|
||
|
|
((Eintrag_nach_dieser_MVP(itFs->first) == 3)
|
|
&&
|
|
(Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first)
|
|
> W_allein_max)
|
|
)
|
|
)
|
|
)
|
|
|
|
return (true);
|
|
return (false);
|
|
} // end of B5
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B6(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer Verlegespur ist, die durch das selbe Fahrzeug zu
|
|
// einer mehrspurigen Minensperre ausgebaut wird.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Das Fz eine Nachfolger-MVP gesendet hat, die den
|
|
// Interpretationsstatus 3 hat UND T_allein_max UND
|
|
// S_allein_max einhaelt)
|
|
// UND
|
|
// (W_allein_max zwischen den Fahrspuren eingehalten wird)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
if (
|
|
(Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first)
|
|
<= W_allein_max)
|
|
&&
|
|
(Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first) != -1)
|
|
&&
|
|
(Eintrag_nach_dieser_MVP(itFs->first) == 3)
|
|
&&
|
|
(p3.zeit - p2.zeit <= T_allein_max)
|
|
&&
|
|
(Punktabstand(p2.pos, p3.pos) <= S_allein_max)
|
|
)
|
|
return (true);
|
|
return (false);
|
|
} // end of B6
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B7(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer durch das selbe Fahrzeug mehrspurig fertig ausgebauten
|
|
// Minensperre ist.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Das Fz innerhalb von T_allein_max keine Nachfolger-MVP gesendet hat
|
|
// ODER eine Nachfolger-MVP gesendet hat, die gegen T_allein_max
|
|
// ODER S_allein_max verstoesst)
|
|
// UND
|
|
// (unmittelbar vor dem zugehoerigen Verlegeanfang eine MVP fuer dieses
|
|
// Fz mit Interpretationsstatus 6 im Map-Container vorliegt)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;
|
|
|
|
const PositionMitZeit p2 = getCurr(itFs);
|
|
const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);
|
|
|
|
if (
|
|
(Eintrag_vor_zugehoerigem_Verlegebeginn(itFs->first) == 6)
|
|
&&
|
|
((
|
|
((p3.zeit == 0) && (time(nullptr) > p2.zeit + T_allein_max))
|
|
||
|
|
((p3.zeit != 0) && (p3.zeit - p2.zeit > T_allein_max))
|
|
||
|
|
((p3.zeit != 0) && (Punktabstand(p2.pos, p3.pos) > S_allein_max))
|
|
)
|
|
||
|
|
((Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first)
|
|
> W_allein_max)
|
|
&&
|
|
(Eintrag_nach_dieser_MVP(itFs->first) == 3))
|
|
)
|
|
)
|
|
return (true);
|
|
return (false);
|
|
} // end of B7
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B8(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer Verlegespur ist, die zu einer Minensperre gehoert,
|
|
// die durch mehrere Fahrzeuge ausgebaut wird.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Der zu dieser Fahrspur gehoerende Verlegeanfang mindestens
|
|
// T_zusammen_max zurueckliegt)
|
|
// UND
|
|
// [(Bezueglich des Verlegebeginns der aktuellen Fahrspur, ein anderes
|
|
// Fz im Zeitraum +/- T_zusammen_max eine MVP mit Interpretationsstatus
|
|
// 3 aufweist UND diese S_zusammen_max einhaelt)
|
|
// UND
|
|
// (W_zusammen_max zwischen beiden Fahrspuren eingehalten wird)
|
|
// Der gesamte Map-Container wird durchsucht, bis ein solcher Eintrag
|
|
// gefunden ist.]
|
|
// Die Funktionalitaet in [] wird in der Funktion
|
|
// Key_eines_Verlegebeginns_im_Zeitfenster_realisiert.
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
bool bRet = false;
|
|
|
|
const auto itBegin = interne_datenbasis_Fahrspur.c().find(Key_des_zugehoerigen_Verlegebeginns(intern_key));
|
|
if (itBegin == interne_datenbasis_Fahrspur.c().end())
|
|
return bRet;
|
|
|
|
if ((time(nullptr) > itBegin->second.daten.gps_zeit.gps_zeit + T_zusammen_max) &&
|
|
(Key_eines_Verlegebeginns_im_Zeitfenster(intern_key) != intern_key))
|
|
bRet = true;
|
|
|
|
TRACE_LOG(loggerMI()) << "B8 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
|
|
return (bRet);
|
|
} // end of B8
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B9(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer Verlegespur ist, welche eine einspurige Minensperre
|
|
// bildet.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Der zu dieser Fahrspur gehoerende Verlegeanfang mindestens
|
|
// T_zusammen_max zurueckliegt)
|
|
// UND
|
|
// (B8 nicht erfuellt wird)
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
bool bRet = false;
|
|
|
|
const auto itBegin = interne_datenbasis_Fahrspur.c().find(Key_des_zugehoerigen_Verlegebeginns(intern_key));
|
|
if (itBegin == interne_datenbasis_Fahrspur.c().end())
|
|
return bRet;
|
|
|
|
if ((time(nullptr) > itBegin->second.daten.gps_zeit.gps_zeit + T_zusammen_max) &&
|
|
(Key_eines_Verlegebeginns_im_Zeitfenster(intern_key) == intern_key))
|
|
bRet = true;
|
|
|
|
TRACE_LOG(loggerMI()) << "B9 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
|
|
return (bRet);
|
|
} // end of B9
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B10(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer durch mehrere Fahrzeuge angelegten Minensperre ist,
|
|
// von der schon mindestens zwei Fahrspuren fertig verlegt sind.
|
|
// Der Interpretationsstatus 10 wurde eingefuert, um sicherzustellen,
|
|
// dass alle Verlegespuren einer Minensperre erfasst werden, und nicht
|
|
// der Fall eintritt, dass eine ev. 3.Verlegespur unbeachtet bleibt.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Alle Eintraege, die fuer das Erfuellen von B8 bezueglich des
|
|
// aktuellen Endpunktes in Frage kommen, bereits einen zugehoerigen
|
|
// Endeeintrag mit Interpretationsstatus 8 oder 10 haben.
|
|
//
|
|
//
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
bool bRet = false;
|
|
|
|
if (Eine_Nachbarspur_ist_unvollstaendig(intern_key, 8, 10) == intern_key)
|
|
bRet = true;
|
|
|
|
TRACE_LOG(loggerMI()) << "B10 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
|
|
return (bRet);
|
|
} // end of B10
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
static bool B11(const VERLEGEDATEN_KEY &intern_key)
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion prueft den aktuellen Eintrag des Map-Containers
|
|
// interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
|
|
// Endpunkt einer durch mehrere Fahrzeuge angelegten Minensperre ist,
|
|
// von der schon mindestens zwei Fahrspuren fertig verlegt sind.
|
|
// Der Interpretationsstatus 10 wurde eingefuert, um sicherzustellen,
|
|
// dass alle Verlegespuren einer Minensperre erfasst werden, und nicht
|
|
// der Fall eintritt, dass eine ev. 3.Verlegespur unbeachtet bleibt.
|
|
// Diese Funktion gibt true zurueck, wenn
|
|
// (Alle Eintraege, die fuer das Erfuellen von B8 bezueglich des
|
|
// aktuellen Endpunktes in Frage kommen, bereits einen zugehoerigen
|
|
// Endeeintrag mit Interpretationsstatus 10 oder 11 haben.
|
|
//
|
|
//
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
bool bRet = false;
|
|
|
|
if (Eine_Nachbarspur_ist_unvollstaendig(intern_key, 10, 11) == intern_key)
|
|
bRet = true;
|
|
|
|
TRACE_LOG(loggerMI()) << "B11 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
|
|
return (bRet);
|
|
} // end of B11
|
|
//-------------------------------------------------------------------------
|
|
|
|
//f+-----------------------------------------------------------------------
|
|
void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::processData()
|
|
//-------------------------------------------------------------------------
|
|
// PURPOSE:
|
|
// Diese Funktion wird in tcl_zssiwi_control zyklisch eingeplant.
|
|
// Die Eintraege im internen Map-Container interne_datenbasis_Fahrspur
|
|
// werden mit dem 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 meherer 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
|
|
//
|
|
//
|
|
// FORMAL PARAMETERS:
|
|
// (Beschreibung der Formalparameter)
|
|
//
|
|
// RETURN:
|
|
// (Beschreibung des Returnwertes)
|
|
//
|
|
//f------------------------------------------------------------------------
|
|
{
|
|
//Kontrollausgabe
|
|
// lout << setprio(LM_INFO)
|
|
// << "Funktion 'ZSSI_WI_Minen_Interpreter' aufgerufen" << endl;
|
|
|
|
|
|
//Es werden alle Eintraege geloescht die nicht den
|
|
//Betriebszustand VERLEGEN aufweisen
|
|
|
|
auto &cont = interne_datenbasis_Fahrspur.c();
|
|
auto it = cont.begin();
|
|
while (it != cont.end())
|
|
{
|
|
const FAHRSPUR_INTERN &val = it->second;
|
|
if (val.daten.ss_betriebszustand != MV_VERLEGEN &&
|
|
val.daten.ss_betriebszustand != WMV_VERLEGEN)
|
|
it = cont.erase(it);
|
|
else
|
|
++it;
|
|
}
|
|
|
|
//Es wird entschieden, ob die die MVP keiner Verlegespur
|
|
//zugeordnet werden kann.
|
|
it = cont.begin();
|
|
while (it != cont.end())
|
|
{
|
|
const FAHRSPUR_INTERN &val = it->second;
|
|
if (val.intstat == 0 && B1(it))
|
|
{
|
|
//Diese Eintraege muessen geloescht werden!!
|
|
//sie wuerden intstat= 1 erhalten;
|
|
it = cont.erase(it);
|
|
}
|
|
else
|
|
++it;
|
|
}
|
|
|
|
//Es wird entschieden, ob die MVP einer Verlegespur zugeordnet werden
|
|
//kann.
|
|
for (auto it = cont.begin(); it != cont.end(); ++it)
|
|
{
|
|
FAHRSPUR_INTERN &val = it->second;
|
|
if (val.intstat == 0 && B2(it))
|
|
val.intstat = 2;
|
|
}
|
|
|
|
//Es wird entschieden, ob die zu einer Verlegespur gehoerige MVP einen
|
|
//Anfangs- oder Endpunkt einer Verlegespur bildet
|
|
for (auto it = cont.begin(); it != cont.end(); ++it)
|
|
{
|
|
FAHRSPUR_INTERN &val = it->second;
|
|
if (val.intstat == 2)
|
|
{
|
|
if (B3(it))
|
|
val.intstat = 3;
|
|
else if (B4(it))
|
|
val.intstat = 4;
|
|
}
|
|
}
|
|
|
|
//Es wird entschieden, ob die MVP die einen Endpunkt einer Verlegespur
|
|
//darstellt, zu einer Minensperre gehoert, die durch das selbe Fahrzeug
|
|
//ausgebaut wird oder wurde.
|
|
for (auto it = cont.begin(); it != cont.end(); ++it)
|
|
{
|
|
FAHRSPUR_INTERN &val = it->second;
|
|
if (val.intstat == 4)
|
|
{
|
|
if (B5(it))
|
|
val.intstat = 5;
|
|
else if (B6(it))
|
|
val.intstat = 6;
|
|
else if (B7(it))
|
|
val.intstat = 7;
|
|
}
|
|
}
|
|
|
|
|
|
//Es wird entschieden, ob die MVP die einen Endpunkt einer Verlegespur
|
|
//darstellt, zu einer Minensperre gehoert, die durch mehrere Fahrzeuge
|
|
//ausgebaut wird oder wurde.
|
|
for (auto &c : cont)
|
|
{
|
|
FAHRSPUR_INTERN &val = c.second;
|
|
if (val.intstat == 5)
|
|
{
|
|
const auto key = keyFromFahrspur(val);
|
|
if (B8(key))
|
|
val.intstat = 8;
|
|
else if (B9(key))
|
|
val.intstat = 9;
|
|
}
|
|
}
|
|
|
|
//Es wird entschieden, ob die MVP einen Endpunkt einer durch mehrere
|
|
//Fahrzeuge angelegten Minensperre darstellt, von der bereits zwei
|
|
//Verlegespuen fertig verlegt sind.
|
|
for (auto &c : cont)
|
|
{
|
|
FAHRSPUR_INTERN &val = c.second;
|
|
if (val.intstat == 8 && B10(keyFromFahrspur(val)))
|
|
val.intstat = 10;
|
|
}
|
|
|
|
//Es wird entschieden, ob die MVP einen Endpunkt einer durch mehrere
|
|
//Fahrzeuge fertig angelegten Minensperre darstellt.
|
|
for (auto &c : cont)
|
|
{
|
|
FAHRSPUR_INTERN &val = c.second;
|
|
if (val.intstat == 10)
|
|
{
|
|
const auto key = keyFromFahrspur(val);
|
|
if (B11(key))
|
|
{
|
|
val.intstat = 11;
|
|
//Der gesamte map-Container wird nun nach zugehoerigen
|
|
//Verlegeendepositionen durchsucht. Das sind die, bei denen das
|
|
//Erfuellen von B8 durch den aktuellen Eintrag erfolgte.
|
|
//Um alle zusammengehoerigen Verlegespuren mit IS 11 versehen zu
|
|
//koennen, muss der Map-Container mehrfach durchsucht werden.
|
|
//Bei einem Start des Minenfeld_Generators, wird somit dafuer
|
|
//gesorgt, dass maximal eine durch mehrere Fz verlegte Minensperre
|
|
//(die Endpunkte tragen den Interpretationsstatus 11) im Map-Container
|
|
//vorhanden ist.
|
|
Gib_den_Partnern_IS11(key);
|
|
break; // warum auch immer, aber noetig (vorher: goto ... )
|
|
}
|
|
}
|
|
}
|
|
|
|
DEBUG_LOG(loggerMI()) << "------------------------------------------------";
|
|
for (const auto &c : interne_datenbasis_Fahrspur.c())
|
|
{
|
|
const VERLEGEDATEN_KEY &key = c.first;
|
|
const FAHRSPUR_INTERN &val = c.second;
|
|
DEBUG_LOG(loggerMI()) << "key: " << key.fz_id << "," << key.zeitpunkt.gps_zeit
|
|
<< ", val: " << val.intstat << ", " << val.daten.header.identitaet
|
|
<< ", " << val.daten.gps_position.utm_ostwert << "/" << val.daten.gps_position.utm_nordwert;
|
|
}
|
|
|
|
m_minenfeldGenerator->processData();
|
|
|
|
} // end of ZSSI_WI_Minen_Interpreter
|
|
//-------------------------------------------------------------------------
|
|
|
|
GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::ZSSI_WI_Minenfeld_Interpreter(QObject *parent)
|
|
: QObject(parent)
|
|
, m_minenfeldGenerator(new ZSSI_WI_Minenfeld_Generator(this))
|
|
{
|
|
connect(m_minenfeldGenerator, &ZSSI_WI_Minenfeld_Generator::sendeWirkfeld, this, &ZSSI_WI_Minenfeld_Interpreter::sendeWirkfeld);
|
|
}
|
|
|
|
GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::~ZSSI_WI_Minenfeld_Interpreter()
|
|
{
|
|
delete m_minenfeldGenerator;
|
|
}
|