ossimNitfHistoaProcessingEvent Class Reference

All comments in this document were taken from the online resource found at: More...

#include <ossimNitfHistoaTag.h>

Public Types
enum	{   PDATE_SIZE = 14, PSITE_SIZE = 10, PAS_SIZE = 10, NIPCOM_SIZE = 1,   IPCOM_SIZE = 80, IBPP_SIZE = 2, IPVTYPE_SIZE = 3, INBWC_SIZE = 10,   DISP_FLAG_SIZE = 1, ROT_FLAG_SIZE = 1, ROT_ANGLE_SIZE = 8, ASYM_FLAG_SIZE = 1,   ZOOMROW_SIZE = 7, ZOOMCOL_SIZE = 7, PROJ_FLAG_SIZE = 1, SHARP_FLAG_SIZE = 1,   SHARPFAM_SIZE = 2, SHARPMEM_SIZE = 2, MAG_FLAG_SIZE = 1, MAG_LEVEL_SIZE = 7,   DRA_FLAG_SIZE = 1, DRA_MULT_SIZE = 7, DRA_SUB_SIZE = 5, TTC_FLAG_SIZE = 1,   TTCFAM_SIZE = 2, TTCMEM_SIZE = 2, DEVLUT_FLAG_SIZE = 1, OBPP_SIZE = 2,   OPVTYPE_SIZE = 3, OUTBWC_SIZE = 10 }

Public Member Functions
	ossimNitfHistoaProcessingEvent ()
ossim_uint32	getSizeInBytes () const
void	parseStream (std::istream &in)
void	writeStream (std::ostream &out)
std::ostream &	print (std::ostream &out, const std::string &prefix=std::string()) const
void	clearFields ()

Private Attributes
char	m_pdate [PDATE_SIZE+1]
	Field: PDATE. More...
char	m_psite [PSITE_SIZE+1]
	Field: PSITE. More...
char	m_pas [PAS_SIZE+1]
	Field: PAS. More...
char	m_nIpcom [NIPCOM_SIZE+1]
	Field: NIPCOM. More...
std::vector< std::string >	m_comment
	Field IPCOM. More...
char	m_ibpp [IBPP_SIZE+1]
	Field: IBPP. More...
char	m_ipvType [IPVTYPE_SIZE+1]
	Field IPVTYPE. More...
char	m_inbwc [INBWC_SIZE+1]
	Field INBWC. More...
char	m_dispFlag [DISP_FLAG_SIZE+1]
	Field DISPLAY_FLAG. More...
char	m_rotFlag [ROT_FLAG_SIZE+1]
	Field ROT_FLAG. More...
char	m_rotAngle [ROT_ANGLE_SIZE+1]
	Field: ROT_ANGLE. More...
char	m_asymFlag [ASYM_FLAG_SIZE+1]
	Field: ASYM_FLAG. More...
char	m_zoomRow [ZOOMROW_SIZE+1]
	Field: ZOOMROW. More...
char	m_zoomCol [ZOOMCOL_SIZE+1]
	Field: ZOOMCOL. More...
char	m_projFlag [PROJ_FLAG_SIZE+1]
	Field: PROJ_FLAG. More...
char	m_sharpFlag [SHARP_FLAG_SIZE+1]
	Field: SHARP_FLAG. More...
char	m_sharpFam [SHARPFAM_SIZE+1]
	Field: SHARPFAM. More...
char	m_sharpMem [SHARPMEM_SIZE+1]
	Field: SHARPMEM. More...
char	m_magFlag [MAG_FLAG_SIZE+1]
	Field MAG_FLAG. More...
char	m_magLevel [MAG_LEVEL_SIZE+1]
	Field MAG_LEVEL. More...
char	m_draFlag [DRA_FLAG_SIZE+1]
	Field: DRA_FLAG. More...
char	m_draMult [DRA_MULT_SIZE+1]
	Field: DRA_MULT. More...
char	m_draSub [DRA_SUB_SIZE+1]
	Field: DRA_SUB. More...
char	m_ttcFlag [TTC_FLAG_SIZE+1]
	Field: TTC_FLAG. More...
char	m_ttcFam [TTCFAM_SIZE+1]
	Field: TTCFAM. More...
char	m_ttcMem [TTCMEM_SIZE+1]
	Field: TTCMEM. More...
char	m_devLutFlag [DEVLUT_FLAG_SIZE+1]
	Field: DEVLUT_FLAG. More...
char	m_obpp [OBPP_SIZE+1]
	Field OBPP. More...
char	m_opvType [OPVTYPE_SIZE+1]
	Field: OPVTYPE. More...
char	m_outBwc [OUTBWC_SIZE+1]
	Field: OUTBWC. More...

Detailed Description

All comments in this document were taken from the online resource found at:

http://www.gwg.nga.mil/ntb/baseline/docs/stdi0002/

Reference: HISTOA section (currently in Appendix L)

The purpose of the Softcopy History Tagged Record Extension, HISTOA, is to provide a history of the softcopy processing functions that have been applied to NSIF imagery. It is meant to describe previous processing actions and the current state of the imagery that was distributed within the intelligence and imagery user community. To be effective, HISTOA needs to be applied to the NSIF product as early as practical and must be updated each time the image is processed and saved by a softcopy processing system. This will allow the user to know with confidence the complete history of the imagery. HISTOA may be created as the NSIF image is created, or when the imagery is first modified.

Definition at line 35 of file ossimNitfHistoaTag.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
PDATE_SIZE
PSITE_SIZE
PAS_SIZE
NIPCOM_SIZE
IPCOM_SIZE
IBPP_SIZE
IPVTYPE_SIZE
INBWC_SIZE
DISP_FLAG_SIZE
ROT_FLAG_SIZE
ROT_ANGLE_SIZE
ASYM_FLAG_SIZE
ZOOMROW_SIZE
ZOOMCOL_SIZE
PROJ_FLAG_SIZE
SHARP_FLAG_SIZE
SHARPFAM_SIZE
SHARPMEM_SIZE
MAG_FLAG_SIZE
MAG_LEVEL_SIZE
DRA_FLAG_SIZE
DRA_MULT_SIZE
DRA_SUB_SIZE
TTC_FLAG_SIZE
TTCFAM_SIZE
TTCMEM_SIZE
DEVLUT_FLAG_SIZE
OBPP_SIZE
OPVTYPE_SIZE
OUTBWC_SIZE

Definition at line 38 of file ossimNitfHistoaTag.h.

   {
      PDATE_SIZE     = 14,
      PSITE_SIZE     = 10,
      PAS_SIZE       = 10,
      NIPCOM_SIZE    = 1,
      IPCOM_SIZE     = 80,
      IBPP_SIZE      = 2,
      IPVTYPE_SIZE   = 3,
      INBWC_SIZE     = 10,
      DISP_FLAG_SIZE = 1,
      ROT_FLAG_SIZE  = 1,
      ROT_ANGLE_SIZE = 8,
      ASYM_FLAG_SIZE = 1,
      ZOOMROW_SIZE   = 7,
      ZOOMCOL_SIZE   = 7,
      PROJ_FLAG_SIZE = 1,
      SHARP_FLAG_SIZE= 1,
      SHARPFAM_SIZE  = 2,
      SHARPMEM_SIZE  = 2,
      MAG_FLAG_SIZE  = 1,
      MAG_LEVEL_SIZE = 7,
      DRA_FLAG_SIZE  = 1,
      DRA_MULT_SIZE  = 7,
      DRA_SUB_SIZE   = 5,
      TTC_FLAG_SIZE  = 1,
      TTCFAM_SIZE    = 2,
      TTCMEM_SIZE    = 2,
      DEVLUT_FLAG_SIZE = 1,
      OBPP_SIZE      = 2,
      OPVTYPE_SIZE   = 3,
      OUTBWC_SIZE    = 10
   };

Constructor & Destructor Documentation

ossimNitfHistoaProcessingEvent()

ossimNitfHistoaProcessingEvent::ossimNitfHistoaProcessingEvent

(

)

Definition at line 17 of file ossimNitfHistoaTag.cpp.

References clearFields().

{
   clearFields();
}

Member Function Documentation

clearFields()

void ossimNitfHistoaProcessingEvent::clearFields

(

)

Definition at line 291 of file ossimNitfHistoaTag.cpp.

References ASYM_FLAG_SIZE, DISP_FLAG_SIZE, DRA_FLAG_SIZE, DRA_MULT_SIZE, DRA_SUB_SIZE, IBPP_SIZE, INBWC_SIZE, IPVTYPE_SIZE, m_asymFlag, m_comment, m_dispFlag, m_draFlag, m_draMult, m_draSub, m_ibpp, m_inbwc, m_ipvType, m_magFlag, m_magLevel, m_nIpcom, m_obpp, m_opvType, m_outBwc, m_pas, m_pdate, m_projFlag, m_psite, m_rotAngle, m_rotFlag, m_sharpFam, m_sharpFlag, m_sharpMem, m_ttcFam, m_ttcFlag, m_ttcMem, m_zoomCol, m_zoomRow, MAG_FLAG_SIZE, MAG_LEVEL_SIZE, NIPCOM_SIZE, OBPP_SIZE, OPVTYPE_SIZE, OUTBWC_SIZE, PAS_SIZE, PDATE_SIZE, PROJ_FLAG_SIZE, PSITE_SIZE, ROT_ANGLE_SIZE, ROT_FLAG_SIZE, SHARP_FLAG_SIZE, SHARPFAM_SIZE, SHARPMEM_SIZE, TTC_FLAG_SIZE, TTCFAM_SIZE, TTCMEM_SIZE, ZOOMCOL_SIZE, and ZOOMROW_SIZE.

Referenced by ossimNitfHistoaProcessingEvent(), and parseStream().

{
   memset(m_pdate, ' ', PDATE_SIZE+1);
   memset(m_psite, ' ', PSITE_SIZE+1);
   memset(m_pas, ' ', PAS_SIZE+1);
   memset(m_nIpcom, ' ', NIPCOM_SIZE+1);
   memset(m_ibpp, ' ', IBPP_SIZE+1);
   memset(m_ipvType, ' ', IPVTYPE_SIZE+1);
   
   memset(m_inbwc, ' ', INBWC_SIZE);
   memset(m_dispFlag, 0, DISP_FLAG_SIZE);
   memset(m_rotFlag, 0, DISP_FLAG_SIZE);
   memset(m_rotAngle, 0, ROT_ANGLE_SIZE);
   m_rotAngle[3]='.';
   memset(m_projFlag, 0, PROJ_FLAG_SIZE);
   memset(m_asymFlag, 0, ASYM_FLAG_SIZE);
   memset(m_zoomRow, 0, ZOOMROW_SIZE);
   m_zoomRow[2]='.';
   memset(m_zoomCol, 0, ZOOMCOL_SIZE);
   m_zoomCol[2]='.';
   memset(m_sharpFlag, 0, SHARP_FLAG_SIZE);
   memset(m_sharpFam, ' ', SHARPFAM_SIZE);
   memset(m_sharpMem, ' ', SHARPMEM_SIZE);
   memset(m_magFlag, 0, MAG_FLAG_SIZE);
   memset(m_magLevel, ' ', MAG_LEVEL_SIZE);
   memset(m_draFlag, 0, DRA_FLAG_SIZE);
   memset(m_draMult, ' ', DRA_MULT_SIZE);
   
   memset(m_draSub, ' ', DRA_SUB_SIZE);
   memset(m_ttcFlag, 0, TTC_FLAG_SIZE);
   memset(m_ttcFam, ' ', TTCFAM_SIZE);
   memset(m_ttcMem, ' ', TTCMEM_SIZE);
   memset(m_obpp, ' ', OBPP_SIZE);
   memset(m_opvType, ' ', OPVTYPE_SIZE);
   memset(m_outBwc, ' ', OUTBWC_SIZE);
   
   m_pdate[PDATE_SIZE]     = '\0';
   m_psite[PSITE_SIZE]     = '\0';
   m_pas[PAS_SIZE]         = '\0';
   m_nIpcom[NIPCOM_SIZE]   = '\0';
   m_ibpp[IBPP_SIZE]       = '\0';
   m_ipvType[IPVTYPE_SIZE] = '\0';
   
   m_comment.clear();

   m_inbwc[INBWC_SIZE] = '\0';
   m_dispFlag[DISP_FLAG_SIZE] = '\0';
   m_rotFlag[ROT_FLAG_SIZE] = '\0';
   m_rotAngle[ROT_ANGLE_SIZE] = '\0';
   m_projFlag[PROJ_FLAG_SIZE] = '\0';
   m_asymFlag[ASYM_FLAG_SIZE] = '\0';
   m_zoomRow[ZOOMROW_SIZE] = '\0';
   m_zoomCol[ZOOMCOL_SIZE] = '\0';
   m_sharpFlag[SHARP_FLAG_SIZE] = '\0';
   m_sharpFam[SHARPFAM_SIZE] = '\0';
   m_sharpMem[SHARPMEM_SIZE] = '\0';
   m_magFlag[MAG_FLAG_SIZE] = '\0';
   m_magLevel[MAG_LEVEL_SIZE] = '\0';
   m_draFlag[DRA_FLAG_SIZE] = '\0';
   m_draMult[DRA_MULT_SIZE] = '\0';
   m_draSub[DRA_SUB_SIZE] = '\0';
   m_ttcFlag[TTC_FLAG_SIZE] = '\0';
   m_ttcFam[TTCFAM_SIZE] = '\0';
   m_ttcMem[TTCMEM_SIZE] = '\0';
   m_obpp[OBPP_SIZE] = '\0';
   m_opvType[OPVTYPE_SIZE] = '\0';
   m_outBwc[OUTBWC_SIZE] = '\0';
}

getSizeInBytes()

ossim_uint32 ossimNitfHistoaProcessingEvent::getSizeInBytes

(

)

const

Definition at line 22 of file ossimNitfHistoaTag.cpp.

References ASYM_FLAG_SIZE, DEVLUT_FLAG_SIZE, DISP_FLAG_SIZE, DRA_FLAG_SIZE, DRA_MULT_SIZE, DRA_SUB_SIZE, IBPP_SIZE, INBWC_SIZE, IPCOM_SIZE, IPVTYPE_SIZE, m_asymFlag, m_comment, m_draFlag, m_magFlag, m_nIpcom, m_rotFlag, m_sharpFlag, m_ttcFlag, MAG_FLAG_SIZE, MAG_LEVEL_SIZE, NIPCOM_SIZE, OBPP_SIZE, OPVTYPE_SIZE, OUTBWC_SIZE, PAS_SIZE, PDATE_SIZE, PROJ_FLAG_SIZE, PSITE_SIZE, ROT_ANGLE_SIZE, ROT_FLAG_SIZE, SHARP_FLAG_SIZE, SHARPFAM_SIZE, SHARPMEM_SIZE, TTC_FLAG_SIZE, TTCFAM_SIZE, TTCMEM_SIZE, ZOOMCOL_SIZE, and ZOOMROW_SIZE.

{
   ossim_uint32 sizeInBytes = (PDATE_SIZE + PSITE_SIZE + PAS_SIZE + NIPCOM_SIZE);

   if ( (*m_nIpcom != '0') && m_comment.size() )
   {
      sizeInBytes += ( m_comment.size() * IPCOM_SIZE );
   }

   sizeInBytes += (IBPP_SIZE + IPVTYPE_SIZE + INBWC_SIZE + 
                   DISP_FLAG_SIZE + ROT_FLAG_SIZE);

   if(*m_rotFlag == '1')
   {
      sizeInBytes += ROT_ANGLE_SIZE;
   }
   
   sizeInBytes += ASYM_FLAG_SIZE;
   if(*m_asymFlag == '1')
   {
      sizeInBytes += (ZOOMROW_SIZE + ZOOMCOL_SIZE);
   }
   
   sizeInBytes += ( PROJ_FLAG_SIZE + SHARP_FLAG_SIZE );
   if(*m_sharpFlag == '1')
   {
      sizeInBytes += (SHARPFAM_SIZE + SHARPMEM_SIZE);
   }

   sizeInBytes += MAG_FLAG_SIZE;
   if(*m_magFlag == '1')
   {
      sizeInBytes += MAG_LEVEL_SIZE;
   }

   sizeInBytes += DRA_FLAG_SIZE;
   if(*m_draFlag == '1')
   {
      sizeInBytes += (DRA_MULT_SIZE + DRA_SUB_SIZE);
   }

   sizeInBytes += TTC_FLAG_SIZE;
   if(*m_ttcFlag == '1')
   {
      sizeInBytes += (TTCFAM_SIZE + TTCMEM_SIZE);
   }

   sizeInBytes += DEVLUT_FLAG_SIZE + OBPP_SIZE + OPVTYPE_SIZE + OUTBWC_SIZE;

   return sizeInBytes;
}

parseStream()

void ossimNitfHistoaProcessingEvent::parseStream

(

std::istream &

in

)

Definition at line 74 of file ossimNitfHistoaTag.cpp.

References ASYM_FLAG_SIZE, clearFields(), DEVLUT_FLAG_SIZE, DISP_FLAG_SIZE, DRA_FLAG_SIZE, DRA_MULT_SIZE, DRA_SUB_SIZE, IBPP_SIZE, INBWC_SIZE, IPCOM_SIZE, IPVTYPE_SIZE, m_asymFlag, m_comment, m_devLutFlag, m_dispFlag, m_draFlag, m_draMult, m_draSub, m_ibpp, m_inbwc, m_ipvType, m_magFlag, m_magLevel, m_nIpcom, m_obpp, m_opvType, m_outBwc, m_pas, m_pdate, m_projFlag, m_psite, m_rotAngle, m_rotFlag, m_sharpFam, m_sharpFlag, m_sharpMem, m_ttcFam, m_ttcFlag, m_ttcMem, m_zoomCol, m_zoomRow, MAG_FLAG_SIZE, MAG_LEVEL_SIZE, NIPCOM_SIZE, OBPP_SIZE, OPVTYPE_SIZE, OUTBWC_SIZE, PAS_SIZE, PDATE_SIZE, PROJ_FLAG_SIZE, PSITE_SIZE, ROT_ANGLE_SIZE, ROT_FLAG_SIZE, SHARP_FLAG_SIZE, SHARPFAM_SIZE, SHARPMEM_SIZE, ossimString::toUInt32(), TTC_FLAG_SIZE, TTCFAM_SIZE, TTCMEM_SIZE, ZOOMCOL_SIZE, and ZOOMROW_SIZE.

Referenced by ossimNitfHistoaTag::parseStream().

{
   clearFields();

   in.read(m_pdate, PDATE_SIZE);
   in.read(m_psite, PSITE_SIZE);
   in.read(m_pas, PAS_SIZE);
   in.read(m_nIpcom, NIPCOM_SIZE);
   ossim_uint32 nIpcom = ossimString(m_nIpcom).toUInt32();
   if(nIpcom < 10)
   {
      ossim_uint32 idx = 0;
      for(;idx < nIpcom;++idx)
      {
         char tempBuf[IPCOM_SIZE+1];
         in.read(tempBuf, IPCOM_SIZE);
         tempBuf[IPCOM_SIZE] = '\0';
      
         // m_comment += std::string(tempBuf, tempBuf + 80);
         
         m_comment.push_back( std::string(tempBuf) );
      }
   }
   in.read(m_ibpp, IBPP_SIZE);
   in.read(m_ipvType, IPVTYPE_SIZE);
   
   in.read(m_inbwc, INBWC_SIZE);
   in.read(m_dispFlag, DISP_FLAG_SIZE);
   in.read(m_rotFlag, ROT_FLAG_SIZE);
   if(*m_rotFlag =='1')
   {
      in.read(m_rotAngle, ROT_ANGLE_SIZE);
   }

   in.read(m_asymFlag, ASYM_FLAG_SIZE);
   if(ossimString(m_asymFlag).toBool())
   {
      in.read(m_zoomRow, ZOOMROW_SIZE);
      in.read(m_zoomCol, ZOOMCOL_SIZE);
   }

   in.read(m_projFlag, PROJ_FLAG_SIZE);   
   in.read(m_sharpFlag, SHARP_FLAG_SIZE);
   if(ossimString(m_sharpFlag).toBool())
   {
      in.read(m_sharpFam, SHARPFAM_SIZE);
      in.read(m_sharpMem, SHARPMEM_SIZE);
   }

   in.read(m_magFlag, MAG_FLAG_SIZE);
   if(ossimString(m_magFlag).toBool())
   {
      in.read(m_magLevel, MAG_LEVEL_SIZE);
   }

   in.read(m_draFlag, DRA_FLAG_SIZE);
   if(ossimString(m_draFlag).toBool())
   {
      in.read(m_draMult, DRA_MULT_SIZE);
      in.read(m_draSub, DRA_SUB_SIZE);
   }

   in.read(m_ttcFlag, TTC_FLAG_SIZE);
   if(ossimString(m_ttcFlag).toBool())
   {
      in.read(m_ttcFam, TTCFAM_SIZE);
      in.read(m_ttcMem, TTCMEM_SIZE);
   }

   in.read(m_devLutFlag, DEVLUT_FLAG_SIZE);
   in.read(m_obpp, OBPP_SIZE);
   in.read(m_opvType, OPVTYPE_SIZE);
   in.read(m_outBwc, OUTBWC_SIZE);
}

print()

std::ostream & ossimNitfHistoaProcessingEvent::print	(	std::ostream &	out,
		const std::string &	prefix = std::string()
	)		const

Definition at line 210 of file ossimNitfHistoaTag.cpp.

References IPCOM_SIZE, m_asymFlag, m_comment, m_devLutFlag, m_dispFlag, m_draFlag, m_draMult, m_draSub, m_ibpp, m_inbwc, m_ipvType, m_magFlag, m_magLevel, m_nIpcom, m_obpp, m_opvType, m_outBwc, m_pas, m_pdate, m_projFlag, m_psite, m_rotAngle, m_rotFlag, m_sharpFam, m_sharpFlag, m_sharpMem, m_ttcFam, m_ttcFlag, m_ttcMem, m_zoomCol, m_zoomRow, ossimString::string(), ossimString::toString(), and ossimString::toUInt32().

{
   std::string pfx = prefix;
   pfx += ".";
   
   out << setiosflags(std::ios::left)
   << pfx << std::setw(24) << "PDATE:"     << m_pdate << "\n"
   << pfx << std::setw(24) << "PSITE:"  << m_psite << "\n"
   << pfx << std::setw(24) << "PAS:"  << m_pas << "\n"
   << pfx << std::setw(24) << "NIPCOM:"   << m_nIpcom << "\n";
   ossim_uint32 nIpcom = ossimString(m_nIpcom).toUInt32();
   if( ( nIpcom > 0 ) && ( nIpcom < 10 ) )
   {
      for( ossim_uint32 i = 0; i < nIpcom; ++i )
      {
         std::string s = "IPCOM";
         
         //---
         // NOTE:
         // Doing  s += ossimString::toString( i ).string() core dumping linux gcc version 4.7.0.
         //---
         std::string s2 = ossimString::toString( i ).string();
         s += s2;
         s += ":";
         out << pfx << std::setw(24) << s.c_str();
         out.write( m_comment[i].data(), IPCOM_SIZE );
         out << "\n";
      }
   }
   
   out << setiosflags(std::ios::left)
   << pfx << std::setw(24) << "IBPP:"     << m_ibpp << "\n"
   << pfx << std::setw(24) << "IPVTYPE:"     << m_ipvType << "\n"
   << pfx << std::setw(24) << "INBWC:"     << m_inbwc << "\n"
   << pfx << std::setw(24) << "DISP_FLAG:"     << m_dispFlag << "\n"
   << pfx << std::setw(24) << "ROT_FLAG:"     << m_rotFlag << "\n";
   if(*m_rotFlag == '1')
   {
      out<< pfx << std::setw(24) << "ROT_ANGLE:" << m_rotAngle << "\n";
   }

   out<< pfx << std::setw(24) << "ASYM_FLAG:" << m_asymFlag << "\n";
   
   if(*m_asymFlag=='1')
   {
      out<< pfx << std::setw(24) << "ZOOMROW:" << m_zoomRow << "\n";
      out<< pfx << std::setw(24) << "ZOOMCOL:" << m_zoomCol << "\n";
   }
   out<< pfx << std::setw(24) << "PROJ_FLAG:" << m_projFlag << "\n";
   out<< pfx << std::setw(24) << "SHARP_FLAG:" << *m_sharpFlag << "\n";
   if(*m_sharpFlag == '1')
   {
      out<< pfx << std::setw(24) << "SHARPFAM:" << m_sharpFam << "\n";
      out<< pfx << std::setw(24) << "SHARPMEM:" << m_sharpMem << "\n";
   }
   out<< pfx << std::setw(24) << "MAG_FLAG:" << *m_magFlag << "\n";
   if(*m_magFlag  == '1')
   {
      out<< pfx << std::setw(24) << "MAG_LEVEL:" << m_magLevel << "\n";
   }
   out<< pfx << std::setw(24) << "DRA_FLAG:" << *m_draFlag << "\n";
   if(*m_draFlag=='1')
   {
      out<< pfx << std::setw(24) << "DRA_MULT:" << m_draMult << "\n";
      out<< pfx << std::setw(24) << "DRA_SUB:" << m_draSub << "\n";
   }
   out<< pfx << std::setw(24) << "TTC_FLAG:" << *m_ttcFlag << "\n";
   if(*m_ttcFlag == '1')
   {
      out<< pfx << std::setw(24) << "TTCFAM:" << m_ttcFam << "\n";
      out<< pfx << std::setw(24) << "TTCMEM:" << m_ttcMem << "\n";
   }
   out<< pfx << std::setw(24) << "DEVLUT_FLAG:" << *m_devLutFlag << "\n";
   out<< pfx << std::setw(24) << "OBPP:" << m_obpp << "\n";
   out<< pfx << std::setw(24) << "OPVTYPE:" << m_opvType << "\n";
   out<< pfx << std::setw(24) << "OUTBWC:" << m_outBwc << "\n";
   
   return out;
}

writeStream()

void ossimNitfHistoaProcessingEvent::writeStream

(

std::ostream &

out

)

Definition at line 149 of file ossimNitfHistoaTag.cpp.

References ASYM_FLAG_SIZE, DEVLUT_FLAG_SIZE, DISP_FLAG_SIZE, DRA_FLAG_SIZE, DRA_MULT_SIZE, DRA_SUB_SIZE, IBPP_SIZE, INBWC_SIZE, IPCOM_SIZE, IPVTYPE_SIZE, m_asymFlag, m_comment, m_devLutFlag, m_dispFlag, m_draFlag, m_draMult, m_draSub, m_ibpp, m_inbwc, m_ipvType, m_magFlag, m_magLevel, m_nIpcom, m_obpp, m_opvType, m_outBwc, m_pas, m_pdate, m_projFlag, m_psite, m_rotAngle, m_rotFlag, m_sharpFam, m_sharpFlag, m_sharpMem, m_ttcFam, m_ttcFlag, m_ttcMem, m_zoomCol, m_zoomRow, MAG_FLAG_SIZE, MAG_LEVEL_SIZE, NIPCOM_SIZE, OBPP_SIZE, OPVTYPE_SIZE, OUTBWC_SIZE, PAS_SIZE, PDATE_SIZE, PROJ_FLAG_SIZE, PSITE_SIZE, ROT_ANGLE_SIZE, ROT_FLAG_SIZE, SHARP_FLAG_SIZE, SHARPFAM_SIZE, SHARPMEM_SIZE, ossimString::toUInt32(), TTC_FLAG_SIZE, TTCFAM_SIZE, TTCMEM_SIZE, ZOOMCOL_SIZE, and ZOOMROW_SIZE.

{
   out.write(m_pdate, PDATE_SIZE);
   out.write(m_psite, PSITE_SIZE);
   out.write(m_pas, PAS_SIZE);
   out.write(m_nIpcom, NIPCOM_SIZE);
   ossim_uint32 nIpcom = ossimString(m_nIpcom).toUInt32();
   if( (nIpcom > 0) && (nIpcom < 10) )
   {
      for( ossim_uint32 i = 0; i < nIpcom; ++i )
      {
         // Should size check std::string or make set method that ensures 80 chars.
         out.write( m_comment[i].data(), IPCOM_SIZE );
      }
   }
   out.write(m_ibpp, IBPP_SIZE);
   out.write(m_ipvType, IPVTYPE_SIZE);
   
   out.write(m_inbwc, INBWC_SIZE);
   out.write(m_dispFlag, DISP_FLAG_SIZE);
   out.write(m_rotFlag, ROT_FLAG_SIZE);
   if(*m_rotFlag =='1')
   {
      out.write(m_rotAngle, ROT_ANGLE_SIZE);
   }
   out.write(m_asymFlag, ASYM_FLAG_SIZE);
   if(*m_asymFlag == '1')
   {
      out.write(m_zoomRow, ZOOMROW_SIZE);
      out.write(m_zoomCol, ZOOMCOL_SIZE);
   }
   out.write(m_projFlag, PROJ_FLAG_SIZE);
   out.write(m_sharpFlag, SHARP_FLAG_SIZE);
   if(*m_sharpFlag == '1')
   {
      out.write(m_sharpFam, SHARPFAM_SIZE);
      out.write(m_sharpMem, SHARPMEM_SIZE);
   }
   out.write(m_magFlag, MAG_FLAG_SIZE);
   if(*m_magFlag == '1')
   {
      out.write(m_magLevel, MAG_LEVEL_SIZE);
   }
   out.write(m_draFlag, DRA_FLAG_SIZE);
   if(*m_draFlag == '1')
   {
      out.write(m_draMult, DRA_MULT_SIZE);
      out.write(m_draSub, DRA_SUB_SIZE);
   }
   out.write(m_ttcFlag, TTC_FLAG_SIZE);
   if(*m_ttcFlag == '1')
   {
      out.write(m_ttcFam, TTCFAM_SIZE);
      out.write(m_ttcMem, TTCMEM_SIZE);
   }
   out.write(m_devLutFlag, DEVLUT_FLAG_SIZE);
   out.write(m_obpp, OBPP_SIZE);
   out.write(m_opvType, OPVTYPE_SIZE);
   out.write(m_outBwc, OUTBWC_SIZE);
}

Member Data Documentation

m_asymFlag

char ossimNitfHistoaProcessingEvent::m_asymFlag[ASYM_FLAG_SIZE+1]

private

Field: ASYM_FLAG.

This field shall indicate if asymmetric correction has been applied to the image. This processing step is only allowed for certain types of EO processing. The valid field codes are 0 and 1, and a blank (BCS 0x20). A value of 0 means that asymmetric correction has not been applied to the image. A value of 1 means that asymmetric correction has been applied to the image. Since this field applies only to certain types of EO imagery, this field shall be filled with a blank (BCS 0x20) for all other system types. If this field is equal to 1, the ZOOMROW and ZOOMCOL fields must be filled with the magnification levels in the row (line) and column (element) directions, respectively.

Definition at line 287 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_comment

std::vector<std::string> ossimNitfHistoaProcessingEvent::m_comment

private

Field IPCOM.

This field shall contain the first line of comment text. The fields IPCOM1 to IPCOMn, if present shall contain free form alphanumeric text. They are intended for use as a single comment block and shall be used that way. This field shall be omitted if the value in NIPCOM field is zero. The comment field shall be used to clarify or indicate special processing not accounted for in the Processing Event Fields. Reasons for populating this field would be to vindicate alternate processing for multi-spectral imagery, to indicate the order of S/C processing steps contained within a single processing event, or to inform downstream users of potential problems with the image.

Definition at line 136 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_devLutFlag

char ossimNitfHistoaProcessingEvent::m_devLutFlag[DEVLUT_FLAG_SIZE+1]

private

Field: DEVLUT_FLAG.

This field shall indicate if device compensation LUT has been applied to the image. The valid field codes are 0 and 1. A value of 0 means that a device LUT has not been applied to the image. A value of 1 means that t device LUT has been applied to the image. The nature of the LUT may be specified in the comment section and should include the device for which the LUT is applied. If the device is not known, an appropriate method for describing the LUT shall be given.

Definition at line 459 of file ossimNitfHistoaTag.h.

Referenced by parseStream(), print(), and writeStream().

m_dispFlag

char ossimNitfHistoaProcessingEvent::m_dispFlag[DISP_FLAG_SIZE+1]

private

Field DISPLAY_FLAG.

This field shall indicate if the image is “Display-Ready.” The DISP_FLAG field applies only to System B, System D, and certain other systems. Display-Ready data has had a system-specific transformation applied to it that is described in appendix A. The valid field codes are 0 to 9 and a blank (BCS 0x20). A value of 0 means that image is not Display-Ready and must be converted to a displayable format, using the pre-defined mappings for Linlog or PEDF formats. A value of 1 means that the image is Display-Ready and needs only basic tonal processing and device compensation for corrects display. Since this field applies to Systems B and D imagery currently, the field shall be filled with a blank (BCS 0x20) for all other system types. Values 2 to 9 are reserved for future use and shall not be used at this time. A more detailed explanation of the Display-Ready transformations is provided in appendix A.

Definition at line 253 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_draFlag

char ossimNitfHistoaProcessingEvent::m_draFlag[DRA_FLAG_SIZE+1]

private

Field: DRA_FLAG.

This field shall indicate if a dynamic Range Adjustment (DRA) has been applied to the image. DRA is an affine transformation of the image pixel values of the form Y = DRA_MULT*(X – DRA_SUB), where X is the input pixel value, DRA_SUB is the DRA subtractor, DRA_MULT is the DRA multiplier, and Y is the output pixel value. The DRA is said to be spatially invariant when the DRA subtractor and DRA multiplier do not depend on pixel position. If the DRA subtractor and DRA multiplier do depend on pixel position, the DRA is said to be spatially variant. The valid field codes are 0, 1, and 2. A value of 0 means that a DRA has not been applied to the image. A value of 1 means that a spatially invariant DRA has been applied to the image. In this case, the DRA_SUB and DRA_MULT fields shall be filled with the appropriate codes. A value of 2 means that a spatially variant DRA has been applied to the image. In cases where DRA_FLAG equals 0 or 2, the DRA_SUB and DRA_MULT fields shall not be filled.

Definition at line 396 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_draMult

char ossimNitfHistoaProcessingEvent::m_draMult[DRA_MULT_SIZE+1]

private

Field: DRA_MULT.

This field shall contain the multiplier value of the DRA. The valid field codes are 000.000 to 999.999. This field is conditional on the DRA_FLAG field being equal to 1.

Definition at line 404 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_draSub

char ossimNitfHistoaProcessingEvent::m_draSub[DRA_SUB_SIZE+1]

private

Field: DRA_SUB.

This field shall contain the subtractor value of the DRA. The valid field codes are 000.000 to 999.999. This field is conditional on the DRA_FLAG field being equal to 1.

Definition at line 412 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_ibpp

char ossimNitfHistoaProcessingEvent::m_ibpp[IBPP_SIZE+1]

private

Field: IBPP.

This field shall contain the number of significant bits for each pixel before the processing functions denoted in the processing event have been performed and before compression. This type of pixel depth description is consistent with the ABPP field within the NSIF image subheader. For example, if an 11-bpp word is stored in 16 bits, this field would contain 11 and the NBPP field in the NSIF image subheader would contain 16. The valid IBPP field codes are 01 to 64, indicating 1 to 64 bpp.

Definition at line 148 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_inbwc

char ossimNitfHistoaProcessingEvent::m_inbwc[INBWC_SIZE+1]

private

Field INBWC.

This field shall indicate the type of bandwidth compression or expansion that has been applied to the image prior to any enhancements denoted in the processing event. The valid field codes to describe each type of compression are 5 byte character strings. The first two characters indicate the type of compression such as DCT or DPCM. The next two characters indicate either the bit rate or the quality level. The last character indicates if the process is compression or an expansion. Compression is denoted by a C, an E denotes expansion, and 0 indicates that neither process occurred. The types of compression are indicated by the following codes: Value Definition DP43 DPCM (Differential Pulse Coded Modulation) – 4.3 bpp DC13 DCT (Discrete Cosine Transform – 2.3 bpp DC23 DCT (Discrete Cosine Transform) – 2.3 bpp NJNL NSIF JPEG – Lossless NJQ0 NSIF JPEG – Quality Level 0 NJQ1 NSIF JPEG – Quality Level 1 NJQ2 NSIF JPEG – Quality Level 2 C11D NSIF Bi-level – 1D C12S NSIF Bi-level – 2DS C12H NSIF Bi-level – 2DH M11D NSIF Bi-level – 1D M12S NSIF Bi-level with masked blocks – 2DS M12H NSIF Bi-level with masked blocks – 2DH C207 NITF ARIDPCM – 0.75 bpp C214 NITF ARIDPCM – 1.40 bpp C223 NITF ARIDPCM – 2.30 bpp C245 NITF ARIDPCM – 4.50 bpp C3Q0 NSIF Lossy JPEG – Q0 Custom Tables C3Q1 NSIF Lossy JPEG – Q1 Default Tables C3Q2 NSIF Lossy JPEG – Q2 Default Tables C3Q3 NSIF Lossy JPEG – Q2 Default Tables C3Q4 NSIF Lossy JPEG – Q4 Default Tables C3Q5 NSIF Lossy JPEG – Q5 Default Tables M3Q0 NSIF Lossy JPEG with masked blocks – Q0 Custom M3Q1 NSIF Lossy JPEG with masked blocks – Q1 Default M3Q2 NSIF Lossy JPEG with masked blocks – Q2 Default M3Q3 NSIF Lossy JPEG with masked blocks – Q3 Default M3Q4 NSIF Lossy JPEG with masked blocks – Q4 Default M3Q5 NSIF Lossy JPEG with masked blocks – Q5 Default C4LO NSIF Vector Quantization – Lossy M4LO NSIF Vector Quantization with masked blocks C5NL NSIF Lossless JPEG M5NL NSIF Lossless JPEG with masked blocks NC00 NSIF uncompressed NM00 NSIF with masked blocks uncompressed I1Q1 NSIF Downsample JPEG – Q1 I1Q2 NSIF Downsample JPEG – Q2 I1Q3 NSIF Downsample JPEG – Q3 I1Q4 NSIF Downsample JPEG – Q4 I1Q5 NSIF Downsample JPEG – Q5 WVLO Wavelet Lossy WVNL Wavelet Lossless JP20 JPEG 2000 NONE No Compression UNKC Unknown Compression OTLO Unknown lossy compression – requires mandatory IPCOM entry to explain technique or source OTNL Unknown lossless compression – requires mandatory IPCOM entry to explain technique or source The entire BWC field is 10 bytes long to allow for the concatenation of up to 2 compression algorithms. Two consecutive 5 byte character strings shall indicate the application of two compression algorithms in succession. If only one operation is performed, then the remaining 5 characters are zero. Examples of valid codes for the BWC field are shown below. The DP43E00000 code indicates that a 4.3 DPCM compressed input image was expanded prior to NSIF formation. The DC13E00000 code indicates that 1.3 DCT compressed input image was expanded prior to NSIF formation. The NONE000000 code indicates that the input image to the NSIF formation process was uncompressed.

Definition at line 237 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_ipvType

char ossimNitfHistoaProcessingEvent::m_ipvType[IPVTYPE_SIZE+1]

private

Field IPVTYPE.

This field shall contain an indicator of the type of computer representation used for the value of each pixel before the processing functions denoted in the processing events have been performed and before compression. Valid entries are INT for integer, SI for 2’s complement signed integer, R for real, and C for complex. The databits of INT and SI values shall appear in the file in order of significance, beginning with the most significant bit (MSB) and ending with the least significant bit (LSB). INT and SI data types shall be limited to 16 bits. R values shall be represented according to IEEE 32-bit floating-point representation (IEEE754). C values shall be represented with the Real and Imaginary parts each represented in IEEE 32-bit floating point representation (IEEE754) and appearing adjacent four-byte blocks, first Real, then Imaginary. B (bi-level) pixel values shall be represented as single bits with value 1 or 0.

Definition at line 164 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_magFlag

char ossimNitfHistoaProcessingEvent::m_magFlag[MAG_FLAG_SIZE+1]

private

Field MAG_FLAG.

This field shall indicate if the image has been symmetrically (same amount in each direction) magnified during this processing step. The valid field codes are 0 and 1. A value of 0 means that the image was not magnified. A value of 1 means that the image has been magnified. If this field is equal to 1, then the MAG_LEVEL field shall be filled with the level of magnification.

Definition at line 366 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_magLevel

char ossimNitfHistoaProcessingEvent::m_magLevel[MAG_LEVEL_SIZE+1]

private

Field MAG_LEVEL.

This field shall contain the level of symmetrical magnification that has been applied to the image relative to the input image at this processing step. For example, a value of 02.0000 would indicate a 2X magnification relative to the input image. The valid field codes are 00.0000 to 99.9999. This field is conditional on the MAG_FLAG field. A value greater than 1 shall indicate that the image was magnified to a size larger than its previous size and a value less than 1 shall indicate the image size was decreased. The method of magnification shall be described in the comment section.

Definition at line 379 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_nIpcom

char ossimNitfHistoaProcessingEvent::m_nIpcom[NIPCOM_SIZE+1]

private

Field: NIPCOM.

This field shall contain the valid number of image processing comments for this processing event. The valid field codes are 0 to 9.

Definition at line 122 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_obpp

char ossimNitfHistoaProcessingEvent::m_obpp[OBPP_SIZE+1]

private

Field OBPP.

This field shall contain the number of significant bits for each pixel after the processing functions denoted in the processing event have been performed, but prior to any output compression. For example, if an 8 bpp System B image is mapped into Display-Ready space using the proper 8 to 11 bpp transformation (see appendix A), the IBPP field shall contain the actual number of data pixels, not the word length. For example, if an 11-bpp word were stored in 16 bits, this field would contain 11. The valid OBPP field codes are 01 to 64, indicating 1 to 64 bpp. In many cases, this field will match the IBPP field.

Definition at line 472 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_opvType

char ossimNitfHistoaProcessingEvent::m_opvType[OPVTYPE_SIZE+1]

private

Field: OPVTYPE.

This field shall contain an indicator of the type of computer representation used for the value of each pixel after the processing functions denoted in the processing event have been performed, but prior to any output compression. Valid entries are INT for integer, B for bi-level, SI for 2’s complement signed integer, R for real, and C for complex. The data bits of INT and SI values shall appear in the file in order of significance, beginning with the MSB and ending with the LSB. INT and SI data types shall be limited to 16 bits. R values shall be represented according to IEEE 32-bit floating-point representation (IEEE754). C values shall be represented with the Real and Imaginary parts each 32-bit floating point representation (IEEE754) and appearing adjacent four-byte blocks, first Real, then Imaginary. B (bi-level) pixel values shall be represented as single bits with value 1 or 0.

Definition at line 488 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_outBwc

char ossimNitfHistoaProcessingEvent::m_outBwc[OUTBWC_SIZE+1]

private

Field: OUTBWC.

This field shall indicate the type of bandwidth compression or expansion that has been applied to the image after any enhancements denoted in the processing event. The valid field codes to describe each type of compression are 5 byte character strings. The first two characters indicate the type of compression such as DCT or DPCM. The next two characters indicate either the bit rate or the quality level. The last character indicates if the process is compression or an expansion. Compression is denoted by a C, an E denotes expansion, and 0 indicates that neither process occurred. The types of compression are indicated by the same codes used in the INBWC field and can be found in the field description for INBWC. The entire BWC field is 10 bytes long to allow for the concatenation of up to 2 compression algorithms. Two consecutive 5 byte character strings shall indicate the application of two compression algorithms in succession. If only one operation is performed, then the remaining 5 characters are zero. Examples of valid codes for the BWC field are shown below. The NJQ1C00000 code indicates that the processed image was saved as a NSIF JPEG lossless compressed image. The NJNLC00000 indicates that the processed image was saved as a NSIF JPEG lossless compressed image. The C3Q3C00000 code indicates that the processed image was saved as a NSIF JPEG compressed image at quality level 3.

Definition at line 512 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_pas

char ossimNitfHistoaProcessingEvent::m_pas[PAS_SIZE+1]

private

Field: PAS.

This field shall contain the processing application software used to perform the processing steps cited in the event (e.g. IDEX, VITEC, or DIEPS). The version number of the application would also be helpful to include in this field.

Definition at line 114 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_pdate

char ossimNitfHistoaProcessingEvent::m_pdate[PDATE_SIZE+1]

private

Field: PDATE.

This field shall contain the date and time (UTC) on which the processing event occurred. The valid form of the field is CCYYMMDDhhmmss, where CC is the first two digits of the year (00 to 99), YY is the last two digits of the year (00 to 99), MM is the month (01 to 12), DD is the day of the month (01 to 31), hh is the hour (00 to 23), mm is the minute (00 to 59), and ss is the second (00 to 59). UTC (Zulu) is assumed to be the time zone designator to express the time of day. This field can be used in conjunction with the FDT field in the NSIF file header to determine if the History Tag has been updated each time the image was processed and saved. If the PDATE field and the FDT field are identical, the History Tag has been properly updated. If the fields are not identical, then the History Tag has not been properly updated and the data may not be accurate or timely.

Definition at line 96 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_projFlag

char ossimNitfHistoaProcessingEvent::m_projFlag[PROJ_FLAG_SIZE+1]

private

Field: PROJ_FLAG.

This field shall indicate if the image has been projected from the collection geometry into geometry more suitable for display. The valid field codes are 0 and 1. A value of 0 means that no geometric transformation has been applied to the image, meaning it is probably stilled in the collection geometry. A value of 1 means that the image has been projected into another geometry. If this field is equal to 1, then a description of the projection or rectification shall be given in the comment section.

Definition at line 319 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_psite

char ossimNitfHistoaProcessingEvent::m_psite[PSITE_SIZE+1]

private

Field: PSITE.

This field shall contain the name of the site or segment that performed the processing event. This 10 character alphanumeric field is free form text. Examples of PSITE entries are FOS, JWAC, or CENTCOM.

Definition at line 105 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_rotAngle

char ossimNitfHistoaProcessingEvent::m_rotAngle[ROT_ANGLE_SIZE+1]

private

Field: ROT_ANGLE.

This field shall contain the angel in degrees that the image has been rotated, where a positive angle denotes clockwise rotation. The valid field codes are 000.0000 to 359.9999. This field is conditional on the ROT_FLAG field being equal to 1. If the rotation has included an interpolation, then the interpolation method shall be described in the comment sections.

Definition at line 273 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_rotFlag

char ossimNitfHistoaProcessingEvent::m_rotFlag[ROT_FLAG_SIZE+1]

private

Field ROT_FLAG.

This field shall indicate if the image has been rotated. The valid field codes are 0 and 1. A value or 0 means that the image has not been rotated. A value of 1 means that the image has been rotated. If this field is equal to 1, then the ROT_ANGLE field must be filled with the angle of rotation.

Definition at line 263 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_sharpFam

char ossimNitfHistoaProcessingEvent::m_sharpFam[SHARPFAM_SIZE+1]

private

Field: SHARPFAM.

This field shall contain the number of the sharpening family, if a sharpening operation was applied to the image. The valid field codes are –1, 00 to 99. This field is conditional on the SHARP_FLAG field. Although the IDEX sharpening family numbers are one-based, many commercial softcopy systems use a zero-based system for their databases. For example, IDEX family 5 would be family 4 for many other softcopy systems. If the sharpening kernel is not a part of the existing group of families and members, a value of – shall be placed in this field and the nature of the sharpening kernel specified in the comment section. Refer to paragraph 15-5 for a more complete description of the sharpening kernel database.

Definition at line 344 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_sharpFlag

char ossimNitfHistoaProcessingEvent::m_sharpFlag[SHARP_FLAG_SIZE+1]

private

Field: SHARP_FLAG.

This field shall indicate if the image has been passed through a sharpening operation. The valid field codes are 0 and 1. A value of 0 means that no sharpening has been applied to the image. A value of 1 means that sharpening has been applied to the image. If this field is equal to 1, then the SHARPFAM and SHARPMEN fields must be filled with the appropriate numbers. Refer to paragraph 15.5 for a more complete description of the sharpening kernel database.

Definition at line 330 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_sharpMem

char ossimNitfHistoaProcessingEvent::m_sharpMem[SHARPMEM_SIZE+1]

private

Field: SHARPMEM.

This field shall contain the number of the sharpening member, if a sharpening operation was applied to the image. The valid field codes are –1, 00 to 99. This field is conditional on the SHARP_FLAG field. If the sharpening kernel is not a part of the existing group of families and members, a value of –1 shall be placed in this field and the nature of the sharpening kernel shall be specified in the comment section. Refer to 15.5 for a more complete description of the sharpening database.

Definition at line 356 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_ttcFam

char ossimNitfHistoaProcessingEvent::m_ttcFam[TTCFAM_SIZE+1]

private

Field: TTCFAM.

This field shall contain the number of the TTC family, if a TTC was applied to the image. The valid field codes are –1, 00 to 99. This field is conditional on the TTC_FLAG field. Although the IDEXZ TTC family numbers are one-based, many commercial softcopy systems use a zerobased system for their databases. For example, IDEX family 5 would be family 4 for many other softcopy systems. If the TTC is not a part of the existing group of families and members, a value of –1 shall be placed in this field and the nature of the TTC shall be specified in the comment section. Refer to paragraph 15-5 for a more complete description of the TTC database.

Definition at line 436 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_ttcFlag

char ossimNitfHistoaProcessingEvent::m_ttcFlag[TTC_FLAG_SIZE+1]

private

Field: TTC_FLAG.

This field shall indicate if a TTC (Tonal Transfer Curve) has been applied to the image. The valid field codes are 0 and 1. A value of 0 means that a TTC has not been applied to the image. A value of 1 means that a TTC has been applied to the image. If a TTC has been applied, then the TTCFAM and TTCNUM fields shall be filled with the appropriate codes. Refer to paragraph 15-5 for more complete description of the TTC database.

Definition at line 423 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), getSizeInBytes(), parseStream(), print(), and writeStream().

m_ttcMem

char ossimNitfHistoaProcessingEvent::m_ttcMem[TTCMEM_SIZE+1]

private

Field: TTCMEM.

This field shall contain the number of the TTC member, if a TTC was applied to the image. The valid field codes are 00 to 99. This field is conditional on the TTC_FLAG field. If the TTC is not a part of the existing group of families and members, a value of –1 shall be placed in this field and the nature of the TTC shall be specified in the comment section. Refer to paragraph 15-5 for a more complete description of the TTC database.

Definition at line 447 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_zoomCol

char ossimNitfHistoaProcessingEvent::m_zoomCol[ZOOMCOL_SIZE+1]

private

Field: ZOOMCOL.

This field shall contain the level of magnification that was applied to the image in the element or column direction, if asymmetric correction was applied. The valid field codes are 00.0000 to 99.9999. The level of magnification is relative to the input image at this processing step. This field is conditional on the ASYM_FLAG field.

Definition at line 307 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

m_zoomRow

char ossimNitfHistoaProcessingEvent::m_zoomRow[ZOOMROW_SIZE+1]

private

Field: ZOOMROW.

This field shall contain the level of magnification that was applied to the image in the line or row direction, if asymmetric correction was applied. The valid field codes are 00.0000 to 99.9999. The level of magnification is relative to the input image at this processing step. This field is conditional on the ASYM_FLAG field

Definition at line 297 of file ossimNitfHistoaTag.h.

Referenced by clearFields(), parseStream(), print(), and writeStream().

---

The documentation for this class was generated from the following files:

• ossimNitfHistoaTag.h
• ossimNitfHistoaTag.cpp