wxPython/src/_image.i

   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
  73
  74 //---------------------------------------------------------------------------
  75
  76
  77 class wxImage : public wxObject {
  78 public:
  79     wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
  80     ~wxImage();
  81
  82     // Alternate constructors
  83     %name(ImageFromMime) wxImage(const wxString& name, const wxString& mimetype, int index = -1);
  84     %name(ImageFromStream) wxImage(wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1);
  85     %name(ImageFromStreamMime) wxImage(wxInputStream& stream, const wxString& mimetype, int index = -1 );
  86     %extend {
  87         %name(EmptyImage) wxImage(int width=0, int height=0, bool clear = true) {
  88             if (width > 0 && height > 0)
  89                 return new wxImage(width, height, clear);
  90             else
  91                 return new wxImage;
  92         }
  93
  94         MustHaveApp(wxImage(const wxBitmap &bitmap));
  95         %name(ImageFromBitmap) wxImage(const wxBitmap &bitmap) {
  96             return new wxImage(bitmap.ConvertToImage());
  97         }
  98
  99         %name(ImageFromData) wxImage(int width, int height, unsigned char* data) {
 100             // Copy the source data so the wxImage can clean it up later
 101             unsigned char* copy = (unsigned char*)malloc(width*height*3);
 102             if (copy == NULL) {
 103                 PyErr_NoMemory();
 104                 return NULL;
 105             }
 106             memcpy(copy, data, width*height*3);
 107             return new wxImage(width, height, copy, false);
 108         }
 109     }
 110
 111     void Create( int width, int height );
 112     void Destroy();
 113
 114     wxImage Scale( int width, int height );
 115     wxImage ShrinkBy( int xFactor , int yFactor ) const ;
 116     wxImage& Rescale(int width, int height);
 117
 118     void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
 119     unsigned char GetRed( int x, int y );
 120     unsigned char GetGreen( int x, int y );
 121     unsigned char GetBlue( int x, int y );
 122
 123     void SetAlpha(int x, int y, unsigned char alpha);
 124     unsigned char GetAlpha(int x, int y);
 125     bool HasAlpha();
 126
 127     // find first colour that is not used in the image and has higher
 128     // RGB values than <startR,startG,startB>
 129     DocDeclAStr(
 130         bool, FindFirstUnusedColour( byte *OUTPUT, byte *OUTPUT, byte *OUTPUT,
 131                                      byte startR = 0, byte startG = 0, byte startB = 0 ) const,
 132         "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
 133         "Find first colour that is not used in the image and has higher RGB
 134 values than startR, startG, startB.  Returns a tuple consisting of a
 135 success flag and rgb values.", "");
 136
 137
 138     DocDeclStr(
 139         bool , ConvertAlphaToMask(byte threshold = 128),
 140         "If the image has alpha channel, this method converts it to mask. All pixels
 141 with alpha value less than ``threshold`` are replaced with mask colour and the
 142 alpha channel is removed. Mask colour is chosen automatically using
 143 `FindFirstUnusedColour`.
 144
 145 If the image image doesn't have alpha channel, ConvertAlphaToMask does
 146 nothing.", "");
 147
 148
 149
 150     // Set image's mask to the area of 'mask' that has <mr,mg,mb> colour
 151     bool SetMaskFromImage(const wxImage & mask,
 152                           byte mr, byte mg, byte mb);
 153
 154 //      void DoFloodFill (wxCoord x, wxCoord y,
 155 //          const wxBrush & fillBrush,
 156 //          const wxColour& testColour,
 157 //          int style = wxFLOOD_SURFACE,
 158 //          int LogicalFunction = wxCOPY /* currently unused */ ) ;
 159
 160     static bool CanRead( const wxString& name );
 161     static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 162
 163     bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
 164     %name(LoadMimeFile)bool LoadFile( const wxString& name, const wxString& mimetype, int index = -1 );
 165
 166     bool SaveFile( const wxString& name, int type );
 167     %name(SaveMimeFile)bool SaveFile( const wxString& name, const wxString& mimetype );
 168
 169     %name(CanReadStream) static bool CanRead( wxInputStream& stream );
 170     %name(LoadStream) bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 );
 171     %name(LoadMimeStream) bool LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 );
 172
 173     bool Ok();
 174     int GetWidth();
 175     int GetHeight();
 176
 177     %extend {
 178         wxSize GetSize() {
 179             wxSize size(self->GetWidth(), self->GetHeight());
 180             return size;
 181         }
 182     }
 183
 184     wxImage GetSubImage(const wxRect& rect);
 185     wxImage Copy();
 186     void Paste( const wxImage &image, int x, int y );
 187
 188     //unsigned char *GetData();
 189     //void SetData( unsigned char *data );
 190
 191     %extend {
 192         PyObject* GetData() {
 193             unsigned char* data = self->GetData();
 194             int len = self->GetWidth() * self->GetHeight() * 3;
 195             PyObject* rv;
 196             wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
 197             return rv;
 198         }
 199         void SetData(PyObject* data) {
 200             unsigned char* dataPtr;
 201
 202             if (! PyString_Check(data)) {
 203                 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
 204                                                   "Expected string object"));
 205                 return /* NULL */ ;
 206             }
 207
 208             size_t len = self->GetWidth() * self->GetHeight() * 3;
 209             dataPtr = (unsigned char*) malloc(len);
 210             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 211             self->SetData(dataPtr);
 212             // wxImage takes ownership of dataPtr...
 213         }
 214
 215
 216
 217         PyObject* GetDataBuffer() {
 218             unsigned char* data = self->GetData();
 219             int len = self->GetWidth() * self->GetHeight() * 3;
 220             PyObject* rv;
 221             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 222             return rv;
 223         }
 224         void SetDataBuffer(PyObject* data) {
 225             unsigned char* buffer;
 226             int size;
 227
 228             bool blocked = wxPyBeginBlockThreads();
 229             if (!PyArg_Parse(data, "t#", &buffer, &size))
 230                 goto done;
 231
 232             if (size != self->GetWidth() * self->GetHeight() * 3) {
 233                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 234                 goto done;
 235             }
 236             self->SetData(buffer);
 237         done:
 238             wxPyEndBlockThreads(blocked);
 239         }
 240
 241
 242
 243         PyObject* GetAlphaData() {
 244             unsigned char* data = self->GetAlpha();
 245             if (! data) {
 246                 RETURN_NONE();
 247             } else {
 248                 int len = self->GetWidth() * self->GetHeight();
 249                 PyObject* rv;
 250                 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
 251                 return rv;
 252             }
 253         }
 254         void SetAlphaData(PyObject* data) {
 255             unsigned char* dataPtr;
 256
 257             if (! PyString_Check(data)) {
 258                 PyErr_SetString(PyExc_TypeError, "Expected string object");
 259                 return /* NULL */ ;
 260             }
 261
 262             size_t len = self->GetWidth() * self->GetHeight();
 263             dataPtr = (unsigned char*) malloc(len);
 264             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 265             self->SetAlpha(dataPtr);
 266             // wxImage takes ownership of dataPtr...
 267         }
 268
 269
 270
 271         PyObject* GetAlphaBuffer() {
 272             unsigned char* data = self->GetAlpha();
 273             int len = self->GetWidth() * self->GetHeight();
 274             PyObject* rv;
 275             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 276             return rv;
 277         }
 278         void SetAlphaBuffer(PyObject* data) {
 279             unsigned char* buffer;
 280             int size;
 281
 282             bool blocked = wxPyBeginBlockThreads();
 283             if (!PyArg_Parse(data, "t#", &buffer, &size))
 284                 goto done;
 285
 286             if (size != self->GetWidth() * self->GetHeight()) {
 287                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 288                 goto done;
 289             }
 290             self->SetAlpha(buffer);
 291         done:
 292             wxPyEndBlockThreads(blocked);
 293         }
 294     }
 295
 296     void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 297     unsigned char GetMaskRed();
 298     unsigned char GetMaskGreen();
 299     unsigned char GetMaskBlue();
 300     void SetMask( bool mask = true );
 301     bool HasMask();
 302
 303     wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
 304                    bool interpolating = true, wxPoint * offset_after_rotation = NULL) const ;
 305     wxImage Rotate90( bool clockwise = true ) ;
 306     wxImage Mirror( bool horizontally = true ) ;
 307
 308     void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
 309                   unsigned char r2, unsigned char g2, unsigned char b2 );
 310
 311     // convert to monochrome image (<r,g,b> will be replaced by white, everything else by black)
 312     wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;
 313
 314     void SetOption(const wxString& name, const wxString& value);
 315     %name(SetOptionInt)void SetOption(const wxString& name, int value);
 316     wxString GetOption(const wxString& name) const;
 317     int GetOptionInt(const wxString& name) const;
 318     bool HasOption(const wxString& name) const;
 319
 320     unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
 321     unsigned long ComputeHistogram( wxImageHistogram& h );
 322
 323     static void AddHandler( wxImageHandler *handler );
 324     static void InsertHandler( wxImageHandler *handler );
 325     static bool RemoveHandler( const wxString& name );
 326     static wxString GetImageExtWildcard();
 327
 328
 329 MustHaveApp(ConvertToBitmap);
 330 MustHaveApp(ConvertToMonoBitmap);
 331
 332     %extend {
 333         wxBitmap ConvertToBitmap(int depth=-1) {
 334             wxBitmap bitmap(*self, depth);
 335             return bitmap;
 336         }
 337
 338         wxBitmap ConvertToMonoBitmap( unsigned char red,
 339                                       unsigned char green,
 340                                       unsigned char blue ) {
 341             wxImage mono = self->ConvertToMono( red, green, blue );
 342             wxBitmap bitmap( mono, 1 );
 343             return bitmap;
 344         }
 345     }
 346
 347     %pythoncode { def __nonzero__(self): return self.Ok() }
 348 };
 349
 350
 351
 352 ///void wxInitAllImageHandlers();
 353
 354 %pythoncode {
 355     def InitAllImageHandlers():
 356         """
 357         The former functionality of InitAllImageHanders is now done internal to
 358         the _core_ extension module and so this function has become a simple NOP.
 359         """
 360         pass
 361 }
 362
 363
 364
 365 // See also wxPy_ReinitStockObjects in helpers.cpp
 366 %immutable;
 367 const wxImage    wxNullImage;
 368 %mutable;
 369
 370 //---------------------------------------------------------------------------
 371
 372
 373 MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
 374 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
 375 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
 376 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
 377 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
 378
 379 enum
 380 {
 381     wxIMAGE_RESOLUTION_INCHES = 1,
 382     wxIMAGE_RESOLUTION_CM = 2
 383 };
 384
 385
 386 enum
 387 {
 388     wxBMP_24BPP        = 24, // default, do not need to set
 389     //wxBMP_16BPP      = 16, // wxQuantize can only do 236 colors?
 390     wxBMP_8BPP         =  8, // 8bpp, quantized colors
 391     wxBMP_8BPP_GREY    =  9, // 8bpp, rgb averaged to greys
 392     wxBMP_8BPP_GRAY    =  wxBMP_8BPP_GREY,
 393     wxBMP_8BPP_RED     = 10, // 8bpp, red used as greyscale
 394     wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
 395     wxBMP_4BPP         =  4, // 4bpp, quantized colors
 396     wxBMP_1BPP         =  1, // 1bpp, quantized "colors"
 397     wxBMP_1BPP_BW      =  2  // 1bpp, black & white from red
 398 };
 399
 400
 401 class wxBMPHandler : public wxImageHandler {
 402 public:
 403     wxBMPHandler();
 404 };
 405
 406 class wxICOHandler : public wxBMPHandler {
 407 public:
 408     wxICOHandler();
 409 };
 410
 411 class wxCURHandler : public wxICOHandler {
 412 public:
 413     wxCURHandler();
 414 };
 415
 416 class wxANIHandler : public wxCURHandler {
 417 public:
 418     wxANIHandler();
 419 };
 420
 421
 422 //---------------------------------------------------------------------------
 423
 424 class wxPNGHandler : public wxImageHandler {
 425 public:
 426     wxPNGHandler();
 427 };
 428
 429
 430 class wxGIFHandler : public wxImageHandler {
 431 public:
 432     wxGIFHandler();
 433 };
 434
 435
 436 class wxPCXHandler : public wxImageHandler {
 437 public:
 438     wxPCXHandler();
 439 };
 440
 441
 442 class wxJPEGHandler : public wxImageHandler {
 443 public:
 444     wxJPEGHandler();
 445 };
 446
 447
 448 class wxPNMHandler : public wxImageHandler {
 449 public:
 450     wxPNMHandler();
 451 };
 452
 453 class wxXPMHandler : public wxImageHandler {
 454 public:
 455     wxXPMHandler();
 456 };
 457
 458 class wxTIFFHandler : public wxImageHandler {
 459 public:
 460     wxTIFFHandler();
 461 };
 462
 463
 464 #if wxUSE_IFF
 465 class wxIFFHandler : public wxImageHandler {
 466 public:
 467     wxIFFHandler();
 468 };
 469 #endif
 470
 471 //---------------------------------------------------------------------------
 472
 473 %{
 474 #include <wx/quantize.h>
 475 %}
 476
 477 enum {
 478     wxQUANTIZE_INCLUDE_WINDOWS_COLOURS,
 479 //    wxQUANTIZE_RETURN_8BIT_DATA,
 480     wxQUANTIZE_FILL_DESTINATION_IMAGE
 481 };
 482
 483
 484 DocStr(wxQuantize,
 485        "Performs quantization, or colour reduction, on a wxImage.", "");
 486
 487 class wxQuantize /*: public wxObject */
 488 {
 489 public:
 490
 491     %extend {
 492         DocStr(
 493             Quantize,
 494             "Reduce the colours in the source image and put the result into the
 495 destination image, setting the palette in the destination if
 496 needed. Both images may be the same, to overwrite the source image.", "
 497 :todo: Create a version that returns the wx.Palette used.");
 498
 499         static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236,
 500                              int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE)
 501         {
 502                 return wxQuantize::Quantize(src, dest,
 503                                             //NULL, // palette
 504                                             desiredNoColours,
 505                                             NULL, // eightBitData
 506                                             flags);
 507         }
 508     }
 509 };
 510
 511
 512 //---------------------------------------------------------------------------