FileFormatInstance.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.4.7
// ----------------------------------------------------------------------------
// pcl/FileFormatInstance.h - Released 2020-12-17T15:46:28Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2020 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------

#ifndef __PCL_FileFormatInstance_h
#define __PCL_FileFormatInstance_h


#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION

#include <pcl/Defs.h>

#include <pcl/FITSHeaderKeyword.h>
#include <pcl/ImageDescription.h>
#include <pcl/ImageVariant.h>
#include <pcl/Property.h>
#include <pcl/UIObject.h>

namespace pcl
{

// ----------------------------------------------------------------------------

class PCL_CLASS ColorFilterArray;
class PCL_CLASS DisplayFunction;
class PCL_CLASS FileFormat;
class PCL_CLASS ICCProfile;

class PCL_CLASS FileFormatInstance : public UIObject
{
public:

   FileFormatInstance( const FileFormat& fmt );

   FileFormatInstance( FileFormatInstance&& x )
      : UIObject( std::move( x ) )
   {
   }

   virtual ~FileFormatInstance()
   {
   }

   FileFormatInstance& operator =( FileFormatInstance&& x )
   {
      Transfer( x );
      return *this;
   }

   void EnsureUnique() override
   {
   }

   static FileFormatInstance& Null();

   FileFormat Format() const;

   bool Close();

   bool IsOpen() const;

   String FilePath() const;

   // Reader functionality

   bool Open( ImageDescriptionArray& images,
              const String& filePath, const IsoString& hints = IsoString() );

   bool Open( ImageDescriptionArray& images, const String& filePath, const IsoString::ustring_base& hints )
   {
      return Open( images, filePath, IsoString( hints ) );
   }

   bool SelectImage( int index );

   int SelectedImageIndex() const;

   const void* FormatSpecificData() const;

   String ImageFormatInfo() const;

   bool ReadICCProfile( ICCProfile& icc );

   bool ReadRGBWorkingSpace( RGBColorSystem& rgbws );

   bool ReadDisplayFunction( DisplayFunction& df );

   bool ReadColorFilterArray( ColorFilterArray& cfa );

   bool ReadThumbnail( UInt8Image& thumbnail );

   bool ReadFITSKeywords( FITSKeywordArray& keywords );

   PropertyDescriptionArray PropertyDescriptions();

   bool HasProperty( const IsoString& property )
   {
      return PropertyDescriptions().Contains( property );
   }

   bool HasProperty( const IsoString::ustring_base& property )
   {
      return HasProperty( IsoString( property ) );
   }

   pcl::PropertyDescription PropertyDescription( const IsoString& property )
   {
      PropertyDescriptionArray properties = PropertyDescriptions();
      PropertyDescriptionArray::const_iterator i = properties.Search( property );
      if ( i == properties.End() )
         return pcl::PropertyDescription();
      return *i;
   }

   pcl::PropertyDescription PropertyDescription( const IsoString::ustring_base& property )
   {
      return PropertyDescription( IsoString( property ) );
   }

   Variant ReadProperty( const IsoString& property );

   Variant ReadProperty( const IsoString::ustring_base& property )
   {
      return ReadProperty( IsoString( property ) );
   }

   PropertyArray ReadProperties();

   PropertyDescriptionArray ImagePropertyDescriptions();

   bool HasImageProperty( const IsoString& property )
   {
      return ImagePropertyDescriptions().Contains( property );
   }

   bool HasImageProperty( const IsoString::ustring_base& property )
   {
      return HasImageProperty( IsoString( property ) );
   }

   pcl::PropertyDescription ImagePropertyDescription( const IsoString& property )
   {
      PropertyDescriptionArray properties = ImagePropertyDescriptions();
      PropertyDescriptionArray::const_iterator i = properties.Search( property );
      if ( i == properties.End() )
         return pcl::PropertyDescription();
      return *i;
   }

   pcl::PropertyDescription ImagePropertyDescription( const IsoString::ustring_base& property )
   {
      return ImagePropertyDescription( IsoString( property ) );
   }

   Variant ReadImageProperty( const IsoString& property );

   Variant ReadImageProperty( const IsoString::ustring_base& property )
   {
      return ReadImageProperty( IsoString( property ) );
   }

   PropertyArray ReadImageProperties();

   bool ReadImage( FImage& image );

   bool ReadImage( DImage& image );

   bool ReadImage( UInt8Image& image );

   bool ReadImage( UInt16Image& image );

   bool ReadImage( UInt32Image& image );

   bool ReadImage( ImageVariant& image )
   {
      if ( image )
         if ( !image.IsComplexSample() )
            if ( image.IsFloatSample() )
               switch ( image.BitsPerSample() )
               {
               case 32: return ReadImage( static_cast<pcl::Image&>( *image ) );
               case 64: return ReadImage( static_cast<pcl::DImage&>( *image ) );
               }
            else
               switch ( image.BitsPerSample() )
               {
               case  8: return ReadImage( static_cast<pcl::UInt8Image&>( *image ) );
               case 16: return ReadImage( static_cast<pcl::UInt16Image&>( *image ) );
               case 32: return ReadImage( static_cast<pcl::UInt32Image&>( *image ) );
               }
      return false;
   }

   bool CanReadIncrementally() const;

   bool ReadSamples( FImage::sample* buffer, int startRow, int rowCount, int channel );

   bool ReadSamples( DImage::sample* buffer, int startRow, int rowCount, int channel );

   bool ReadSamples( UInt8Image::sample* buffer, int startRow, int rowCount, int channel );

   bool ReadSamples( UInt16Image::sample* buffer, int startRow, int rowCount, int channel );

   bool ReadSamples( UInt32Image::sample* buffer, int startRow, int rowCount, int channel );

   bool WasInexactRead() const;

   // Writer functionality

   bool QueryOptions( Array<ImageOptions>& options, Array<const void*>& formatOptions );

   bool Create( const String& filePath, const IsoString& hints = IsoString(), int numberOfImages = 1 );

   bool Create( const String& filePath, const IsoString::ustring_base& hints, int numberOfImages = 1 )
   {
      return Create( filePath, IsoString( hints ), numberOfImages );
   }

   bool SetId( const IsoString& id );

   bool SetId( const IsoString::ustring_base& id )
   {
      return SetId( IsoString( id ) );
   }

   bool SetOptions( const ImageOptions& options );

   bool SetFormatSpecificData( const void* data );

   bool WriteICCProfile( const ICCProfile& icc );

   bool WriteRGBWorkingSpace( const RGBColorSystem& rgbws );

   bool WriteDisplayFunction( const DisplayFunction& df );

   bool WriteColorFilterArray( const ColorFilterArray& cfa );

   bool WriteThumbnail( const UInt8Image& image );

   bool WriteProperty( const IsoString& property, const Variant& value );

   bool WriteProperty( const IsoString::ustring_base& property, const Variant& value )
   {
      return WriteProperty( IsoString( property ), value );
   }

   bool WriteProperty( const Property& property )
   {
      return WriteProperty( property.Id(), property.Value() );
   }

   bool WriteProperties( const PropertyArray& properties );

   bool WriteImageProperty( const IsoString& property, const Variant& value );

   bool WriteImageProperty( const IsoString::ustring_base& property, const Variant& value )
   {
      return WriteImageProperty( IsoString( property ), value );
   }

   bool WriteImageProperty( const Property& property )
   {
      return WriteImageProperty( property.Id(), property.Value() );
   }

   bool WriteImageProperties( const PropertyArray& properties );

   bool WriteFITSKeywords( const FITSKeywordArray& keywords );

   bool WriteImage( const FImage& image );

   bool WriteImage( const DImage& image );

   bool WriteImage( const UInt8Image& image );

   bool WriteImage( const UInt16Image& image );

   bool WriteImage( const UInt32Image& image );

   bool WriteImage( const ImageVariant& image )
   {
      if ( image )
         if ( !image.IsComplexSample() )
            if ( image.IsFloatSample() )
               switch ( image.BitsPerSample() )
               {
               case 32: return WriteImage( static_cast<const pcl::Image&>( *image ) );
               case 64: return WriteImage( static_cast<const pcl::DImage&>( *image ) );
               }
            else
               switch ( image.BitsPerSample() )
               {
               case  8: return WriteImage( static_cast<const pcl::UInt8Image&>( *image ) );
               case 16: return WriteImage( static_cast<const pcl::UInt16Image&>( *image ) );
               case 32: return WriteImage( static_cast<const pcl::UInt32Image&>( *image ) );
               }
      return false;
   }

   bool CanWriteIncrementally() const;

   bool CreateImage( const ImageInfo& info );

   bool CloseImage();

   bool WriteSamples( const FImage::sample* buffer, int startRow, int rowCount, int channel );

   bool WriteSamples( const DImage::sample* buffer, int startRow, int rowCount, int channel );

   bool WriteSamples( const UInt8Image::sample* buffer, int startRow, int rowCount, int channel );

   bool WriteSamples( const UInt16Image::sample* buffer, int startRow, int rowCount, int channel );

   bool WriteSamples( const UInt32Image::sample* buffer, int startRow, int rowCount, int channel );

   bool WasLossyWrite() const;

private:

   FileFormatInstance( void* h ) : UIObject( h )
   {
   }

   void* CloneHandle() const override;

   friend class FileFormatInstancePrivate;
};

// ----------------------------------------------------------------------------

} // pcl

#endif   // __PCL_BUILDING_PIXINSIGHT_APPLICATION

#endif   // __PCL_FileFormatInstance_h

// ----------------------------------------------------------------------------
// EOF pcl/FileFormatInstance.h - Released 2020-12-17T15:46:28Z