ImageFactory.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: ImageFactory
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Dictionary.h>
#include <NDEVR/String.h>
#include <NDEVR/LABColor.h>
#include <NDEVR/File.h>
#include <NDEVR/RWLock.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Pointer.h>
namespace NDEVR
{
    class RLock;
    class FileFormat;
    struct ImageMetaData
    {
        Vertex<3, fltp08> lat_lon_location = Constant<Vector<3, fltp08>>::Invalid; 
        Vector<3, Angle<fltp08>> orientation = Constant<Vector<3, Angle<fltp08>>>::Invalid; 
        Time creation_time = Constant<Time>::Invalid; 
        bool has_been_read = false; 
    };

    struct NDEVR_DESIGN_API ImageCacheData
    {
        ImageCacheData()
            : modified_time(Time::SystemTime())
        {}
 
        //void readFromFile(StringView format_extension = StringView());
        ImageCacheData& operator=(const ImageCacheData& data);
    public:
        RWLock lock; 
        ImageMetaData metadata; 
        File file; 
        Buffer<uint01> decompressed_data; 
        Buffer<uint01> compressed_data; 
        String compression_format; 
        String name; 
        Vector<2, uint04> size = Constant<Vector<2, uint04>>::Invalid; 
        Time modified_time = Constant<Time>::Invalid; 
        bool has_transparency = true; 
        bool has_calculated_transparency = false; 
    };

    struct ImageReadPointer : public ConstPointer<ImageCacheData>
    {
        ImageReadPointer()
            : lock(nullptr)
        {}

        ImageReadPointer(const DynamicPointer<ImageCacheData>& d)
            : ConstPointer<ImageCacheData>(d)
            , lock(d->lock)
        {}
    private:
        RLock lock; 
    };

    struct ImageWritePointer : public DynamicPointer<ImageCacheData>
    {
        ImageWritePointer()
            : lock(nullptr)
        {}

        ImageWritePointer(const DynamicPointer<ImageCacheData>& d)
            : DynamicPointer<ImageCacheData>(d)
            , lock(d->lock)
        {}
    private:
        WLock lock; 
    };

    class ImageFormatHandler
    {
    public:
        virtual UUID id() const = 0;
        virtual void getSupportedFormats(AlocatingAlignedBuffer<FileFormat, 64>& formats, bool is_read) const = 0;
        virtual bool canRead(StringView format) const = 0;
        virtual bool canRead(const File& file) const = 0;
        virtual bool canWrite(StringView format) const = 0;
        virtual bool getMetaData(ImageCacheData&) { return false; };
        virtual bool getUncompressed(ImageCacheData&) { return false; };
        virtual bool getCompressed(ImageCacheData&, StringView) { return false; };
        virtual bool hasTransparency(ImageCacheData&) { return false; };
        virtual bool getSize(ImageCacheData&) { return false; };
        virtual StringView compressionFormat(const uint01*, uint04) { return StringView(); };
    };

    class NDEVR_DESIGN_API ImageFactory
    {
    public:
        void addImageFile(const StringView& id, const File& file, bool clear_other);
        void addImageUncompressed(const StringView& id, const Buffer<uint01>& uncompressed, bool clear_other);
        void addImageUncompressed(const StringView& id, const Buffer<uint01>& uncompressed, const Vector<2, uint04>& size, bool clear_other);
        void addImageCompressed(const StringView& id, const StringView& extension, const Buffer<uint01>& compressed, bool clear_other);
        void addImageCompressed(const StringView& id, const StringView& extension, const Buffer<uint01>& compressed, const Vector<2, uint04>& size, bool clear_other);
        void addImageCompressed(const StringView& id, const Buffer<uint01>& compressed, bool clear_other);
        void clearAllImageData(const StringView& id);

        void writeToFile(const StringView& id, const File& file);
        void convertDirectory(const File& directory, const StringView& from_ext, const StringView& to_ext);
        void copyImage(const StringView& id_destination, const StringView& id_source);
        void convertColorTheme(const Buffer<std::pair<LABColor, LABColor>>& color, String& image, bool preserve_brightness, bool preserve_alpha);
        Time modifiedTime(const StringView& id) const;
        bool hasImage(const StringView& id) const;
        ImageReadPointer getMetaData(const StringView& id);
        ImageReadPointer getUncompressed(const StringView& id, bool ensure_valid_transparancy = false);
        ImageReadPointer getCompressed(const StringView& id, StringView default_extension = ".png");
        ImageReadPointer getCompressedInFormat(const StringView& id, const StringView& extension);
        ImageReadPointer getCompressedInFormat(const StringView& id, const Buffer<StringView>& acceptable_formats);
        String optimizedWriteFileName(const StringView& id, const Buffer<String>& optional_extensions = Buffer<String>());
        static FileFormat PNGFormat();
        ImageReadPointer getSize(const StringView& id);
        StringView compressionFormat(const StringView& id);
        bool canRead(const File& file);
        void setWriteQuality(fltp08 quality);
        virtual void getSupportedFormats(AlocatingAlignedBuffer<FileFormat, 64>& formats, bool is_read) const;
        ImageWritePointer getEditableData(const StringView& id);
        ImageReadPointer getReadOnlyData(const StringView& id) const;
        Dictionary<String, DynamicPointer<ImageCacheData>> cachedData() const;
        void addFormatHandler(ImageFormatHandler* handler);
        void removeFormatHandler(const UUID& handler);

        bool readFromFile(ImageCacheData& data, StringView format_extension = StringView());
        void readFromBMP(ImageCacheData& data);
        bool readFromCompressed(ImageCacheData& data);
        bool hasTransparency(ImageCacheData& data);
        void handleMetaData(ImageCacheData& data);
        bool determineCompressionFormat(ImageCacheData& data);
        const Buffer<uint01>& calculateAndGetDecompressed(ImageCacheData& data);
    public:
        static ImageFactory& DefaultFactory();
        static void Resize(const Buffer<uint01>& input, const Vector<2, uint04>& in_size, const Vector<2, uint04>& out_size, Buffer<uint01>& output);
        static void WriteToFile(const uint01* data, Vector<2, uint04> size, uint04 px_size, const File& file, fltp08 write_quality = 1.0);
        static void ReadJPG(const uint01* input, uint04 input_length, uint01* buffer, bool has_alpha, uint04 dst_line_span, const Vector<2, uint04>& offset);
        static void AddFormatHandler(ImageFormatHandler* handler);
        static void RemoveFormatHandler(const UUID& handler);
    protected:
        Dictionary<String, DynamicPointer<ImageCacheData>> m_cached_data; 
        Dictionary<UUID, ImageFormatHandler*> m_format_handlers; 
        fltp08 m_write_quality = 1.0; 
        mutable RWLock m_lock; 
    protected:
        static Dictionary<UUID, ImageFormatHandler*> s_format_handlers; 
    };

    class NDEVR_DESIGN_API ImageData
    {
    public:
        ImageData(const StringView& id, ImageFactory& image_factory);
        ImageData(const ImageData& data);
        ImageData(ImageData&& data) noexcept;
        ~ImageData();
        [[nodiscard]] ImageReadPointer getUncompressed() const;
        [[nodiscard]] ImageReadPointer getCompressed(const String& default_image_format) const;
        [[nodiscard]] ImageReadPointer size() const;
        [[nodiscard]] Time modifiedTime() const;
        [[nodiscard]] StringView compressionFormat() const;
    protected:
        ImageFactory& m_image_factory; 
        const String m_id; 
    };
}