wxPython/src/_image.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _image.i
// Purpose:     SWIG definitions for wxImage and such
//
// Author:      Robin Dunn
//
// Created:     25-Sept-2000
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


//---------------------------------------------------------------------------

%{
#include "wx/wxPython/pyistream.h"
%}

//---------------------------------------------------------------------------
%newgroup


class wxImageHandler : public wxObject {
public:
    // wxImageHandler();    Abstract Base Class
    wxString GetName();
    wxString GetExtension();
    long GetType();
    wxString GetMimeType();

    //bool LoadFile(wxImage* image, wxInputStream& stream);
    //bool SaveFile(wxImage* image, wxOutputStream& stream);
    //virtual int GetImageCount( wxInputStream& stream );
    //bool CanRead( wxInputStream& stream );

    bool CanRead( const wxString& name );

    void SetName(const wxString& name);
    void SetExtension(const wxString& extension);
    void SetType(long type);
    void SetMimeType(const wxString& mimetype);
};


//---------------------------------------------------------------------------

class wxImageHistogram /* : public wxImageHistogramBase */
{
public:
    wxImageHistogram();

    DocStr(MakeKey, "Get the key in the histogram for the given RGB values", "");
    static unsigned long MakeKey(unsigned char r,
                                 unsigned char g,
                                 unsigned char b);

    DocDeclAStr(
        bool, FindFirstUnusedColour(unsigned char *OUTPUT,
                                    unsigned char *OUTPUT,
                                    unsigned char *OUTPUT,
                                    unsigned char startR = 1,
                                    unsigned char startG = 0,
                                    unsigned char startB = 0 ) const,
        "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
        "Find first colour that is not used in the image and has higher RGB
values than startR, startG, startB.  Returns a tuple consisting of a
success flag and rgb values.", "");

    %extend {
        DocStr(GetCount,
               "Returns the pixel count for the given key.  Use `MakeKey` to create a
key value from a RGB tripple.", "");
        unsigned long GetCount(unsigned long key) {
            wxImageHistogramEntry e = (*self)[key];
            return e.value;
        }

        DocStr(GetCountRGB,
               "Returns the pixel count for the given RGB values.", "");
        unsigned long GetCountRGB(unsigned char r,
                                  unsigned char g,
                                  unsigned char b) {
            unsigned long key = wxImageHistogram::MakeKey(r, g, b);
            wxImageHistogramEntry e = (*self)[key];
            return e.value;
        }

        DocStr(GetCountColour,
               "Returns the pixel count for the given `wx.Colour` value.", "");
        unsigned long GetCountColour(const wxColour& colour) {
            unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
                                                          colour.Green(),
                                                          colour.Blue());
            wxImageHistogramEntry e = (*self)[key];
            return e.value;
        }
    }

};


//---------------------------------------------------------------------------


class wxImage : public wxObject {
public:
    DocCtorStr(
        wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 ),
        "", "");

    ~wxImage();

    // Alternate constructors
    DocCtorStrName(
        wxImage(const wxString& name, const wxString& mimetype, int index = -1),
        "", "",
        ImageFromMime);

    DocCtorStrName(
        wxImage(wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1),
        "", "",
        ImageFromStream);

    DocCtorStrName(
        wxImage(wxInputStream& stream, const wxString& mimetype, int index = -1 ),
        "", "",
        ImageFromStreamMime);

    %extend {
        %rename(EmptyImage) wxImage(int width=0, int height=0, bool clear = true);
        wxImage(int width=0, int height=0, bool clear = true)
        {
            if (width > 0 && height > 0)
                return new wxImage(width, height, clear);
            else
                return new wxImage;
        }

        MustHaveApp(wxImage(const wxBitmap &bitmap));
        %rename(ImageFromBitmap) wxImage(const wxBitmap &bitmap);
        wxImage(const wxBitmap &bitmap)
        {
            return new wxImage(bitmap.ConvertToImage());
        }

        %rename(ImageFromData) wxImage(int width, int height, unsigned char* data);
        wxImage(int width, int height, unsigned char* data)
        {
            // Copy the source data so the wxImage can clean it up later
            unsigned char* copy = (unsigned char*)malloc(width*height*3);
            if (copy == NULL) {
                PyErr_NoMemory();
                return NULL;
            }
            memcpy(copy, data, width*height*3);
            return new wxImage(width, height, copy, false);
        }


        %rename(ImageFromDataWithAlpha) wxImage(int width, int height, unsigned char* data, unsigned char* alpha);
        wxImage(int width, int height, unsigned char* data, unsigned char* alpha)
        {
            // Copy the source data so the wxImage can clean it up later
            unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
            if (dcopy == NULL) {
                PyErr_NoMemory();
                return NULL;
            }
            memcpy(dcopy, data, width*height*3);
            unsigned char* acopy = (unsigned char*)malloc(width*height);
            if (acopy == NULL) {
                PyErr_NoMemory();
                return NULL;
            }
            memcpy(acopy, alpha, width*height);

            return new wxImage(width, height, dcopy, acopy, false);
        }
    }

    // TODO: wxImage( char** xpmData );


    void Create( int width, int height );
    void Destroy();

    wxImage Scale( int width, int height );
    wxImage ShrinkBy( int xFactor , int yFactor ) const ;
    wxImage& Rescale(int width, int height);

    // resizes the image in place
    wxImage& Resize( const wxSize& size, const wxPoint& pos,
                     int r = -1, int g = -1, int b = -1 );

    void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );

    %Rename(SetRGBRect,
            void, SetRGB( const wxRect& rect,
                          unsigned char r, unsigned char g, unsigned char b ));

    unsigned char GetRed( int x, int y );
    unsigned char GetGreen( int x, int y );
    unsigned char GetBlue( int x, int y );

    void SetAlpha(int x, int y, unsigned char alpha);
    unsigned char GetAlpha(int x, int y);
    bool HasAlpha();

    DocDeclStr(
        void , InitAlpha(),
        "Initializes the image alpha channel data. It is an error to call it if
the image already has alpha data. If it doesn't, alpha data will be by
default initialized to all pixels being fully opaque. But if the image
has a a mask colour, all mask pixels will be completely transparent.", "");


    // find first colour that is not used in the image and has higher
    // RGB values than <startR,startG,startB>
    DocDeclAStr(
        bool, FindFirstUnusedColour( byte *OUTPUT, byte *OUTPUT, byte *OUTPUT,
                                     byte startR = 0, byte startG = 0, byte startB = 0 ) const,
        "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
        "Find first colour that is not used in the image and has higher RGB
values than startR, startG, startB.  Returns a tuple consisting of a
success flag and rgb values.", "");


    DocDeclStr(
        bool , ConvertAlphaToMask(byte threshold = 128),
        "If the image has alpha channel, this method converts it to mask. All pixels
with alpha value less than ``threshold`` are replaced with mask colour and the
alpha channel is removed. Mask colour is chosen automatically using
`FindFirstUnusedColour`.

If the image image doesn't have alpha channel, ConvertAlphaToMask does
nothing.", "");


    DocDeclStr(
        bool , ConvertColourToAlpha( unsigned char r, unsigned char g, unsigned char b ),
        "This method converts an image where the original alpha information is
only available as a shades of a colour (actually shades of grey)
typically when you draw anti-aliased text into a bitmap. The DC
drawing routines draw grey values on the black background although
they actually mean to draw white with differnt alpha values.  This
method reverses it, assuming a black (!) background and white text.
The method will then fill up the whole image with the colour given.", "");


    // Set image's mask to the area of 'mask' that has <mr,mg,mb> colour
    bool SetMaskFromImage(const wxImage & mask,
                          byte mr, byte mg, byte mb);

//      void DoFloodFill (wxCoord x, wxCoord y,
//          const wxBrush & fillBrush,
//          const wxColour& testColour,
//          int style = wxFLOOD_SURFACE,
//          int LogicalFunction = wxCOPY /* currently unused */ ) ;

    static bool CanRead( const wxString& name );
    static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );

    bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
    %Rename(LoadMimeFile, bool,  LoadFile( const wxString& name, const wxString& mimetype, int index = -1 ));

    bool SaveFile( const wxString& name, int type );
    %Rename(SaveMimeFile, bool,  SaveFile( const wxString& name, const wxString& mimetype ));

    %Rename(CanReadStream, static bool,  CanRead( wxInputStream& stream ));
    %Rename(LoadStream, bool,  LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 ));
    %Rename(LoadMimeStream, bool,  LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 ));

    bool Ok();
    int GetWidth();
    int GetHeight();

    %extend {
        wxSize GetSize() {
            wxSize size(self->GetWidth(), self->GetHeight());
            return size;
        }
    }

    wxImage GetSubImage(const wxRect& rect);

    // Paste the image or part of this image into an image of the given size at the pos
    //  any newly exposed areas will be filled with the rgb colour
    //  by default if r = g = b = -1 then fill with this image's mask colour or find and
    //  set a suitable mask colour
    wxImage Size( const wxSize& size, const wxPoint& pos,
                  int r = -1, int g = -1, int b = -1 ) const;

    wxImage Copy();
    void Paste( const wxImage &image, int x, int y );

    //unsigned char *GetData();
    //void SetData( unsigned char *data );

    %extend {
        PyObject* GetData() {
            unsigned char* data = self->GetData();
            int len = self->GetWidth() * self->GetHeight() * 3;
            PyObject* rv;
            wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
            return rv;
        }
        void SetData(PyObject* data) {
            unsigned char* dataPtr;

            if (! PyString_Check(data)) {
                wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
                                                  "Expected string object"));
                return /* NULL */ ;
            }

            size_t len = self->GetWidth() * self->GetHeight() * 3;
            dataPtr = (unsigned char*) malloc(len);
            wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
            self->SetData(dataPtr);
            // wxImage takes ownership of dataPtr...
        }


        PyObject* GetDataBuffer() {
            unsigned char* data = self->GetData();
            int len = self->GetWidth() * self->GetHeight() * 3;
            PyObject* rv;
            wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
            return rv;
        }
        void SetDataBuffer(PyObject* data) {
            unsigned char* buffer;
            int size;

            wxPyBlock_t blocked = wxPyBeginBlockThreads();
            if (!PyArg_Parse(data, "t#", &buffer, &size))
                goto done;

            if (size != self->GetWidth() * self->GetHeight() * 3) {
                PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
                goto done;
            }
            self->SetData(buffer);
        done:
            wxPyEndBlockThreads(blocked);
        }


        PyObject* GetAlphaData() {
            unsigned char* data = self->GetAlpha();
            if (! data) {
                RETURN_NONE();
            } else {
                int len = self->GetWidth() * self->GetHeight();
                PyObject* rv;
                wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
                return rv;
            }
        }
        void SetAlphaData(PyObject* data) {
            unsigned char* dataPtr;

            if (! PyString_Check(data)) {
                PyErr_SetString(PyExc_TypeError, "Expected string object");
                return /* NULL */ ;
            }

            size_t len = self->GetWidth() * self->GetHeight();
            dataPtr = (unsigned char*) malloc(len);
            wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
            self->SetAlpha(dataPtr);
            // wxImage takes ownership of dataPtr...
        }


        PyObject* GetAlphaBuffer() {
            unsigned char* data = self->GetAlpha();
            int len = self->GetWidth() * self->GetHeight();
            PyObject* rv;
            wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
            return rv;
        }
        void SetAlphaBuffer(PyObject* data) {
            unsigned char* buffer;
            int size;

            wxPyBlock_t blocked = wxPyBeginBlockThreads();
            if (!PyArg_Parse(data, "t#", &buffer, &size))
                goto done;

            if (size != self->GetWidth() * self->GetHeight()) {
                PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
                goto done;
            }
            self->SetAlpha(buffer);
        done:
            wxPyEndBlockThreads(blocked);
        }
    }

    void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );

    DocDeclAStr(
        /*bool*/ void , GetOrFindMaskColour( unsigned char *OUTPUT,
                                             unsigned char *OUTPUT,
                                             unsigned char *OUTPUT ) const,
        "GetOrFindMaskColour() -> (r,g,b)",
        "Get the current mask colour or find a suitable colour.", "");


    unsigned char GetMaskRed();
    unsigned char GetMaskGreen();
    unsigned char GetMaskBlue();
    void SetMask( bool mask = true );
    bool HasMask();

    wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
                   bool interpolating = true, wxPoint * offset_after_rotation = NULL) const ;
    wxImage Rotate90( bool clockwise = true ) ;
    wxImage Mirror( bool horizontally = true ) ;

    void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
                  unsigned char r2, unsigned char g2, unsigned char b2 );

    // convert to monochrome image (<r,g,b> will be replaced by white, everything else by black)
    wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;

    void SetOption(const wxString& name, const wxString& value);
    %Rename(SetOptionInt, void,  SetOption(const wxString& name, int value));
    wxString GetOption(const wxString& name) const;
    int GetOptionInt(const wxString& name) const;
    bool HasOption(const wxString& name) const;

    unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
    unsigned long ComputeHistogram( wxImageHistogram& h );

    static void AddHandler( wxImageHandler *handler );
    static void InsertHandler( wxImageHandler *handler );
    static bool RemoveHandler( const wxString& name );
    static wxString GetImageExtWildcard();


MustHaveApp(ConvertToBitmap);
MustHaveApp(ConvertToMonoBitmap);

    %extend {
        wxBitmap ConvertToBitmap(int depth=-1) {
            wxBitmap bitmap(*self, depth);
            return bitmap;
        }

        wxBitmap ConvertToMonoBitmap( unsigned char red,
                                      unsigned char green,
                                      unsigned char blue ) {
            wxImage mono = self->ConvertToMono( red, green, blue );
            wxBitmap bitmap( mono, 1 );
            return bitmap;
        }
    }

    %pythoncode { def __nonzero__(self): return self.Ok() }
};


///void wxInitAllImageHandlers();

%pythoncode {
    def InitAllImageHandlers():
        """
        The former functionality of InitAllImageHanders is now done internal to
        the _core_ extension module and so this function has become a simple NOP.
        """
        pass
}


// See also wxPy_ReinitStockObjects in helpers.cpp
%immutable;
const wxImage    wxNullImage;
%mutable;

//---------------------------------------------------------------------------

MAKE_CONST_WXSTRING(IMAGE_OPTION_FILENAME);
MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONX);
MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONY);
MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
MAKE_CONST_WXSTRING(IMAGE_OPTION_QUALITY);

enum
{
    wxIMAGE_RESOLUTION_INCHES = 1,
    wxIMAGE_RESOLUTION_CM = 2
};


MAKE_CONST_WXSTRING(IMAGE_OPTION_BITSPERSAMPLE);
MAKE_CONST_WXSTRING(IMAGE_OPTION_SAMPLESPERPIXEL);
MAKE_CONST_WXSTRING(IMAGE_OPTION_COMPRESSION);
MAKE_CONST_WXSTRING(IMAGE_OPTION_IMAGEDESCRIPTOR);

MAKE_CONST_WXSTRING(IMAGE_OPTION_PNG_FORMAT);
MAKE_CONST_WXSTRING(IMAGE_OPTION_PNG_BITDEPTH);

enum
{
    wxPNG_TYPE_COLOUR = 0,
    wxPNG_TYPE_GREY = 2,
    wxPNG_TYPE_GREY_RED = 3
};

enum
{
    wxBMP_24BPP        = 24, // default, do not need to set
    //wxBMP_16BPP      = 16, // wxQuantize can only do 236 colors?
    wxBMP_8BPP         =  8, // 8bpp, quantized colors
    wxBMP_8BPP_GREY    =  9, // 8bpp, rgb averaged to greys
    wxBMP_8BPP_GRAY    =  wxBMP_8BPP_GREY,
    wxBMP_8BPP_RED     = 10, // 8bpp, red used as greyscale
    wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
    wxBMP_4BPP         =  4, // 4bpp, quantized colors
    wxBMP_1BPP         =  1, // 1bpp, quantized "colors"
    wxBMP_1BPP_BW      =  2  // 1bpp, black & white from red
};


class wxBMPHandler : public wxImageHandler {
public:
    wxBMPHandler();
};

class wxICOHandler : public wxBMPHandler {
public:
    wxICOHandler();
};

class wxCURHandler : public wxICOHandler {
public:
    wxCURHandler();
};

class wxANIHandler : public wxCURHandler {
public:
    wxANIHandler();
};


//---------------------------------------------------------------------------

class wxPNGHandler : public wxImageHandler {
public:
    wxPNGHandler();
};


class wxGIFHandler : public wxImageHandler {
public:
    wxGIFHandler();
};


class wxPCXHandler : public wxImageHandler {
public:
    wxPCXHandler();
};


class wxJPEGHandler : public wxImageHandler {
public:
    wxJPEGHandler();
};


class wxPNMHandler : public wxImageHandler {
public:
    wxPNMHandler();
};

class wxXPMHandler : public wxImageHandler {
public:
    wxXPMHandler();
};

class wxTIFFHandler : public wxImageHandler {
public:
    wxTIFFHandler();
};


#if wxUSE_IFF
class wxIFFHandler : public wxImageHandler {
public:
    wxIFFHandler();
};
#endif

//---------------------------------------------------------------------------

%{
#include <wx/quantize.h>
%}

enum {
    wxQUANTIZE_INCLUDE_WINDOWS_COLOURS,
//    wxQUANTIZE_RETURN_8BIT_DATA,
    wxQUANTIZE_FILL_DESTINATION_IMAGE
};


DocStr(wxQuantize,
       "Performs quantization, or colour reduction, on a wxImage.", "");

class wxQuantize /*: public wxObject */
{
public:

    %extend {
        DocStr(
            Quantize,
            "Reduce the colours in the source image and put the result into the
destination image, setting the palette in the destination if
needed. Both images may be the same, to overwrite the source image.", "
:todo: Create a version that returns the wx.Palette used.");

        static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236,
                             int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE)
        {
                return wxQuantize::Quantize(src, dest,
                                            //NULL, // palette
                                            desiredNoColours,
                                            NULL, // eightBitData
                                            flags);
        }
    }
};


//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _image.i
	3	// Purpose: SWIG definitions for wxImage and such
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 25-Sept-2000
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
	16	//---------------------------------------------------------------------------
	17
	18	%{
	19	#include "wx/wxPython/pyistream.h"
	20	%}
	21
	22	//---------------------------------------------------------------------------
	23	%newgroup
	24
	25
	26	class wxImageHandler : public wxObject {
	27	public:
	28	// wxImageHandler(); Abstract Base Class
	29	wxString GetName();
	30	wxString GetExtension();
	31	long GetType();
	32	wxString GetMimeType();
	33
	34	//bool LoadFile(wxImage* image, wxInputStream& stream);
	35	//bool SaveFile(wxImage* image, wxOutputStream& stream);
	36	//virtual int GetImageCount( wxInputStream& stream );
	37	//bool CanRead( wxInputStream& stream );
	38
	39	bool CanRead( const wxString& name );
	40
	41	void SetName(const wxString& name);
	42	void SetExtension(const wxString& extension);
	43	void SetType(long type);
	44	void SetMimeType(const wxString& mimetype);
	45	};
	46
	47
	48	//---------------------------------------------------------------------------
	49
	50	class wxImageHistogram /* : public wxImageHistogramBase */
	51	{
	52	public:
	53	wxImageHistogram();
	54
	55	DocStr(MakeKey, "Get the key in the histogram for the given RGB values", "");
	56	static unsigned long MakeKey(unsigned char r,
	57	unsigned char g,
	58	unsigned char b);
	59
	60	DocDeclAStr(
	61	bool, FindFirstUnusedColour(unsigned char *OUTPUT,
	62	unsigned char *OUTPUT,
	63	unsigned char *OUTPUT,
	64	unsigned char startR = 1,
	65	unsigned char startG = 0,
	66	unsigned char startB = 0 ) const,
	67	"FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
	68	"Find first colour that is not used in the image and has higher RGB
	69	values than startR, startG, startB. Returns a tuple consisting of a
	70	success flag and rgb values.", "");
	71
	72	%extend {
	73	DocStr(GetCount,
	74	"Returns the pixel count for the given key. Use `MakeKey` to create a
	75	key value from a RGB tripple.", "");
	76	unsigned long GetCount(unsigned long key) {
	77	wxImageHistogramEntry e = (*self)[key];
	78	return e.value;
	79	}
	80
	81	DocStr(GetCountRGB,
	82	"Returns the pixel count for the given RGB values.", "");
	83	unsigned long GetCountRGB(unsigned char r,
	84	unsigned char g,
	85	unsigned char b) {
	86	unsigned long key = wxImageHistogram::MakeKey(r, g, b);
	87	wxImageHistogramEntry e = (*self)[key];
	88	return e.value;
	89	}
	90
	91	DocStr(GetCountColour,
	92	"Returns the pixel count for the given `wx.Colour` value.", "");
	93	unsigned long GetCountColour(const wxColour& colour) {
	94	unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
	95	colour.Green(),
	96	colour.Blue());
	97	wxImageHistogramEntry e = (*self)[key];
	98	return e.value;
	99	}
	100	}
	101
	102	};
	103
	104
	105	//---------------------------------------------------------------------------
	106
	107
	108	class wxImage : public wxObject {
	109	public:
	110	DocCtorStr(
	111	wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 ),
	112	"", "");
	113
	114	~wxImage();
	115
	116	// Alternate constructors
	117	DocCtorStrName(
	118	wxImage(const wxString& name, const wxString& mimetype, int index = -1),
	119	"", "",
	120	ImageFromMime);
	121
	122	DocCtorStrName(
	123	wxImage(wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1),
	124	"", "",
	125	ImageFromStream);
	126
	127	DocCtorStrName(
	128	wxImage(wxInputStream& stream, const wxString& mimetype, int index = -1 ),
	129	"", "",
	130	ImageFromStreamMime);
	131
	132	%extend {
	133	%rename(EmptyImage) wxImage(int width=0, int height=0, bool clear = true);
	134	wxImage(int width=0, int height=0, bool clear = true)
	135	{
	136	if (width > 0 && height > 0)
	137	return new wxImage(width, height, clear);
	138	else
	139	return new wxImage;
	140	}
	141
	142	MustHaveApp(wxImage(const wxBitmap &bitmap));
	143	%rename(ImageFromBitmap) wxImage(const wxBitmap &bitmap);
	144	wxImage(const wxBitmap &bitmap)
	145	{
	146	return new wxImage(bitmap.ConvertToImage());
	147	}
	148
	149	%rename(ImageFromData) wxImage(int width, int height, unsigned char* data);
	150	wxImage(int width, int height, unsigned char* data)
	151	{
	152	// Copy the source data so the wxImage can clean it up later
	153	unsigned char* copy = (unsigned char)malloc(widthheight*3);
	154	if (copy == NULL) {
	155	PyErr_NoMemory();
	156	return NULL;
	157	}
	158	memcpy(copy, data, widthheight3);
	159	return new wxImage(width, height, copy, false);
	160	}
	161
	162
	163	%rename(ImageFromDataWithAlpha) wxImage(int width, int height, unsigned char* data, unsigned char* alpha);
	164	wxImage(int width, int height, unsigned char* data, unsigned char* alpha)
	165	{
	166	// Copy the source data so the wxImage can clean it up later
	167	unsigned char* dcopy = (unsigned char)malloc(widthheight*3);
	168	if (dcopy == NULL) {
	169	PyErr_NoMemory();
	170	return NULL;
	171	}
	172	memcpy(dcopy, data, widthheight3);
	173	unsigned char* acopy = (unsigned char)malloc(widthheight);
	174	if (acopy == NULL) {
	175	PyErr_NoMemory();
	176	return NULL;
	177	}
	178	memcpy(acopy, alpha, width*height);
	179
	180	return new wxImage(width, height, dcopy, acopy, false);
	181	}
	182	}
	183
	184	// TODO: wxImage( char** xpmData );
	185
	186
	187	void Create( int width, int height );
	188	void Destroy();
	189
	190	wxImage Scale( int width, int height );
	191	wxImage ShrinkBy( int xFactor , int yFactor ) const ;
	192	wxImage& Rescale(int width, int height);
	193
	194	// resizes the image in place
	195	wxImage& Resize( const wxSize& size, const wxPoint& pos,
	196	int r = -1, int g = -1, int b = -1 );
	197
	198	void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
	199
	200	%Rename(SetRGBRect,
	201	void, SetRGB( const wxRect& rect,
	202	unsigned char r, unsigned char g, unsigned char b ));
	203
	204	unsigned char GetRed( int x, int y );
	205	unsigned char GetGreen( int x, int y );
	206	unsigned char GetBlue( int x, int y );
	207
	208	void SetAlpha(int x, int y, unsigned char alpha);
	209	unsigned char GetAlpha(int x, int y);
	210	bool HasAlpha();
	211
	212	DocDeclStr(
	213	void , InitAlpha(),
	214	"Initializes the image alpha channel data. It is an error to call it if
	215	the image already has alpha data. If it doesn't, alpha data will be by
	216	default initialized to all pixels being fully opaque. But if the image
	217	has a a mask colour, all mask pixels will be completely transparent.", "");
	218
	219
	220	// find first colour that is not used in the image and has higher
	221	// RGB values than <startR,startG,startB>
	222	DocDeclAStr(
	223	bool, FindFirstUnusedColour( byte OUTPUT, byte OUTPUT, byte *OUTPUT,
	224	byte startR = 0, byte startG = 0, byte startB = 0 ) const,
	225	"FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
	226	"Find first colour that is not used in the image and has higher RGB
	227	values than startR, startG, startB. Returns a tuple consisting of a
	228	success flag and rgb values.", "");
	229
	230
	231	DocDeclStr(
	232	bool , ConvertAlphaToMask(byte threshold = 128),
	233	"If the image has alpha channel, this method converts it to mask. All pixels
	234	with alpha value less than ``threshold`` are replaced with mask colour and the
	235	alpha channel is removed. Mask colour is chosen automatically using
	236	`FindFirstUnusedColour`.
	237
	238	If the image image doesn't have alpha channel, ConvertAlphaToMask does
	239	nothing.", "");
	240
	241
	242	DocDeclStr(
	243	bool , ConvertColourToAlpha( unsigned char r, unsigned char g, unsigned char b ),
	244	"This method converts an image where the original alpha information is
	245	only available as a shades of a colour (actually shades of grey)
	246	typically when you draw anti-aliased text into a bitmap. The DC
	247	drawing routines draw grey values on the black background although
	248	they actually mean to draw white with differnt alpha values. This
	249	method reverses it, assuming a black (!) background and white text.
	250	The method will then fill up the whole image with the colour given.", "");
	251
	252
	253
	254	// Set image's mask to the area of 'mask' that has <mr,mg,mb> colour
	255	bool SetMaskFromImage(const wxImage & mask,
	256	byte mr, byte mg, byte mb);
	257
	258	// void DoFloodFill (wxCoord x, wxCoord y,
	259	// const wxBrush & fillBrush,
	260	// const wxColour& testColour,
	261	// int style = wxFLOOD_SURFACE,
	262	// int LogicalFunction = wxCOPY /* currently unused */ ) ;
	263
	264	static bool CanRead( const wxString& name );
	265	static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
	266
	267	bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
	268	%Rename(LoadMimeFile, bool, LoadFile( const wxString& name, const wxString& mimetype, int index = -1 ));
	269
	270	bool SaveFile( const wxString& name, int type );
	271	%Rename(SaveMimeFile, bool, SaveFile( const wxString& name, const wxString& mimetype ));
	272
	273	%Rename(CanReadStream, static bool, CanRead( wxInputStream& stream ));
	274	%Rename(LoadStream, bool, LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 ));
	275	%Rename(LoadMimeStream, bool, LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 ));
	276
	277	bool Ok();
	278	int GetWidth();
	279	int GetHeight();
	280
	281	%extend {
	282	wxSize GetSize() {
	283	wxSize size(self->GetWidth(), self->GetHeight());
	284	return size;
	285	}
	286	}
	287
	288	wxImage GetSubImage(const wxRect& rect);
	289
	290	// Paste the image or part of this image into an image of the given size at the pos
	291	// any newly exposed areas will be filled with the rgb colour
	292	// by default if r = g = b = -1 then fill with this image's mask colour or find and
	293	// set a suitable mask colour
	294	wxImage Size( const wxSize& size, const wxPoint& pos,
	295	int r = -1, int g = -1, int b = -1 ) const;
	296
	297	wxImage Copy();
	298	void Paste( const wxImage &image, int x, int y );
	299
	300	//unsigned char *GetData();
	301	//void SetData( unsigned char *data );
	302
	303	%extend {
	304	PyObject* GetData() {
	305	unsigned char* data = self->GetData();
	306	int len = self->GetWidth() * self->GetHeight() * 3;
	307	PyObject* rv;
	308	wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
	309	return rv;
	310	}
	311	void SetData(PyObject* data) {
	312	unsigned char* dataPtr;
	313
	314	if (! PyString_Check(data)) {
	315	wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
	316	"Expected string object"));
	317	return /* NULL */ ;
	318	}
	319
	320	size_t len = self->GetWidth() * self->GetHeight() * 3;
	321	dataPtr = (unsigned char*) malloc(len);
	322	wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
	323	self->SetData(dataPtr);
	324	// wxImage takes ownership of dataPtr...
	325	}
	326
	327
	328
	329	PyObject* GetDataBuffer() {
	330	unsigned char* data = self->GetData();
	331	int len = self->GetWidth() * self->GetHeight() * 3;
	332	PyObject* rv;
	333	wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
	334	return rv;
	335	}
	336	void SetDataBuffer(PyObject* data) {
	337	unsigned char* buffer;
	338	int size;
	339
	340	wxPyBlock_t blocked = wxPyBeginBlockThreads();
	341	if (!PyArg_Parse(data, "t#", &buffer, &size))
	342	goto done;
	343
	344	if (size != self->GetWidth() * self->GetHeight() * 3) {
	345	PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
	346	goto done;
	347	}
	348	self->SetData(buffer);
	349	done:
	350	wxPyEndBlockThreads(blocked);
	351	}
	352
	353
	354
	355	PyObject* GetAlphaData() {
	356	unsigned char* data = self->GetAlpha();
	357	if (! data) {
	358	RETURN_NONE();
	359	} else {
	360	int len = self->GetWidth() * self->GetHeight();
	361	PyObject* rv;
	362	wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
	363	return rv;
	364	}
	365	}
	366	void SetAlphaData(PyObject* data) {
	367	unsigned char* dataPtr;
	368
	369	if (! PyString_Check(data)) {
	370	PyErr_SetString(PyExc_TypeError, "Expected string object");
	371	return /* NULL */ ;
	372	}
	373
	374	size_t len = self->GetWidth() * self->GetHeight();
	375	dataPtr = (unsigned char*) malloc(len);
	376	wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
	377	self->SetAlpha(dataPtr);
	378	// wxImage takes ownership of dataPtr...
	379	}
	380
	381
	382
	383	PyObject* GetAlphaBuffer() {
	384	unsigned char* data = self->GetAlpha();
	385	int len = self->GetWidth() * self->GetHeight();
	386	PyObject* rv;
	387	wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
	388	return rv;
	389	}
	390	void SetAlphaBuffer(PyObject* data) {
	391	unsigned char* buffer;
	392	int size;
	393
	394	wxPyBlock_t blocked = wxPyBeginBlockThreads();
	395	if (!PyArg_Parse(data, "t#", &buffer, &size))
	396	goto done;
	397
	398	if (size != self->GetWidth() * self->GetHeight()) {
	399	PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
	400	goto done;
	401	}
	402	self->SetAlpha(buffer);
	403	done:
	404	wxPyEndBlockThreads(blocked);
	405	}
	406	}
	407
	408	void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
	409
	410	DocDeclAStr(
	411	/bool/ void , GetOrFindMaskColour( unsigned char *OUTPUT,
	412	unsigned char *OUTPUT,
	413	unsigned char *OUTPUT ) const,
	414	"GetOrFindMaskColour() -> (r,g,b)",
	415	"Get the current mask colour or find a suitable colour.", "");
	416
	417
	418	unsigned char GetMaskRed();
	419	unsigned char GetMaskGreen();
	420	unsigned char GetMaskBlue();
	421	void SetMask( bool mask = true );
	422	bool HasMask();
	423
	424	wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
	425	bool interpolating = true, wxPoint * offset_after_rotation = NULL) const ;
	426	wxImage Rotate90( bool clockwise = true ) ;
	427	wxImage Mirror( bool horizontally = true ) ;
	428
	429	void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
	430	unsigned char r2, unsigned char g2, unsigned char b2 );
	431
	432	// convert to monochrome image (<r,g,b> will be replaced by white, everything else by black)
	433	wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;
	434
	435	void SetOption(const wxString& name, const wxString& value);
	436	%Rename(SetOptionInt, void, SetOption(const wxString& name, int value));
	437	wxString GetOption(const wxString& name) const;
	438	int GetOptionInt(const wxString& name) const;
	439	bool HasOption(const wxString& name) const;
	440
	441	unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
	442	unsigned long ComputeHistogram( wxImageHistogram& h );
	443
	444	static void AddHandler( wxImageHandler *handler );
	445	static void InsertHandler( wxImageHandler *handler );
	446	static bool RemoveHandler( const wxString& name );
	447	static wxString GetImageExtWildcard();
	448
	449
	450	MustHaveApp(ConvertToBitmap);
	451	MustHaveApp(ConvertToMonoBitmap);
	452
	453	%extend {
	454	wxBitmap ConvertToBitmap(int depth=-1) {
	455	wxBitmap bitmap(*self, depth);
	456	return bitmap;
	457	}
	458
	459	wxBitmap ConvertToMonoBitmap( unsigned char red,
	460	unsigned char green,
	461	unsigned char blue ) {
	462	wxImage mono = self->ConvertToMono( red, green, blue );
	463	wxBitmap bitmap( mono, 1 );
	464	return bitmap;
	465	}
	466	}
	467
	468	%pythoncode { def __nonzero__(self): return self.Ok() }
	469	};
	470
	471
	472
	473	///void wxInitAllImageHandlers();
	474
	475	%pythoncode {
	476	def InitAllImageHandlers():
	477	"""
	478	The former functionality of InitAllImageHanders is now done internal to
	479	the _core_ extension module and so this function has become a simple NOP.
	480	"""
	481	pass
	482	}
	483
	484
	485
	486	// See also wxPy_ReinitStockObjects in helpers.cpp
	487	%immutable;
	488	const wxImage wxNullImage;
	489	%mutable;
	490
	491	//---------------------------------------------------------------------------
	492
	493	MAKE_CONST_WXSTRING(IMAGE_OPTION_FILENAME);
	494	MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
	495	MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
	496	MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
	497	MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
	498	MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONX);
	499	MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONY);
	500	MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
	501	MAKE_CONST_WXSTRING(IMAGE_OPTION_QUALITY);
	502
	503	enum
	504	{
	505	wxIMAGE_RESOLUTION_INCHES = 1,
	506	wxIMAGE_RESOLUTION_CM = 2
	507	};
	508
	509
	510	MAKE_CONST_WXSTRING(IMAGE_OPTION_BITSPERSAMPLE);
	511	MAKE_CONST_WXSTRING(IMAGE_OPTION_SAMPLESPERPIXEL);
	512	MAKE_CONST_WXSTRING(IMAGE_OPTION_COMPRESSION);
	513	MAKE_CONST_WXSTRING(IMAGE_OPTION_IMAGEDESCRIPTOR);
	514
	515	MAKE_CONST_WXSTRING(IMAGE_OPTION_PNG_FORMAT);
	516	MAKE_CONST_WXSTRING(IMAGE_OPTION_PNG_BITDEPTH);
	517
	518	enum
	519	{
	520	wxPNG_TYPE_COLOUR = 0,
	521	wxPNG_TYPE_GREY = 2,
	522	wxPNG_TYPE_GREY_RED = 3
	523	};
	524
	525	enum
	526	{
	527	wxBMP_24BPP = 24, // default, do not need to set
	528	//wxBMP_16BPP = 16, // wxQuantize can only do 236 colors?
	529	wxBMP_8BPP = 8, // 8bpp, quantized colors
	530	wxBMP_8BPP_GREY = 9, // 8bpp, rgb averaged to greys
	531	wxBMP_8BPP_GRAY = wxBMP_8BPP_GREY,
	532	wxBMP_8BPP_RED = 10, // 8bpp, red used as greyscale
	533	wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
	534	wxBMP_4BPP = 4, // 4bpp, quantized colors
	535	wxBMP_1BPP = 1, // 1bpp, quantized "colors"
	536	wxBMP_1BPP_BW = 2 // 1bpp, black & white from red
	537	};
	538
	539
	540	class wxBMPHandler : public wxImageHandler {
	541	public:
	542	wxBMPHandler();
	543	};
	544
	545	class wxICOHandler : public wxBMPHandler {
	546	public:
	547	wxICOHandler();
	548	};
	549
	550	class wxCURHandler : public wxICOHandler {
	551	public:
	552	wxCURHandler();
	553	};
	554
	555	class wxANIHandler : public wxCURHandler {
	556	public:
	557	wxANIHandler();
	558	};
	559
	560
	561	//---------------------------------------------------------------------------
	562
	563	class wxPNGHandler : public wxImageHandler {
	564	public:
	565	wxPNGHandler();
	566	};
	567
	568
	569	class wxGIFHandler : public wxImageHandler {
	570	public:
	571	wxGIFHandler();
	572	};
	573
	574
	575	class wxPCXHandler : public wxImageHandler {
	576	public:
	577	wxPCXHandler();
	578	};
	579
	580
	581	class wxJPEGHandler : public wxImageHandler {
	582	public:
	583	wxJPEGHandler();
	584	};
	585
	586
	587	class wxPNMHandler : public wxImageHandler {
	588	public:
	589	wxPNMHandler();
	590	};
	591
	592	class wxXPMHandler : public wxImageHandler {
	593	public:
	594	wxXPMHandler();
	595	};
	596
	597	class wxTIFFHandler : public wxImageHandler {
	598	public:
	599	wxTIFFHandler();
	600	};
	601
	602
	603	#if wxUSE_IFF
	604	class wxIFFHandler : public wxImageHandler {
	605	public:
	606	wxIFFHandler();
	607	};
	608	#endif
	609
	610	//---------------------------------------------------------------------------
	611
	612	%{
	613	#include <wx/quantize.h>
	614	%}
	615
	616	enum {
	617	wxQUANTIZE_INCLUDE_WINDOWS_COLOURS,
	618	// wxQUANTIZE_RETURN_8BIT_DATA,
	619	wxQUANTIZE_FILL_DESTINATION_IMAGE
	620	};
	621
	622
	623	DocStr(wxQuantize,
	624	"Performs quantization, or colour reduction, on a wxImage.", "");
	625
	626	class wxQuantize /: public wxObject /
	627	{
	628	public:
	629
	630	%extend {
	631	DocStr(
	632	Quantize,
	633	"Reduce the colours in the source image and put the result into the
	634	destination image, setting the palette in the destination if
	635	needed. Both images may be the same, to overwrite the source image.", "
	636	:todo: Create a version that returns the wx.Palette used.");
	637
	638	static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236,
	639	int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS\|wxQUANTIZE_FILL_DESTINATION_IMAGE)
	640	{
	641	return wxQuantize::Quantize(src, dest,
	642	//NULL, // palette
	643	desiredNoColours,
	644	NULL, // eightBitData
	645	flags);
	646	}
	647	}
	648	};
	649
	650
	651	//---------------------------------------------------------------------------