Bitmap.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <memory>
 
#include "../Graphics/Animations.h"
#include "../Graphics/Texture.h"
#include "../Containers/Image.h"
#include "../Geometry/Margin.h"
 
namespace Gorgon { namespace Graphics {
 
 
    class Bitmap : 
        public virtual Graphics::RectangularAnimationProvider, public virtual Graphics::Image,
        public virtual Graphics::RectangularAnimation, protected virtual Graphics::Texture, public virtual Graphics::TextureSource
    {
        friend class BitmapWrapper;
    public:
        
        using AnimationType = Bitmap;
 
        enum AtlasMargin {
            None, 
 
            Zero,
 
            Repeat,
 
            Wrap
        };
        
        enum GrayscaleConversionMethod {
            Luminance,
            Average,
            Maximum,
            Minimum
        };
 
        Bitmap() {
 
        }
 
        explicit Bitmap(const Geometry::Size &size, Graphics::ColorMode mode=Graphics::ColorMode::RGBA) : 
        data(new Containers::Image{size, mode}) {
 
#ifndef NDEBUG
            if(size.Width<0 || size.Height<0) {
                throw std::runtime_error("Size of an image cannot be negative.");
            }
#endif
        }
 
        Bitmap(int width, int height, Graphics::ColorMode mode) : Bitmap({width, height}, mode) { }
 
        Bitmap(const Bitmap &) = delete;
 
        Bitmap(Bitmap &&other) {
            Swap(other);
        }
 
        Bitmap(Containers::Image &&imagedata) : data(new Containers::Image) {
            data->Swap(imagedata);
        }
 
        virtual void Swap(Bitmap &other) {
            using std::swap;
 
            swap(data, other.data);
 
            Graphics::Texture::Swap(other);
        }
        
        //types are derived not to type the same code for every class
        virtual auto MoveOutProvider() -> decltype(*this) override {
            auto ret = new std::remove_reference<decltype(*this)>::type(std::move(*this));
            
            return *ret;
        }
 
        Bitmap &operator=(Bitmap &) = delete;
 
        Bitmap &operator =(Bitmap &&other) {
            Discard();
            Graphics::Texture::Destroy();
 
            Swap(other);
            
            return *this;
        }
 
        Bitmap Duplicate() const {
            Bitmap img;
            if(data)
                img.Assign(*data);
 
            return img;
        }
 
        void Destroy() {
            Texture::Destroy();
            delete data;
            data=nullptr;
        }
 
        virtual ~Bitmap() {
            delete data;
        }
        
        using Graphics::Texture::GetID;
        using Graphics::Texture::GetMode;
        using Graphics::Texture::GetCoordinates;
        using Graphics::Texture::GetImageSize;
 
        Bitmap &CreateAnimation(Gorgon::Animation::ControllerBase &) const override { return const_cast<Bitmap &>(*this); }
 
        Bitmap &CreateAnimation(bool =false) const override { return const_cast<Bitmap &>(*this); }
 
        virtual void DeleteAnimation() const override { }
        
        virtual void SetController(Gorgon::Animation::ControllerBase &) override { }
 
        Containers::Image ReleaseData();
 
        Graphics::TextureImage ReleaseTexture() {
            auto sz = Graphics::Texture::size;
            return {Graphics::Texture::Release(), GetMode(), sz};
        }
 
        bool HasData() const {
            return data!=nullptr;
        }
 
        Containers::Image &GetData() const {
            if(!data)
                throw std::runtime_error("Bitmap data is not set");
            
            return *data;
        }
 
        bool HasTexture() const {
            return Graphics::Texture::id!=0;
        }
 
        void Assign(const Containers::Image &image) {
            if(!data) {
                data=new Containers::Image;
            }
 
            *data = image.Duplicate();
        }
 
        void Assign(Byte *newdata, const Geometry::Size &size, Graphics::ColorMode mode) {
            if(!data) {
                data=new Containers::Image;
            }
 
            data->Assign(newdata, size, mode);
        }
 
        void Assign(Byte *newdata) {
            if(!data) {
                throw std::runtime_error("Data is not set");
            }
 
            data->Assign(newdata);
        }
 
        void Assume(Containers::Image &image) {
            if(!data) {
                data=new Containers::Image;
            }
 
            *data = std::move(image);
        }
 
        void Assume(Byte *newdata, const Geometry::Size &size, Graphics::ColorMode mode) {
            if(!data) {
                data=new Containers::Image;
            }
 
            data->Assume(newdata, size, mode);
        }
 
        void Assume(Byte *newdata) {
            if(!data) {
                throw std::runtime_error("Data is not set");
            }
 
            data->Assume(newdata);
        }
 
        void Resize(const Geometry::Size &size, Graphics::ColorMode mode=Graphics::ColorMode::RGBA) {
            if(!data) {
                data=new Containers::Image;
            }
 
            data->Resize(size, mode);
        }
        
        void Resize(int w, int h, Graphics::ColorMode mode=Graphics::ColorMode::RGBA) {
            Resize({w, h}, mode);
        }
 
        Byte &operator()(const Geometry::Point &p, unsigned component=0) {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Data is not set");
            }
#endif
 
            return (*data)(p, component);
        }
 
        Byte operator()(const Geometry::Point &p, unsigned component=0) const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Data is not set");
            }
#endif
 
            return (*data)(p, component);
        }
 
        Byte &operator()(int x, int y, unsigned component=0) {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Data is not set");
            }
#endif
 
            return (*data)(x, y, component);
        }
 
        Byte operator()(int x, int y, unsigned component=0) const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Data is not set");
            }
#endif
 
            return (*data)(x, y, component);
        }
 
        Byte Get(const Geometry::Point &p, unsigned component = 0) const {
#ifndef NDEBUG
            if (!data) {
                throw std::runtime_error("Data is not set");
            }
#endif
 
            return data->Get(p, component);
        }
 
        Byte Get(const Geometry::Point &p, Byte def, unsigned component = 0) const {
#ifndef NDEBUG
            if (!data) {
                throw std::runtime_error("Data is not set");
            }
#endif
 
            return data->Get(p, def, component);
        }
 
        Byte GetAlphaAt(int x, int y) const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
            return data->GetAlphaAt(x, y);
        }
        
        Byte GetAlphaAt(Geometry::Point p) const {
            return GetAlphaAt(p.X, p.Y);
        }
        
        RGBA GetRGBAAt(int x, int y) const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
            
            return data->GetRGBAAt(x, y);
        }
 
        RGBA GetRGBAAt(Geometry::Point p) const {
            return GetRGBAAt(p.X, p.Y);
        }
        
        void SetRGBAAt(int x, int y, RGBA color) {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
            
            data->SetRGBAAt(x, y, color);
        }
        
        void SetRGBAAt(Geometry::Point p, RGBA color) {
            SetRGBAAt(p.X, p.Y, color);
        }
        
        int GetChannelsPerPixel() const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
            return data->GetChannelsPerPixel();
        }
 
        Graphics::ColorMode GetMode() const override {
            if(Graphics::Texture::id!=0) {
                return Graphics::Texture::GetMode();
            }
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
            return data->GetMode();
        }
 
        Geometry::Size GetSize() const override {
            if(Graphics::Texture::id!=0) {
                return Graphics::Texture::GetImageSize();
            }
            else if(data) {
                return data->GetSize();
            }
            else {
#ifndef NDEBUG
                throw std::runtime_error("Bitmap contains no data");
#endif
 
                return{0, 0};
            }
        }
 
        bool HasAlpha() const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
 
            return data->HasAlpha();
        }
 
        int GetAlphaIndex() const {
#ifndef NDEBUG
            if(!data) {
                throw std::runtime_error("Bitmap data is not set");
            }
#endif
 
            return data->GetAlphaIndex();
        }
 
        int GetWidth() const { return GetSize().Width; }
        
        int GetHeight() const { return GetSize().Height; }
 
        virtual void Prepare();
 
        virtual void Discard();
 
        bool ImportPNG(const std::string &filename);
 
        bool ImportJPEG(const std::string &filename);
 
        bool ImportBMP(const std::string &filename);
 
        bool ImportPNG(std::istream &file);
 
        bool ImportJPEG(std::istream &file);
 
        bool ImportBMP(std::istream &file);
 
        bool Import(const std::string &filename);
 
        bool Import(std::istream &file);
 
        bool ExportPNG(const std::string &filename);
 
        bool ExportPNG(std::ostream &out);
 
        bool ExportBMP(const std::string &filename);
 
        bool ExportBMP(std::ostream &out);
 
        bool ExportJPG(const std::string &filename, int quality = 90);
 
        bool ExportJPG(std::ostream &out, int quality = 90);
 
        Bitmap Blur(float amount, int windowsize=-1) const;
 
        Bitmap Shadow(float amount, int windowsize=-1) const;
 
        void Grayscale(float ratio=1.0f, GrayscaleConversionMethod method = Luminance);
 
        void StripAlpha();
 
        void StripRGB();
 
        Geometry::Margin Trim(bool left, bool top, bool right, bool bottom);
 
        Geometry::Margin Trim() {
            return Trim(true, true, true, true);
        }
 
        Geometry::Margin Trim(bool horizontal, bool vertical) {
            return Trim(horizontal, vertical, horizontal, vertical);
        }
        
        Geometry::Margin Trim(Geometry::Bounds bounds, bool left, bool top, bool right, bool bottom);
        
        Geometry::Margin Trim(Geometry::Bounds bounds, bool horizontal, bool vertical) {
            return Trim(bounds, horizontal, vertical, horizontal, vertical);
        }
        
        Geometry::Margin Trim(Geometry::Bounds bounds) {
            return Trim(bounds, true, true, true, true);
        }
 
        void ForAllPixels(std::function<void(int, int)> fn) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    fn(x, y);
        }
 
        void ForAllPixels(std::function<void(int, int, int)> fn) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    for(int c=0; c<GetChannelsPerPixel(); c++)
                        fn(x, y, c);
        }
 
        bool ForPixels(std::function<bool(int, int)> fn) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    if(!fn(x, y)) return false;
 
            return true;
        }
 
        bool ForPixels(std::function<bool(int, int, int)> fn) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    for(int c=0; c<GetChannelsPerPixel(); c++)
                            if(!fn(x, y, c)) return false;
 
            return true;
        }
 
        void ForAllPixels(std::function<void(Byte&)> fn, int channel) {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    fn(this->operator()(x, y, channel));
        }
 
        void ForAllPixels(std::function<void(Byte)> fn, int channel) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    fn(this->operator()(x, y, channel));
        }
 
        void ForAllValues(std::function<void(Byte&)> fn) {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    for(int c=0; c<GetChannelsPerPixel(); c++)
                        fn(this->operator()(x, y, c));
        }
 
        void ForAllValues(std::function<void(Byte)> fn) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    for(int c=0; c<GetChannelsPerPixel(); c++)
                        fn(this->operator()(x, y, c));
        }
 
        bool ForPixels(std::function<bool(Byte&)> fn, int channel) {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    if(!fn(this->operator()(x, y, channel)))
                        return false;
 
            return true;
        }
 
        bool ForPixels(std::function<bool(Byte)> fn, int channel) const {
            for(int y=0; y<data->GetHeight(); y++)
                for(int x=0; x<data->GetWidth(); x++)
                    if(!fn(this->operator()(x, y, channel)))
                        return false;
 
            return true;
        }
        
        bool IsEmpty(Geometry::Bounds bounds) const;
 
        bool IsEmpty() const {
            return IsEmpty({0,0, GetSize()});
        }
 
        Graphics::Bitmap Rotate90() const;
 
        Graphics::Bitmap Rotate180() const;
 
        Graphics::Bitmap Rotate270() const;
        
        Graphics::Bitmap ZoomMultiple(int factor) const;
 
        void Clear() {
            ASSERT(data, "Bitmap data is not set");
            data->Clear();
        }
 
        std::vector<Geometry::Bounds> CreateLinearAtlas(Containers::Collection<const Bitmap> list, AtlasMargin margins = None);
 
        std::vector<TextureImage> CreateAtlasImages(std::vector<Geometry::Bounds> boundaries) const;
        
        Bitmap Slice(Geometry::Bounds bounds) const {            
            ASSERT(data, "Bitmap data is not set");
            
            Bitmap ret(bounds.GetSize(), GetMode());
            
            data->CopyTo(ret.GetData(), bounds);
                
            return ret;
        }
 
    protected:
        bool Progress(unsigned &) override { return true; }
        
        int GetDuration() const override { return 0; }
        
        Geometry::Size getsize() const override {
            return GetSize();
        }
 
        Containers::Image *data = nullptr;
        
        using Texture::size;
    };
} }