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     DocDeclStr(
 150         bool , ConvertColourToAlpha( unsigned char r, unsigned char g, unsigned char b ),
 151         "This method converts an image where the original alpha information is
 152 only available as a shades of a colour (actually shades of grey)
 153 typically when you draw anti-aliased text into a bitmap. The DC
 154 drawing routines draw grey values on the black background although
 155 they actually mean to draw white with differnt alpha values.  This
 156 method reverses it, assuming a black (!) background and white text.
 157 The method will then fill up the whole image with the colour given.", "");
 158
 159
 160
 161     // Set image's mask to the area of 'mask' that has <mr,mg,mb> colour
 162     bool SetMaskFromImage(const wxImage & mask,
 163                           byte mr, byte mg, byte mb);
 164
 165 //      void DoFloodFill (wxCoord x, wxCoord y,
 166 //          const wxBrush & fillBrush,
 167 //          const wxColour& testColour,
 168 //          int style = wxFLOOD_SURFACE,
 169 //          int LogicalFunction = wxCOPY /* currently unused */ ) ;
 170
 171     static bool CanRead( const wxString& name );
 172     static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 173
 174     bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
 175     %name(LoadMimeFile)bool LoadFile( const wxString& name, const wxString& mimetype, int index = -1 );
 176
 177     bool SaveFile( const wxString& name, int type );
 178     %name(SaveMimeFile)bool SaveFile( const wxString& name, const wxString& mimetype );
 179
 180     %name(CanReadStream) static bool CanRead( wxInputStream& stream );
 181     %name(LoadStream) bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 );
 182     %name(LoadMimeStream) bool LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 );
 183
 184     bool Ok();
 185     int GetWidth();
 186     int GetHeight();
 187
 188     %extend {
 189         wxSize GetSize() {
 190             wxSize size(self->GetWidth(), self->GetHeight());
 191             return size;
 192         }
 193     }
 194
 195     wxImage GetSubImage(const wxRect& rect);
 196     wxImage Copy();
 197     void Paste( const wxImage &image, int x, int y );
 198
 199     //unsigned char *GetData();
 200     //void SetData( unsigned char *data );
 201
 202     %extend {
 203         PyObject* GetData() {
 204             unsigned char* data = self->GetData();
 205             int len = self->GetWidth() * self->GetHeight() * 3;
 206             PyObject* rv;
 207             wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
 208             return rv;
 209         }
 210         void SetData(PyObject* data) {
 211             unsigned char* dataPtr;
 212
 213             if (! PyString_Check(data)) {
 214                 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
 215                                                   "Expected string object"));
 216                 return /* NULL */ ;
 217             }
 218
 219             size_t len = self->GetWidth() * self->GetHeight() * 3;
 220             dataPtr = (unsigned char*) malloc(len);
 221             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 222             self->SetData(dataPtr);
 223             // wxImage takes ownership of dataPtr...
 224         }
 225
 226
 227
 228         PyObject* GetDataBuffer() {
 229             unsigned char* data = self->GetData();
 230             int len = self->GetWidth() * self->GetHeight() * 3;
 231             PyObject* rv;
 232             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 233             return rv;
 234         }
 235         void SetDataBuffer(PyObject* data) {
 236             unsigned char* buffer;
 237             int size;
 238
 239             bool blocked = wxPyBeginBlockThreads();
 240             if (!PyArg_Parse(data, "t#", &buffer, &size))
 241                 goto done;
 242
 243             if (size != self->GetWidth() * self->GetHeight() * 3) {
 244                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 245                 goto done;
 246             }
 247             self->SetData(buffer);
 248         done:
 249             wxPyEndBlockThreads(blocked);
 250         }
 251
 252
 253
 254         PyObject* GetAlphaData() {
 255             unsigned char* data = self->GetAlpha();
 256             if (! data) {
 257                 RETURN_NONE();
 258             } else {
 259                 int len = self->GetWidth() * self->GetHeight();
 260                 PyObject* rv;
 261                 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
 262                 return rv;
 263             }
 264         }
 265         void SetAlphaData(PyObject* data) {
 266             unsigned char* dataPtr;
 267
 268             if (! PyString_Check(data)) {
 269                 PyErr_SetString(PyExc_TypeError, "Expected string object");
 270                 return /* NULL */ ;
 271             }
 272
 273             size_t len = self->GetWidth() * self->GetHeight();
 274             dataPtr = (unsigned char*) malloc(len);
 275             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 276             self->SetAlpha(dataPtr);
 277             // wxImage takes ownership of dataPtr...
 278         }
 279
 280
 281
 282         PyObject* GetAlphaBuffer() {
 283             unsigned char* data = self->GetAlpha();
 284             int len = self->GetWidth() * self->GetHeight();
 285             PyObject* rv;
 286             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 287             return rv;
 288         }
 289         void SetAlphaBuffer(PyObject* data) {
 290             unsigned char* buffer;
 291             int size;
 292
 293             bool blocked = wxPyBeginBlockThreads();
 294             if (!PyArg_Parse(data, "t#", &buffer, &size))
 295                 goto done;
 296
 297             if (size != self->GetWidth() * self->GetHeight()) {
 298                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 299                 goto done;
 300             }
 301             self->SetAlpha(buffer);
 302         done:
 303             wxPyEndBlockThreads(blocked);
 304         }
 305     }
 306
 307     void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 308     unsigned char GetMaskRed();
 309     unsigned char GetMaskGreen();
 310     unsigned char GetMaskBlue();
 311     void SetMask( bool mask = true );
 312     bool HasMask();
 313
 314     wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
 315                    bool interpolating = true, wxPoint * offset_after_rotation = NULL) const ;
 316     wxImage Rotate90( bool clockwise = true ) ;
 317     wxImage Mirror( bool horizontally = true ) ;
 318
 319     void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
 320                   unsigned char r2, unsigned char g2, unsigned char b2 );
 321
 322     // convert to monochrome image (<r,g,b> will be replaced by white, everything else by black)
 323     wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;
 324
 325     void SetOption(const wxString& name, const wxString& value);
 326     %name(SetOptionInt)void SetOption(const wxString& name, int value);
 327     wxString GetOption(const wxString& name) const;
 328     int GetOptionInt(const wxString& name) const;
 329     bool HasOption(const wxString& name) const;
 330
 331     unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
 332     unsigned long ComputeHistogram( wxImageHistogram& h );
 333
 334     static void AddHandler( wxImageHandler *handler );
 335     static void InsertHandler( wxImageHandler *handler );
 336     static bool RemoveHandler( const wxString& name );
 337     static wxString GetImageExtWildcard();
 338
 339
 340 MustHaveApp(ConvertToBitmap);
 341 MustHaveApp(ConvertToMonoBitmap);
 342
 343     %extend {
 344         wxBitmap ConvertToBitmap(int depth=-1) {
 345             wxBitmap bitmap(*self, depth);
 346             return bitmap;
 347         }
 348
 349         wxBitmap ConvertToMonoBitmap( unsigned char red,
 350                                       unsigned char green,
 351                                       unsigned char blue ) {
 352             wxImage mono = self->ConvertToMono( red, green, blue );
 353             wxBitmap bitmap( mono, 1 );
 354             return bitmap;
 355         }
 356     }
 357
 358     %pythoncode { def __nonzero__(self): return self.Ok() }
 359 };
 360
 361
 362
 363 ///void wxInitAllImageHandlers();
 364
 365 %pythoncode {
 366     def InitAllImageHandlers():
 367         """
 368         The former functionality of InitAllImageHanders is now done internal to
 369         the _core_ extension module and so this function has become a simple NOP.
 370         """
 371         pass
 372 }
 373
 374
 375
 376 // See also wxPy_ReinitStockObjects in helpers.cpp
 377 %immutable;
 378 const wxImage    wxNullImage;
 379 %mutable;
 380
 381 //---------------------------------------------------------------------------
 382
 383
 384 MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
 385 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
 386 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
 387 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
 388 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
 389
 390 enum
 391 {
 392     wxIMAGE_RESOLUTION_INCHES = 1,
 393     wxIMAGE_RESOLUTION_CM = 2
 394 };
 395
 396
 397 enum
 398 {
 399     wxBMP_24BPP        = 24, // default, do not need to set
 400     //wxBMP_16BPP      = 16, // wxQuantize can only do 236 colors?
 401     wxBMP_8BPP         =  8, // 8bpp, quantized colors
 402     wxBMP_8BPP_GREY    =  9, // 8bpp, rgb averaged to greys
 403     wxBMP_8BPP_GRAY    =  wxBMP_8BPP_GREY,
 404     wxBMP_8BPP_RED     = 10, // 8bpp, red used as greyscale
 405     wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
 406     wxBMP_4BPP         =  4, // 4bpp, quantized colors
 407     wxBMP_1BPP         =  1, // 1bpp, quantized "colors"
 408     wxBMP_1BPP_BW      =  2  // 1bpp, black & white from red
 409 };
 410
 411
 412 class wxBMPHandler : public wxImageHandler {
 413 public:
 414     wxBMPHandler();
 415 };
 416
 417 class wxICOHandler : public wxBMPHandler {
 418 public:
 419     wxICOHandler();
 420 };
 421
 422 class wxCURHandler : public wxICOHandler {
 423 public:
 424     wxCURHandler();
 425 };
 426
 427 class wxANIHandler : public wxCURHandler {
 428 public:
 429     wxANIHandler();
 430 };
 431
 432
 433 //---------------------------------------------------------------------------
 434
 435 class wxPNGHandler : public wxImageHandler {
 436 public:
 437     wxPNGHandler();
 438 };
 439
 440
 441 class wxGIFHandler : public wxImageHandler {
 442 public:
 443     wxGIFHandler();
 444 };
 445
 446
 447 class wxPCXHandler : public wxImageHandler {
 448 public:
 449     wxPCXHandler();
 450 };
 451
 452
 453 class wxJPEGHandler : public wxImageHandler {
 454 public:
 455     wxJPEGHandler();
 456 };
 457
 458
 459 class wxPNMHandler : public wxImageHandler {
 460 public:
 461     wxPNMHandler();
 462 };
 463
 464 class wxXPMHandler : public wxImageHandler {
 465 public:
 466     wxXPMHandler();
 467 };
 468
 469 class wxTIFFHandler : public wxImageHandler {
 470 public:
 471     wxTIFFHandler();
 472 };
 473
 474
 475 #if wxUSE_IFF
 476 class wxIFFHandler : public wxImageHandler {
 477 public:
 478     wxIFFHandler();
 479 };
 480 #endif
 481
 482 //---------------------------------------------------------------------------
 483
 484 %{
 485 #include <wx/quantize.h>
 486 %}
 487
 488 enum {
 489     wxQUANTIZE_INCLUDE_WINDOWS_COLOURS,
 490 //    wxQUANTIZE_RETURN_8BIT_DATA,
 491     wxQUANTIZE_FILL_DESTINATION_IMAGE
 492 };
 493
 494
 495 DocStr(wxQuantize,
 496        "Performs quantization, or colour reduction, on a wxImage.", "");
 497
 498 class wxQuantize /*: public wxObject */
 499 {
 500 public:
 501
 502     %extend {
 503         DocStr(
 504             Quantize,
 505             "Reduce the colours in the source image and put the result into the
 506 destination image, setting the palette in the destination if
 507 needed. Both images may be the same, to overwrite the source image.", "
 508 :todo: Create a version that returns the wx.Palette used.");
 509
 510         static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236,
 511                              int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE)
 512         {
 513                 return wxQuantize::Quantize(src, dest,
 514                                             //NULL, // palette
 515                                             desiredNoColours,
 516                                             NULL, // eightBitData
 517                                             flags);
 518         }
 519     }
 520 };
 521
 522
 523 //---------------------------------------------------------------------------