image.h

 
#ifndef _aspose_system_drawing_image_h_
#define _aspose_system_drawing_image_h_
 
#include "system/object.h"
#include "system/nullable.h"
#include "system/idisposable.h"
#include "system/details/array_view.h"
#include "drawing/imaging/image_attributes.h"
#include "drawing/imaging/image_format.h"
#include "drawing/imaging/image_codec_info.h"
#include "drawing/imaging/encoder_parameters.h"
#include "drawing/imaging/encoder_value.h"
#include "drawing/imaging/pixel_format.h"
#include "drawing/imaging/color_palette.h"
#include "drawing/imaging/frame_dimension.h"
#include "drawing/rotate_flip_type.h"
#include "drawing/graphics_unit.h"
#include "drawing/size.h"
#include "drawing/rectangle_f.h"
#include "system/io/stream.h"
#include "system/string.h"
#include "imaging/image_flags.h"
#include "imaging/property_item.h"
 
// skia headers and forwards
#if defined(ASPOSECPPLIB_BEING_BUILT) || defined(ASPOSECPP_SKIA_EXTERNAL_USAGE)
#include <core/SkImage.h>
#include <core/SkData.h>
#include <core/SkEncodedImageFormat.h>
#include <encode/SkTIFFImageEncoder.h>
#endif
 
#define ASPOSE_DUMMY_META_FILE
 
ASPOSECPP_3RD_PARTY_CLASS(SkBitmap);
ASPOSECPP_3RD_PARTY_CLASS(SkCanvas);
ASPOSECPP_3RD_PARTY_CLASS(SkData);
ASPOSECPP_3RD_PARTY_CLASS(SkMatrix);
ASPOSECPP_3RD_PARTY_CLASS(SkTIFFImageEncoder)
ASPOSECPP_3RD_PARTY_CLASS(SkRWStream);
// Forward declaration of SkImageInfo struct.
ASPOSECPP_3RD_PARTY_STRUCT(SkImageInfo);
// Forward declaration of SkRect struct.
ASPOSECPP_3RD_PARTY_STRUCT(SkRect);
 
#if defined(ASPOSECPPLIB_BEING_BUILT) || !defined(ASPOSECPP_SKIA_EXTERNAL_USAGE)
ASPOSECPP_3RD_PARTY_ENUM_CLASS(SkEncodedImageFormat);
ASPOSECPP_3RD_PARTY_ENUM(SkFilterQuality);
ASPOSECPP_3RD_PARTY_ENUM_CLASS(SkBlendMode);
#endif
 
template <typename T> class sk_sp;
 
namespace System { namespace Drawing {
 
    class Bitmap;
    class TextureBrush;
    class ASPOSECPP_SHARED_CLASS Image: virtual public System::IDisposable
    {
        RTTI_INFO(System::Drawing::Image, ::System::BaseTypesInfo<System::IDisposable>)
 
    public:
        ASPOSECPP_SHARED_API void Save(const String & filename);
        ASPOSECPP_SHARED_API void Save(const String & filename, const Imaging::ImageFormatPtr& format);
        ASPOSECPP_SHARED_API void Save(const SharedPtr<System::IO::Stream>& stream, const Imaging::ImageFormatPtr& format);
        ASPOSECPP_SHARED_API void Save(const String & filename, const Imaging::ImageCodecInfoPtr& encoder, const Imaging::EncoderParametersPtr& encoder_params);
        ASPOSECPP_SHARED_API void Save(const SharedPtr<System::IO::Stream>& stream, const Imaging::ImageCodecInfoPtr& encoder, const Imaging::EncoderParametersPtr& encoder_params);
        ASPOSECPP_SHARED_API void SaveAdd(const Imaging::EncoderParametersPtr& encoder_params);
        ASPOSECPP_SHARED_API void SaveAdd(const SharedPtr<Image>& image, const Imaging::EncoderParametersPtr& encoder_params);
 
        virtual ASPOSECPP_SHARED_API SharedPtr<Image> Clone() = 0;
 
        virtual ASPOSECPP_SHARED_API void RotateFlip(RotateFlipType rotate_flip_type);
 
        virtual ASPOSECPP_SHARED_API ArrayPtr<int> get_PropertyIdList() const;
 
        ASPOSECPP_SHARED_API RectangleF GetBounds(GraphicsUnit & page_unit);
 
        virtual ASPOSECPP_SHARED_API int get_Width() const = 0;
        virtual ASPOSECPP_SHARED_API int get_Height() const = 0;
        virtual int32_t get_Flags() const;
        ASPOSECPP_SHARED_API Size get_Size() const;
 
        virtual ASPOSECPP_SHARED_API Imaging::ImageFormatPtr get_RawFormat() const = 0;
        virtual ASPOSECPP_SHARED_API Imaging::PixelFormat get_PixelFormat() const = 0;
        
        virtual ASPOSECPP_SHARED_API System::SharedPtr<System::Object> get_Tag() const;
        virtual ASPOSECPP_SHARED_API void set_Tag(const System::SharedPtr<System::Object> tag);
 
        ASPOSECPP_SHARED_API float get_HorizontalResolution() const;
        ASPOSECPP_SHARED_API float get_VerticalResolution() const;
 
        virtual ASPOSECPP_SHARED_API Imaging::ColorPalettePtr get_Palette() const;
        virtual ASPOSECPP_SHARED_API void set_Palette(Imaging::ColorPalettePtr value);
 
        virtual ASPOSECPP_SHARED_API bool IsMultiImage() const;
 
        ASPOSECPP_SHARED_API ArrayPtr<Guid> get_FrameDimensionsList() const;
 
        ASPOSECPP_SHARED_API int GetFrameCount(const Imaging::FrameDimensionPtr& dimension);
        ASPOSECPP_SHARED_API int SelectActiveFrame(const Imaging::FrameDimensionPtr& dimension, int frameIndex);
 
        virtual ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<Imaging::PropertyItem>> get_PropertyItems() const;
 
        static ASPOSECPP_SHARED_API SharedPtr<Image> FromStream(const SharedPtr<System::IO::Stream>& stream, bool use_embedded_color_management = false, bool validate_image_data = true);
        static ASPOSECPP_SHARED_API SharedPtr<Image> FromFile(const String & filename, bool use_embedded_color_management = false);
 
        static ASPOSECPP_SHARED_API bool IsAlphaPixelFormat(Imaging::PixelFormat pixfmt);
        static ASPOSECPP_SHARED_API int GetPixelFormatSize(Imaging::PixelFormat pixfmt);
        static ASPOSECPP_SHARED_API SharedPtr<Bitmap> FromHbitmap(IntPtr hbitmap);
        void Dispose() override { };
 
        virtual ASPOSECPP_SHARED_API const SkBitmap* GetSkBitmap() const = 0;
 
        using GetThumbnailImageAbort = System::MulticastDelegate<bool()>;
 
        ASPOSECPP_SHARED_API SharedPtr<Image> GetThumbnailImage(int thumbWidth, int thumbHeight, Image::GetThumbnailImageAbort callback, IntPtr callbackData);
 
    protected:
        static const int s_default_save_quality = 80;
        
        friend class Graphics;
        friend class TextureBrush;
        friend class Bitmap;
 
        struct SaveOptions
        {
            Nullable<int> Quality;
            Nullable<Imaging::EncoderValue> Flag;
            Nullable<Imaging::EncoderValue> Compression;
            Nullable<int> PixelFormat;
        };
 
        static SkBitmap ConvertToGrayscale(const SkBitmap& src_bitmap);
 
        static SaveOptions ParseEncoderParameters(const Imaging::EncoderParametersPtr& encoder_params);
 
        virtual ASPOSECPP_SHARED_API std::unique_ptr<SkCanvas> GetDrawingCanvas() const = 0;
        virtual ASPOSECPP_SHARED_API sk_sp<SkData> GetRawBytes(SkEncodedImageFormat encoder_type, int quality) = 0;
 
        ASPOSECPP_SHARED_API void InternalSave(const SharedPtr<System::IO::Stream>& stream, SkEncodedImageFormat encoder_type,
                                                Imaging::EncoderValue encoder_value = Imaging::EncoderValue::CompressionLZW,
                                                int pixel_format = 32, int quality = s_default_save_quality);
 
        void InternalSave(const SharedPtr<IO::Stream>& stream, SkEncodedImageFormat encoder_type, const SaveOptions& options);
 
        void InternalSavePage(const SkBitmap* bitmap, const SaveOptions& options);
 
        ASPOSECPP_SHARED_API SkEncodedImageFormat CheckOutputFormat(const Imaging::ImageFormatPtr& image_format) const;
        static ASPOSECPP_SHARED_API SkEncodedImageFormat CheckOutputFormat(const Imaging::ImageCodecInfoPtr& encoder);
        static ASPOSECPP_SHARED_API SkEncodedImageFormat CheckOutputFormat(SkEncodedImageFormat encoded_format);
 
        virtual ASPOSECPP_SHARED_API const SkEncodedImageFormat GetSkEncodedFormat() const = 0;
        virtual ASPOSECPP_SHARED_API Imaging::PixelFormat GetOriginalFormat() const = 0;
 
        virtual void Draw(SkCanvas* sk_canvas, const SkRect& dest_rect, const SkRect&src_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const = 0;
        virtual void Draw(SkCanvas* sk_canvas, const SkRect& dest_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const = 0;
        virtual void Draw(SkCanvas* sk_canvas, ArrayPtr<PointF> dest_points, const SkRect& src_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const = 0;
        virtual void Draw(SkCanvas* sk_canvas, const System::Details::ArrayView<PointF>& dest_points, const SkRect& src_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const = 0;
 
        static ASPOSECPP_SHARED_API bool IsWmf(const System::SharedPtr<System::IO::Stream>& stream);
 
        static ASPOSECPP_SHARED_API bool IsEmf(const System::SharedPtr<System::IO::Stream>& stream);
 
        Imaging::ColorPalettePtr m_palette;
        float m_horizontal_resolution = 96.f; //only default 96dpi is supported
        float m_vertical_resolution = 96.f; //only default 96dpi is supported
        
    private:
        std::unique_ptr<SkRWStream> m_stream;
        std::unique_ptr<SkTIFFImageEncoder> m_tiff_encoder;
 
        System::SharedPtr<System::Object> m_tag = nullptr;
        Imaging::ImageFlags m_flags = Imaging::ImageFlags::None;
 
        static const int16_t s_tiff_tag_compression = 0x103;
        int16_t GetTiffCompression(const ArrayPtr<uint8_t>& stream);
        Nullable<int16_t> m_tiff_compression;
 
        sk_sp<SkData> GetTiffRawBytes(Imaging::EncoderValue encoder_value, int pixel_format);
 
        Imaging::PixelFormat GetTiffPixelFormat(const ArrayPtr<uint8_t>& stream);
    };
}}
 
 
#endif