ossimNitfEngrdaTag.cpp

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// License:  LGPL
//
// See LICENSE.txt file in the top level directory for more details.
//
// Author:  David Burken
//
// Description: ENGRDA - Engineering Data tag class declaration.
//
// See document STDI-0002 (version 3), Appendix N for more info.
// 
//----------------------------------------------------------------------------
// $Id

#include <cstring>
#include <istream>
#include <iostream>
#include <iomanip>
#include <sstream>

#include <ossim/support_data/ossimNitfEngrdaTag.h>
#include <ossim/base/ossimNotify.h>
#include <ossim/base/ossimTrace.h>

static const ossimTrace traceDebug(ossimString("ossimNitfEngrda:debug"));

RTTI_DEF1(ossimNitfEngrdaTag, "ossimNitfEngrdaTag", ossimNitfRegisteredTag);

ossimNitfEngrdaTag::ossimNitfEngrdaTag()
   : ossimNitfRegisteredTag(std::string("ENGRDA"), 0)
{
   clearFields();
}

ossimNitfEngrdaTag::~ossimNitfEngrdaTag()
{
}

void ossimNitfEngrdaTag::parseStream(std::istream& in)
{
   clearFields();

   in.read(m_reSrc, RESRC_SIZE);
   in.read(m_reCnt, RECNT_SIZE);
 
   const ossim_uint16 ELEMENT_COUNT = ossimString(m_reCnt).toUInt16();
   
   for (ossim_uint16 i = 0; i < ELEMENT_COUNT; ++i)
   {
      ossimString os;
      ossim_uint32 size(0);
      
      char buf[TMP_BUF_SIZE];

      ossimEngDataElement element;

      // ENGLN - label length field
      in.read(element.m_engLn, ENGLN_SIZE);
      element.m_engLn[ENGLN_SIZE] = '\0';

      // ENGLBL - label field
      os = element.m_engLn;
      size = os.toUInt16();
      in.read(buf, size);
      buf[size] = '\0';
      element.m_engLbl = buf;

      // ENGMTXC - data column count
      in.read(element.m_engMtxC, ENGMTXC_SIZE);
      element.m_engMtxC[ENGMTXC_SIZE] = '\0';

      // ENGMTXR - data row count
      in.read(element.m_engMtxR, ENGMTXR_SIZE);
      element.m_engMtxR[ENGMTXR_SIZE] = '\0';

      // ENGTYP - Value Type of Engineering Data Element.
      in.get( element.m_engTyp );

      // ENGDTS - Engineering Data Element Size
      in.get( element.m_engDts );
      os = element.m_engDts;
      ossim_uint32 engDataElementSize = os.toUInt32();

      // ENGDATU - Engineering Data Units.
      in.read( element.m_engDatU, ENGDATU_SIZE );
      element.m_engDatU[ENGDATU_SIZE] = '\0';

      // ENGDATC - Engineering Data Count
      in.read(element.m_engDatC, ENGDATC_SIZE);
      element.m_engDatC[ENGDATC_SIZE] = '\0';
      os = element.m_engDatC;
      ossim_uint32 engDataCount = os.toUInt32();

      // ENGDATA - Engineering Data
      size = engDataElementSize * engDataCount;
      element.m_engDat.resize(size);
      in.read((char*)&(element.m_engDat.front()), size);
      
      m_data.push_back(element);

   } // Matches: for (ossim_uint16 i = 0; i < ELEMENT_COUNT; ++i)
}

void ossimNitfEngrdaTag::writeStream(std::ostream& out)
{
   //out.write(theAcMsnId, AC_MSN_ID_SIZE);
   // out.write(theAcTailNo, AC_TAIL_NO_SIZE);

   out.write(m_reSrc, RESRC_SIZE);
   out.write(m_reCnt, RECNT_SIZE);

   const ossim_uint16 ELEMENT_COUNT = ossimString(m_reCnt).toUInt16();
   
   for (ossim_uint16 i = 0; i < ELEMENT_COUNT; ++i)
   {
      // ENGLN - label length field      
      out.write(m_data[i].m_engLn, ENGLN_SIZE);

      // ENGLBL - label field
      out.write(m_data[i].m_engLbl.data(), (std::streamsize)m_data[i].m_engLbl.size());

      // ENGMTXC - data column count
      out.write(m_data[i].m_engMtxC, ENGMTXC_SIZE );

      // ENGMTXR - data row count
      out.write(m_data[i].m_engMtxR, ENGMTXR_SIZE );

      // ENGTYP - Value Type of Engineering Data Element.
      out.write( (char*)(&m_data[i].m_engTyp), ENGTYP_SIZE );

      // ENGDTS - Engineering Data Element Size
      out.write((char*)(&m_data[i].m_engDts), ENGDTS_SIZE );

      // ENGDATU - Engineering Data Units.
      out.write( m_data[i].m_engDatU, ENGDATU_SIZE );

      // ENGDATC - Engineering Data Count
      out.write( m_data[i].m_engDatC, ENGDATC_SIZE );

      // ENGDATA - Engineering Data NOTE: should be big endian...
      out.write((char*)&(m_data[i].m_engDat.front()),
                (std::streamsize)m_data[i].m_engDat.size());

   } // Matches: for (ossim_uint16 i = 0; i < ELEMENT_COUNT; ++i)
   
}

void ossimNitfEngrdaTag::clearFields()
{
   // BCS-N's to '0's, BCS-A's to ' '(spaces)

   // clear
   memset(m_reSrc, ' ', RESRC_SIZE);
   memset(m_reCnt, ' ', RECNT_SIZE);
   m_data.clear();

   // null terminate
   m_reSrc[RESRC_SIZE] = '\0';
   m_reCnt[RECNT_SIZE] = '\0';
}

std::ostream& ossimNitfEngrdaTag::print(
   std::ostream& out, const std::string& prefix) const
{
   std::string pfx = prefix;
   pfx += getTagName();
   pfx += ".";

   const ossim_uint32 W = 17;
   
   out << setiosflags(std::ios::left)
       << pfx << std::setw(W) << "CETAG:"
       << getTagName() << "\n"
       << pfx << std::setw(W) << "CEL:"   << getSizeInBytes() << "\n"
       << pfx << std::setw(W) << "RESRC:" << m_reSrc << "\n"
       << pfx << std::setw(W) << "RECNT:" << m_reCnt << "\n";

   for (ossim_uint32 i = 0; i < m_data.size(); ++i)
   {
      out << pfx << "ENGLN[" << i << std::setw(W-7) << "]:"
          << m_data[i].m_engLn << "\n"
          << pfx << "ENGLBL[" << i << std::setw(W-8) << "]:"
          << m_data[i].m_engLbl << "\n"
          << pfx << "ENGMTXC[" << i << std::setw(W-9) << "]:"
          << m_data[i].m_engMtxC << "\n"
          << pfx << "ENGMTXR[" << i << std::setw(W-9) << "]:"
          << m_data[i].m_engMtxR << "\n"
          << pfx << "ENGTYP[" << i << std::setw(W-8) << "]:"
          << std::string(1, m_data[i].m_engTyp) << "\n"
          << pfx << "ENGDTS[" << i << std::setw(W-8) << "]:"
          << std::string(1, m_data[i].m_engDts) << "\n"
          << pfx << "ENGDATU[" << i << std::setw(W-9) << "]:"
          << m_data[i].m_engDatU << "\n"
          << pfx << "ENGDATC[" << i << std::setw(W-9) << "]:"
          << m_data[i].m_engDat.size() << "\n";
      
      printData(out, m_data[i], i, pfx);
   }
   
   return out;
}

std::ostream& ossimNitfEngrdaTag::printData( std::ostream& out,
                                             const ossimEngDataElement& element,
                                             ossim_uint32 elIndex,
                                             const std::string& prefix ) const
{
   if (element.m_engTyp == 'A')
   {
      out << prefix << "ENGDATA[" << elIndex << std::setw(8) << "]:";
      
      std::vector<ossim_uint8>::const_iterator i = element.m_engDat.begin();
      while (i != element.m_engDat.end())
      {
         out << static_cast<ossim_int8>(*i);
         ++i;
      }
      out << "\n";
   }
   else
   {
      out << prefix << "ENGDATA[" << elIndex << std::setw(8) << "]:      NOT DISPLAYED\n";
      if ( traceDebug() )
      {
         ossimNotify(ossimNotifyLevel_WARN)
            << "ossimNitfEngrdaTag::printData WARNING unhandled data type."
            << "Data type = " << (char)element.m_engTyp << "\n"
            << std::endl;
      }
   } 
   return out;
}

template <class T>
void ossimNitfEngrdaTag::getValueAsString(
   T v, ossim_uint16 w, std::string& s) const
{
   std::ostringstream os;
   os << std::setw(w) << std::setfill('0') << setiosflags(ios::right) << v;
   s = os.str();
}