Initial commit

Lts/Viewer/SituationMap/Symbology/sidc_builder_base.cpp

@@ -0,0 +1,195 @@
+/**
+  * @RDE_HEADER@
+  * Class SidcBuilderBase
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+// Own
+#include "sidc_builder_base.h"
+#include "sidc_codec.h"
+
+// ESRI
+
+
+// Qt
+#include <QtCore/QDebug>
+
+
+namespace AdvancedSymbology
+{
+
+
+SidcBuilderBase::SidcBuilderBase(SymbolDictionary *symbolDictionary, const char *loggerName)
+  : SidcDefinitions(symbolDictionary, loggerName)
+{
+}
+
+
+QString SidcBuilderBase::baseSymbolCodeToSidc(const QString &baseSymbolCodeCodec)
+{
+  if (!SidcCodec::isEncoded(baseSymbolCodeCodec))
+  {
+    qCritical() << LOGFUNCTION << " baseSymbolCodeCodec input parameter isn't encoded: " << baseSymbolCodeCodec;
+    return QString();
+  }
+
+  switch (SidcCodec::decodeSidcType(baseSymbolCodeCodec))
+  {
+    case SidcCodec::SidcType::CivilEts:
+    case SidcCodec::SidcType::CivilXml:
+      return baseSymbolCodeCodec;
+    case SidcCodec::SidcType::Base:
+      break;
+    default :
+    {
+      qCritical() << LOGFUNCTION << " baseSymbolCodeCodec is not a base symbol code: " << baseSymbolCodeCodec;
+      return QString();
+    }
+  } // switch
+
+  QString       sidc;
+  QString       baseSymbolCode = SidcCodec::decodeRawSidc(baseSymbolCodeCodec);
+  SymbologyType symbologyType  = SidcCodec::decodeSymbologyType(baseSymbolCodeCodec);
+
+  if ((SymbologyType::MIL2525D == symbologyType) || (SymbologyType::APP6D == symbologyType))
+  {
+    //
+    // its MIL2525D or APP6D
+    //
+
+    if ((baseSymbolCode.size() != 8) && (baseSymbolCode.size() != 10))
+    {
+      return QString(); // failure !!
+    }
+
+    QRegExp sidcTemplate(QStringLiteral("^[0-9]{8}(_[0-9])?$"));
+
+    if (!sidcTemplate.exactMatch(baseSymbolCode))
+    {
+      return QString(); // Failure
+    }
+
+    // Version
+    sidc += QLatin1Char('1');
+    sidc += QLatin1Char('0');
+
+    // Standard Identity
+    sidc += QLatin1Char('0');
+    if (baseSymbolCode.size() == 10) sidc += baseSymbolCode[9];
+    else                             sidc += QLatin1Char('1');
+
+    // SymbolSet
+    sidc += baseSymbolCode[0];
+    sidc += baseSymbolCode[1];
+
+    // Status
+    sidc += QLatin1Char('0');
+
+    // HeadQuarter, TaskForce, Dummy
+    sidc += QLatin1Char('0');
+
+    // Amplifier/Descriptor
+    sidc += QLatin1Char('0');
+    sidc += QLatin1Char('0');
+
+    sidc += baseSymbolCode[2];
+    sidc += baseSymbolCode[3];
+    sidc += baseSymbolCode[4];
+    sidc += baseSymbolCode[5];
+    sidc += baseSymbolCode[6];
+    sidc += baseSymbolCode[7];
+
+    sidc = sidc.leftJustified(20, QLatin1Char('0'));
+
+    return SidcCodec::encodeComplete(symbologyType, sidc);
+  }
+ 
+  if (SymbologyType::APP6B == symbologyType)
+  {
+    sidc = baseSymbolCode;
+    sidc[1] = QLatin1Char('U');
+    sidc[3] = QLatin1Char('P');
+
+    return SidcCodec::encodeComplete(symbologyType, sidc);
+  }
+
+  return QString();
+} // QString SidcBuilderBase::baseSymbolCodeToSidc(const QString &baseSymbolCodeCodec)
+
+
+QString SidcBuilderBase::concreteSidcToBaseSymbolCode(const QString &sidcCodec)
+{
+  if (!SidcCodec::isEncoded(sidcCodec))
+  {
+    qCritical() << LOGFUNCTION << " sidcCodec is not a complete sidc: " << sidcCodec;
+    return QString();
+  }
+
+  switch (SidcCodec::decodeSidcType(sidcCodec))
+  {
+  case SidcCodec::SidcType::CivilEts:
+  case SidcCodec::SidcType::CivilXml:
+    return sidcCodec;
+    break;
+  case SidcCodec::SidcType::Complete:
+    break;
+  default :
+  {
+    qCritical() << LOGFUNCTION << " sidcCodec is not a complete sidc: " << sidcCodec;
+    return QString();
+  }
+  } // switch
+
+  const QString   &rawSidc      = SidcCodec::decodeRawSidc(sidcCodec);
+  SymbologyType   symbologyType = SidcCodec::decodeSymbologyType(sidcCodec);
+
+  switch (symbologyType)
+  {
+    case SymbologyType::APP6B    :
+    {
+      const QString & baseSymbolCode = normalizeAPP6BaseSymbolCode(rawSidc);
+     
+      return SidcCodec::encodeBaseSymbolCode(symbologyType, baseSymbolCode);
+    }
+    case SymbologyType::MIL2525C : return QString();
+    case SymbologyType::APP6D    : // it's same as MIL2525D
+    case SymbologyType::MIL2525D :
+    {
+      if (rawSidc.count() != 20)
+        return QString();
+
+      QString baseSymbolCode(
+        QStringRef(&rawSidc, 4, 2).toString() +
+        QStringRef(&rawSidc, 10, 6).toString());
+      return SidcCodec::encodeBaseSymbolCode(symbologyType, baseSymbolCode);
+    } break;
+
+    case SymbologyType::None: return QString();
+  }
+  return QString();
+  
+} // QString SidcBuilderBase::concreteSidcToBaseSymbolCode(const QString &sidcCodec)
+
+
+QString SidcBuilderBase::normalizeAPP6BaseSymbolCode(const QString & baseSymbolCode)
+{
+  QString baseNorm = baseSymbolCode;
+
+  baseNorm.resize(15, QLatin1Char('*'));
+
+  baseNorm[1]  = QLatin1Char('*');
+  baseNorm[3]  = QLatin1Char('*');
+
+  if (QLatin1Char('*') != baseNorm[10]) baseNorm[10] = QLatin1Char('-');
+  if (QLatin1Char('*') != baseNorm[11]) baseNorm[11] = QLatin1Char('-');
+  if (QLatin1Char('*') != baseNorm[14]) baseNorm[14] = QLatin1Char('-');
+
+  return baseNorm;
+
+} // QString SidcBuilderBase::normalizeAPP6BaseSymbolCode(const QString & baseSymbolCode)
+
+
+
+} // namespace AdvancedSymbology