ossimH5Util.h

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: OSSIM HDF5 utility class.
//
//----------------------------------------------------------------------------
// $Id

#ifndef ossimH5Util_HEADER
#define ossimH5Util_HEADER 1

#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimRefPtr.h>
#include <ossim/projection/ossimProjection.h>

#include <iosfwd>
#include <string>
#include <vector>

// Forward class declarations:
class ossimIrect;
namespace H5
{
   class AbstractDs;
   class Attribute;
   class DataSet;
   class H5File;
   class CompType;
   class DataSpace;
   class DataSet;
   class DataType;
   class EnumType;
   class FloatType;
   class IntType;
   class StrType;
   class ArrayType;
}

// Anonymous enums:
enum 
{
   OSSIM_H5_MAX_RECURSION_LEVEL = 8
};

namespace ossim_hdf5
{
   // Anonymous enums:
   enum 
   {
      //---
      // Used by iterateGroupForDatasetNames which can recursively call itself
      // to avoid blowing away the stack on an error.
      //---
      MAX_RECURSION_LEVEL = 8
   };

   std::ostream& print( H5::H5File* file,
                        std::ostream& out );   

   void printIterative( H5::H5File* file,
                        const std::string& groupName,
                        const std::string& prefix,
                        ossim_uint32& recursedCount,
                        std::ostream& out );

   void printObject(  H5::H5File* file,
                      const std::string& objectName,
                      const std::string& prefix,
                      std::ostream& out );


   void printEnumType(H5::DataSet& dataset, 
                      H5::EnumType& dataType,
                      const std::string& prefix,
                      std::ostream& out);
   void printIntType(H5::DataSet& dataset, 
                      H5::IntType& dataType,
                      const char* dataPtr,
                      const std::string& prefix,
                      std::ostream& out);
   void printFloatType(H5::DataSet& dataset, 
                      H5::FloatType& dataType,
                      const char* dataPtr,
                      const std::string& prefix,
                      std::ostream& out);
   void printArrayType(H5::DataSet& dataset, 
                      H5::ArrayType& dataType,
                      const char* dataPtr,
                      const std::string& prefix,
                      std::ostream& out);
   void printStrType(H5::DataSet& dataset, 
                      H5::StrType& dataType,
                      const char* dataPtr,
                      const std::string& prefix,
                      std::ostream& out);
   void printCompound(H5::DataSet& dataset, 
                      const std::string& prefix,
                      std::ostream& out);

   bool getGroupAttributeValue( H5::H5File* file,
                                const std::string& group,
                                const std::string& key,
                                std::string& value );
   
   bool getDatasetAttributeValue( H5::H5File* file,
                                const std::string& objectName,
                                const std::string& key,
                                std::string& value );
   
   void printAttribute( const H5::Attribute& attr,
                        const std::string& prefix,
                        std::ostream& out );
   void combine( const std::string& left,
                 const std::string& right,
                 char separator,
                 std::string& result );
   
   void getDatasetNames(H5::H5File* file, std::vector<std::string>& names );

   std::string getDatatypeClassType( ossim_int32 type );

   bool isLoadableAsImage( H5::H5File* file,
                           const std::string& datasetName );

   //bool isExcludedDataset( const std::string& datasetName );

   void iterateGroupForDatasetNames( H5::H5File* file,
                                     const std::string& group,
                                     std::vector<std::string>& names,
                                     ossim_uint32& recursedCount );

   void getExtents( const H5::DataSet* dataset,
                    std::vector<ossim_uint32>& extents );

   // ossimScalarType getScalarType( ossim_int32 typeClass, ossim_int32 id );
   ossimScalarType getScalarType( const H5::DataSet* dataset );

   ossimScalarType getScalarType( ossim_int32 typeClass,
                                  size_t size,
                                  bool isSigned );

   /* GP:
   * I am commenting this one out and we should use the one above.  
   * This gives us negative values for the class type and seems to be busted.
   * if you have the typeclass then you can get the size and sign and it is safer to 
   * use the call above.
   */
   //ossimScalarType getScalarType( ossim_int32 id );
   
   ossimByteOrder getByteOrder( const H5::AbstractDs* dataset );

   ossimByteOrder getByteOrder( const H5::DataType* dataType );


   bool getValidBoundingRect( H5::DataSet& dataset,
                              const std::string& name,
                              ossimIrect& rect );

   ossimRefPtr<ossimProjection> getBilinearProjection(
      H5::DataSet& latDataSet,
      H5::DataSet& lonDataSet,
      const ossimIrect& validRect );

   bool crossesDateline( H5::DataSet& dataset, const ossimIrect& validRect );
   bool crossesDateline( const std::vector<ossim_float32>& lineBuffer);
   
} // End: namespace ossim_hdf5{...}

#endif /* #ifndef ossimH5Util_HEADER */