ossimNBandLutDataObject.h

Go to the documentation of this file.

//*******************************************************************
// Copyright (C) 2005 Garrett Potts
//
// LICENSE: MIT See top level license file.
// 
// Author: Garrett Potts
//
//*************************************************************************
// $Id: ossimNBandLutDataObject.h 19732 2011-06-06 22:24:54Z dburken $
#ifndef ossimNBandLutDataObject_HEADER
#define ossimNBandLutDataObject_HEADER 1

#include <ossim/base/ossimObject.h>
#include <ossim/base/ossimFilename.h>
#include <iostream>
#include <map>

class OSSIM_DLL ossimNBandLutDataObject : public ossimObject
{
public:
   
   typedef ossim_int32 LUT_ENTRY_TYPE;
   
   friend std::ostream& operator <<(std::ostream& out,
                                    const ossimNBandLutDataObject& lut);
   ossimNBandLutDataObject(ossim_uint32 numberOfEntries=0,
                           ossim_uint32 numberOfBands=0,
                           ossimScalarType bandScalarType = OSSIM_UINT8,
                           ossim_int32 nullPixelIndex=-1);
   ossimNBandLutDataObject(const ossimNBandLutDataObject& lut);
   ossimObject* dup()const
   {
      return new ossimNBandLutDataObject(*this);
   }
   void create(ossim_uint32 numberOfEntries,
               ossim_uint32 numberOfBands=3);
   const LUT_ENTRY_TYPE* operator[](ossim_uint32 idx)const
   {
      if(theLut)
      {
         return &theLut[idx*theNumberOfBands];
      }
      
      return 0;
   }
   LUT_ENTRY_TYPE* operator[](ossim_uint32 idx)
   {
      if(theLut)
      {
         return &theLut[idx*theNumberOfBands];
      }
      
      return 0;
   }
   const LUT_ENTRY_TYPE* operator[](ossim_int32 idx)const
   {
      if(theLut)
      {
         return &theLut[idx*theNumberOfBands];
      }
      
      return 0;
   }
   LUT_ENTRY_TYPE* operator[](ossim_int32 idx)
   {
      if(theLut)
      {
         return &theLut[idx*theNumberOfBands];
      }
      
      return 0;
   }
   const LUT_ENTRY_TYPE* operator[](double normalizedIndex)const
   {
      int idx = int(normalizedIndex*theNumberOfEntries);
      if (idx < 0)
      {
         idx = 0;
      }
      return (*this)[idx];
   }

   LUT_ENTRY_TYPE* operator[](double normalizedIndex)
   {
      ossim_uint32 idx = int(normalizedIndex*(theNumberOfEntries-1));
      if (idx >= theNumberOfEntries)
      {
         idx = theNumberOfEntries-1;
      }
      return (*this)[idx];
   }
   
   bool hasNullPixelIndex()const
   {
      return (theNullPixelIndex >= 0);
   }
   void getMinMax(ossim_uint32 band,
                  LUT_ENTRY_TYPE& minValue,
                  LUT_ENTRY_TYPE& maxValue);

   ossim_int32 getFirstNullAlphaIndex() const;
   
   void setNullPixelIndex(ossim_int32 idx){theNullPixelIndex = idx;}

   ossim_int32 getNullPixelIndex()const{return theNullPixelIndex;}

   ossim_uint32 getNumberOfBands()const{return theNumberOfBands;}

   ossim_uint32 getNumberOfEntries()const{return theNumberOfEntries;}

   ossim_uint32 findIndex(ossim_int32* values) const;

   ossim_uint32 findIndex(ossim_int32* values, ossim_uint32 size) const;

   void clearLut();
   const ossimNBandLutDataObject& operator =(const ossimNBandLutDataObject& lut);

   bool operator ==(const ossimNBandLutDataObject& lut)const;

   bool open(const ossimFilename& lutFile);

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

   std::vector<ossimString> getEntryLabels(ossim_uint32 band);

   void setEntryLables(ossim_uint32 band, std::vector<ossimString> entryLabels);

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

   LUT_ENTRY_TYPE *theLut;
   ossim_uint32    theNumberOfEntries;
   ossim_uint32    theNumberOfBands;
   ossimScalarType theBandScalarType;
   ossim_int32     theNullPixelIndex;
   std::map<ossim_uint32, std::vector<ossimString> >  m_entryLabels;
   
TYPE_DATA
};

#endif