FileFormatInstance.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/FileFormatInstance.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 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 ) )
   {
   }
 
   ~FileFormatInstance() override
   {
   }
 
   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 2024-06-18T15:48:54Z