juce_Image.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2015 - ROLI Ltd.
 
   Permission is granted to use this software under the terms of either:
   a) the GPL v2 (or any later version)
   b) the Affero GPL v3
 
   Details of these licenses can be found at: www.gnu.org/licenses
 
   JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 
   ------------------------------------------------------------------------------
 
   To release a closed-source product which uses JUCE, commercial licenses are
   available: visit www.juce.com for more information.
 
  ==============================================================================
*/
 
#ifndef JUCE_IMAGE_H_INCLUDED
#define JUCE_IMAGE_H_INCLUDED
 
class ImageType;
class ImagePixelData;
 
 
//==============================================================================
class JUCE_API  Image
{
public:
    //==============================================================================
    enum PixelFormat
    {
        UnknownFormat,
        RGB,                
        ARGB,               
        SingleChannel       
    };
 
    //==============================================================================
    Image() noexcept;
 
    Image (PixelFormat format, int imageWidth, int imageHeight, bool clearImage);
 
    Image (PixelFormat format, int imageWidth, int imageHeight, bool clearImage, const ImageType& type);
 
    Image (const Image&) noexcept;
 
    Image& operator= (const Image&);
 
   #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS
    Image (Image&&) noexcept;
    Image& operator= (Image&&) noexcept;
   #endif
 
    ~Image();
 
    bool operator== (const Image& other) const noexcept     { return image == other.image; }
 
    bool operator!= (const Image& other) const noexcept     { return image != other.image; }
 
    inline bool isValid() const noexcept                    { return image != nullptr; }
 
    inline bool isNull() const noexcept                     { return image == nullptr; }
 
    static const Image null;
 
    //==============================================================================
    int getWidth() const noexcept;
 
    int getHeight() const noexcept;
 
    Rectangle<int> getBounds() const noexcept;
 
    PixelFormat getFormat() const noexcept;
 
    bool isARGB() const noexcept;
 
    bool isRGB() const noexcept;
 
    bool isSingleChannel() const noexcept;
 
    bool hasAlphaChannel() const noexcept;
 
    //==============================================================================
    void clear (const Rectangle<int>& area, Colour colourToClearTo = Colour (0x00000000));
 
    Image rescaled (int newWidth, int newHeight,
                    Graphics::ResamplingQuality quality = Graphics::mediumResamplingQuality) const;
 
    Image createCopy() const;
 
    Image convertedToFormat (PixelFormat newFormat) const;
 
    void duplicateIfShared();
 
    Image getClippedImage (const Rectangle<int>& area) const;
 
    //==============================================================================
    Colour getPixelAt (int x, int y) const;
 
    void setPixelAt (int x, int y, Colour colour);
 
    void multiplyAlphaAt (int x, int y, float multiplier);
 
    void multiplyAllAlphas (float amountToMultiplyBy);
 
    void desaturate();
 
    //==============================================================================
    class JUCE_API  BitmapData
    {
    public:
        enum ReadWriteMode
        {
            readOnly,
            writeOnly,
            readWrite
        };
 
        BitmapData (Image& image, int x, int y, int w, int h, ReadWriteMode mode);
        BitmapData (const Image& image, int x, int y, int w, int h);
        BitmapData (const Image& image, ReadWriteMode mode);
        ~BitmapData();
 
        inline uint8* getLinePointer (int y) const noexcept                 { return data + y * lineStride; }
 
        inline uint8* getPixelPointer (int x, int y) const noexcept         { return data + y * lineStride + x * pixelStride; }
 
        Colour getPixelColour (int x, int y) const noexcept;
 
        void setPixelColour (int x, int y, Colour colour) const noexcept;
 
        Rectangle<int> getBounds() const noexcept                           { return Rectangle<int> (width, height); }
 
        uint8* data;             
        PixelFormat pixelFormat; 
        int lineStride;          
        int pixelStride;         
        int width, height;
 
        //==============================================================================
        class BitmapDataReleaser
        {
        protected:
            BitmapDataReleaser() {}
        public:
            virtual ~BitmapDataReleaser() {}
        };
 
        ScopedPointer<BitmapDataReleaser> dataReleaser;
 
    private:
        JUCE_DECLARE_NON_COPYABLE (BitmapData)
    };
 
    //==============================================================================
    void moveImageSection (int destX, int destY,
                           int sourceX, int sourceY,
                           int width, int height);
 
    void createSolidAreaMask (RectangleList<int>& result, float alphaThreshold) const;
 
    //==============================================================================
    NamedValueSet* getProperties() const;
 
    //==============================================================================
    LowLevelGraphicsContext* createLowLevelContext() const;
 
    int getReferenceCount() const noexcept;
 
    //==============================================================================
    ImagePixelData* getPixelData() const noexcept       { return image; }
 
    explicit Image (ImagePixelData*) noexcept;
 
private:
    //==============================================================================
    ReferenceCountedObjectPtr<ImagePixelData> image;
 
    JUCE_LEAK_DETECTOR (Image)
};
 
 
//==============================================================================
class JUCE_API  ImagePixelData  : public ReferenceCountedObject
{
public:
    ImagePixelData (Image::PixelFormat, int width, int height);
    ~ImagePixelData();
 
    virtual LowLevelGraphicsContext* createLowLevelContext() = 0;
    virtual ImagePixelData* clone() = 0;
    virtual ImageType* createType() const = 0;
    virtual void initialiseBitmapData (Image::BitmapData&, int x, int y, Image::BitmapData::ReadWriteMode) = 0;
    virtual int getSharedCount() const noexcept;
 
 
    const Image::PixelFormat pixelFormat;
    const int width, height;
 
    NamedValueSet userData;
 
    typedef ReferenceCountedObjectPtr<ImagePixelData> Ptr;
 
    //==============================================================================
    struct Listener
    {
        virtual ~Listener() {}
 
        virtual void imageDataChanged (ImagePixelData*) = 0;
        virtual void imageDataBeingDeleted (ImagePixelData*) = 0;
    };
 
    ListenerList<Listener> listeners;
 
    void sendDataChangeMessage();
 
private:
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ImagePixelData)
};
 
//==============================================================================
class JUCE_API  ImageType
{
public:
    ImageType();
    virtual ~ImageType();
 
    virtual ImagePixelData::Ptr create (Image::PixelFormat format, int width, int height, bool shouldClearImage) const = 0;
 
    virtual int getTypeID() const = 0;
 
    virtual Image convert (const Image& source) const;
};
 
//==============================================================================
class JUCE_API  SoftwareImageType   : public ImageType
{
public:
    SoftwareImageType();
    ~SoftwareImageType();
 
    ImagePixelData::Ptr create (Image::PixelFormat, int width, int height, bool clearImage) const override;
    int getTypeID() const override;
};
 
//==============================================================================
class JUCE_API  NativeImageType   : public ImageType
{
public:
    NativeImageType();
    ~NativeImageType();
 
    ImagePixelData::Ptr create (Image::PixelFormat, int width, int height, bool clearImage) const override;
    int getTypeID() const override;
};
 
 
#endif   // JUCE_IMAGE_H_INCLUDED