ImageFactory.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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>
namespace NDEVR
{
    class RLock;
    class FileFormat;
 
    /**--------------------------------------------------------------------------------------------------
    \brief Defines a DataStream for Image reading or writing
    **/
    struct ImageDataStream
    {
        File file;
        String format;
        uint01* compressed_data = nullptr;
        uint04 compressed_length = 0;
        uint01* bitmap_data = nullptr;
        uint04 bitmap_line_span = 0;
        Vector<2, uint04> bitmap_offset = Vector<2, uint04>(0);
        Vector<2, uint04> image_size = Vector<2, uint04>(0);
        fltp08 quality;
        bool has_alpha = false;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Can be used to add functionality to the ImageFactory
    **/
    class ImageFormatHandler
    {
        virtual bool readFromFormat(ImageDataStream& data) = 0;
        virtual bool writeToFormat(ImageDataStream& data) = 0;
        virtual Buffer<String> supportedFormats() const = 0;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief The core class for reading/writing and storing images in an optimized way
    **/
    class NDEVR_DESIGN_API ImageFactory
    {
    public:
        RLock readLock();
        WLock writeLock();
        void addImageFile(const String& image_id, const File& file, bool clear_other);
        void addImageUncompressed(const String& image_id, const Buffer<uint01>& uncompressed, bool clear_other);
        void addImageUncompressed(const String& image_id, const Buffer<uint01>& uncompressed, const Vector<2, uint04>& size, bool clear_other);
        void addImageCompressed(const String& image_id, const String& extension, const Buffer<uint01>& compressed, bool clear_other);
        void addImageCompressed(const String& image_id, const Buffer<uint01>& compressed, bool clear_other);
        void readFromFile(const String& image_id);
        void readFromFile(const String& image_id, String format_extension);
        void writeToFile(const String& image_id, const File& file);
        static void WriteToFile(const uint01* data, Vector<2, uint04> size, uint04 px_size, const File& file, fltp08 write_quality = 1.0);
        void readFromCompressed(const String& image_id);
        Time modifiedTime(const String& image_id) const;
        void convertDirectory(const File& directory, const String& from_ext, const String& to_ext);
        bool hasImage(const String& image_id);
        void copyImage(const String& image_id_destination, const String& image_id_source);
        const Buffer<uint01>& getUncompressed(const String& image_id);
        const Buffer<uint01>& getCompressed(const String& image_id, const String& default_extension = ".png");
        const Buffer<uint01>& getCompressedInFormat(const String& image_id, const String& default_extension);
        const File& getFile(const String& image_id);
        void convertColorTheme(const Buffer<std::pair<LABColor, LABColor>, uint04, ObjectAllocator<true>>& color, String& image, bool preserve_brightness, bool preserve_alpha);
        String optimizedWriteFileName(const String& image_id, const Buffer<String>& optional_extenstions = Buffer<String>());
        bool hasTransparency(const String& image_id);
        const Vector<2, uint04>& getSize(const String& image_id);
        String compressionFormat(const String& image_id);
        static ImageFactory& DefaultFactory();
        bool canRead(const File& file);
        void setWriteQuality(fltp08 quality);
        virtual void getSupportedFormats(Buffer<FileFormat, uint04, ObjectAllocator<false>>& formats) const;
        static void ReadJPG(const uint01* input, uint04 input_length, uint01* buffer, bool has_alpha, uint04 dst_line_span, const Vector<2, uint04>& offset);
        void readFromBMP(const String& image_id);
    protected:
        Dictionary<String, Time> m_image_modified_time;
        Dictionary<String, Vector<2, uint04>> m_image_size;
        Dictionary<String, Buffer<uint01>> m_image_decompressed_data;
        Dictionary<String, Buffer<uint01>> m_image_compressed_data;
        Dictionary<String, String> m_image_compression_format;
        Dictionary<String, File> m_image_files;
        Dictionary<String, bool> m_has_transparency;
        Dictionary<String, ImageFormatHandler*> m_format_handlers;
        fltp08 m_write_quality = 1.0;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A container for Images managed by the ImageFactory. Provides convenience access functions without
        actually allocating memory outside of the factory.
    **/
    class NDEVR_DESIGN_API ImageData
    {
    public:
        ImageData(const String& id, ImageFactory& image_factory);
        ImageData(const ImageData& data);
        ImageData(ImageData&& data) noexcept;
        ~ImageData();
        [[nodiscard]] const File& file() const;
        [[nodiscard]] const Buffer<uint01>& getUncompressed() const;
        [[nodiscard]] const Buffer<uint01>& getCompressed(const String& default_image_format) const;
        [[nodiscard]] const Vector<2, uint04>& size() const;
        [[nodiscard]] Time modifiedTime() const;
        [[nodiscard]] String compressionFormat() const;
    protected:
        ImageFactory& m_image_factory;
        const String m_id;
    };
}