/* --------------------------------------------------------------------
// $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
//-------------------------------------------------------------------------