ossimGeneralRasterInfo.h

Go to the documentation of this file.

//*******************************************************************
// Copyright (C) 2000 ImageLinks Inc.
//
// License:  MIT
// 
// See LICENSE.txt file in the top level directory for more details.
//
// Author:  David Burken
//
// Description:
//
// Contains class declaration for ossimGeneralRasterInfo
//*******************************************************************
//  $Id: ossimGeneralRasterInfo.h 22197 2013-03-12 02:00:55Z dburken $

#ifndef ossimGeneralRasterInfo_HEADER
#define ossimGeneralRasterInfo_HEADER 1

#include <ossim/base/ossimObject.h>
#include <ossim/base/ossimCommon.h>
#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimDrect.h>
#include <ossim/base/ossimErrorContext.h>
#include <ossim/base/ossimFilename.h>
#include <ossim/base/ossimIrect.h>
#include <ossim/support_data/ossimImageMetaData.h>
#include <vector>

//---
// Forward class declarations.
//---
class ossimEnviHeader;
class ossimKeywordlist;

class OSSIMDLLEXPORT ossimGeneralRasterInfo : public ossimObject
{
public:

   enum ossimFillMode
   {
      NONE,
      ZEROES_TO_MIN,
      ZEROES_TO_NULL_EDGES_ONLY
   };

   enum
   {
      UNKNOWN = -1
   };

   /* @brief default constructor */
   ossimGeneralRasterInfo();
   
   ossimGeneralRasterInfo(const std::vector<ossimFilename>& imageFileList,
                          ossimScalarType      pixelType,
                          ossimInterleaveType  il_type,
                          ossim_int32          numberOfBands,
                          ossim_int32          lines,
                          ossim_int32          samples,
                          ossim_int32          headerSize,
                          ossimFillMode        nullsMode,
                          ossim_int32          pixelsToChop);
   
   ossimGeneralRasterInfo(const ossimKeywordlist& kwl, const char* prefix=0);

   /* @brief copy constructor */
   ossimGeneralRasterInfo( const ossimGeneralRasterInfo& obj );

   const ossimGeneralRasterInfo& operator=( const ossimGeneralRasterInfo& rhs );
   
   virtual ~ossimGeneralRasterInfo ();

   const ossimIrect& imageRect() const;

   const ossimIrect& validImageRect() const;

   const ossimIrect& rawImageRect() const;

   const ossimIpt& subImageOffset() const;

   ossim_int32 headerSize() const;

   ossim_uint32 fillToNullsMode() const;

   void setFillToNullsMode(ossim_uint32 mode);

   inline ossim_int32 numberOfBands() const;
   
   inline ossim_int32 bytesPerPixel() const;
   
   ossim_int32 pixelsToChop() const;
   
   ossimInterleaveType interleaveType() const;

   inline ossim_int32 validLines() const;

   inline ossim_int32 rawLines() const;

   inline ossim_int32 bytesPerRawLine() const;

   inline ossim_int32 bytesPerValidLine() const;

   inline ossim_int32 validSamples() const;

   inline ossim_int32 rawSamples() const;

   inline std::streamoff offsetToFirstValidSample() const;
   
   const std::vector<ossimFilename>& getImageFileList() const;

   void setImageFileList(const std::vector<ossimFilename>& list);

   void setImageFile(const ossimFilename& file);

   void setHeaderSize(ossim_int32 headerSize);
   
   void setInterleaveType(ossimInterleaveType il_type);

   virtual std::ostream& print(std::ostream& out) const;

   void setImageRect(const ossimIrect& imageRect);
   
   void setValidImageRect(const ossimIrect &imageRect);

   void setRawImageRect(const ossimIrect &imageRect);

   void setSubImageOffset(const ossimIpt& d);

   ossimByteOrder getImageDataByteOrder() const;

   void setImageDataByteOrder(ossimByteOrder byteOrder);
   virtual bool saveState(ossimKeywordlist& kwl,
                          const char* prefix=0) const;

   virtual bool loadState(const ossimKeywordlist& kwl,
                          const char* prefix=0);

   bool open( const ossimFilename& imageFile );

   inline const ossimImageMetaData& getImageMetaData() const;

   inline ossimImageMetaData& getImageMetaData();

   bool initializeFromEnviHdr( const ossimEnviHeader& enviHdr );

private:

   bool initializeFromHdr( const ossimFilename& imageFile,
                           const ossimFilename& headerFile );

   bool initializeFromEnviHdr( const ossimFilename& headerFile );

   bool initializeFromXml( const ossimFilename& imageFile,
                           const ossimFilename& headerFile );

   ossim_int32 getBitsPerPixel( const ossimFilename& imageFile ) const;

   void clear();
   
   ossimImageMetaData          theMetaData;
   std::vector<ossimFilename>  theImageFileList;
   ossimInterleaveType         theInterleaveType;

   ossimIrect theRawImageRect;

   ossimIrect theValidImageRect;

   ossimIrect theImageRect;

   ossimIpt theSubImageOffset;

   ossim_int32 theHeaderSize;

   ossimFillMode theSetNullsMode;

   ossim_int32 thePixelsToChop;

  ossimByteOrder theImageDataByteOrder;
};


//---
// Inlines:
// 
// These methods are used throughout raster read/write code; hence, inlines.
// Note that most of these are used in calculating std::streamoff which is
// a signed 64 bit integer on most machines; hence, the cast to an int from
// an unsigned int for convenience.
//---
inline const ossimImageMetaData& ossimGeneralRasterInfo::getImageMetaData() const
{
   return theMetaData;
}

inline ossimImageMetaData& ossimGeneralRasterInfo::getImageMetaData()
{
   return theMetaData;
}

inline ossim_int32 ossimGeneralRasterInfo::numberOfBands() const
{
   return static_cast<ossim_int32>( theMetaData.getNumberOfBands() );
}

inline ossim_int32 ossimGeneralRasterInfo::bytesPerPixel() const
{
   return static_cast<ossim_int32>( theMetaData.getBytesPerPixel() );
}

inline ossim_int32 ossimGeneralRasterInfo::validLines() const
{
   return static_cast<ossim_int32>(theValidImageRect.height());
}

inline ossim_int32 ossimGeneralRasterInfo::rawLines() const
{
   return static_cast<ossim_int32>(theRawImageRect.height());
}

inline ossim_int32 ossimGeneralRasterInfo::bytesPerRawLine() const
{
   if (interleaveType() == OSSIM_BIP)
   {
      return rawSamples() * bytesPerPixel() * numberOfBands();
   }
   else
   {
      return rawSamples() * bytesPerPixel();
   }
}

inline ossim_int32 ossimGeneralRasterInfo::bytesPerValidLine() const
{
   if (interleaveType() == OSSIM_BIP)
   {
      return validSamples() * bytesPerPixel() * numberOfBands();
   }
   else
   {
      return validSamples() * bytesPerPixel();
   }
}

inline ossim_int32 ossimGeneralRasterInfo::validSamples() const
{
   return static_cast<ossim_int32>(theValidImageRect.width());
}

inline ossim_int32 ossimGeneralRasterInfo::rawSamples() const
{
   return static_cast<ossim_int32>(theRawImageRect.width());
}

inline std::streamoff ossimGeneralRasterInfo::offsetToFirstValidSample() const
{
   if (interleaveType() == OSSIM_BIP)
   {
      return headerSize() +
         ( bytesPerRawLine() * validImageRect().ul().y ) +
         ( validImageRect().ul().x * numberOfBands() * bytesPerPixel() );
   }
   else if (interleaveType() == OSSIM_BIL)
   {
      return headerSize() +
         ( bytesPerRawLine() * validImageRect().ul().y * numberOfBands() ) +
         ( validImageRect().ul().x * bytesPerPixel() );
   }
   else // BSQ
   {
      return headerSize() +
         ( bytesPerRawLine() * validImageRect().ul().y ) +
         ( validImageRect().ul().x * bytesPerPixel() );
   }
}

#endif