]>
Commit | Line | Data |
---|---|---|
01111366 | 1 | ///////////////////////////////////////////////////////////////////////////// |
38d4b1e4 | 2 | // Name: src/common/image.cpp |
01111366 RR |
3 | // Purpose: wxImage |
4 | // Author: Robert Roebling | |
5 | // RCS-ID: $Id$ | |
6 | // Copyright: (c) Robert Roebling | |
65571936 | 7 | // Licence: wxWindows licence |
01111366 RR |
8 | ///////////////////////////////////////////////////////////////////////////// |
9 | ||
0b4f9ee3 UU |
10 | // For compilers that support precompilation, includes "wx.h". |
11 | #include "wx/wxprec.h" | |
12 | ||
13 | #ifdef __BORLANDC__ | |
edccf428 | 14 | #pragma hdrstop |
0b4f9ee3 UU |
15 | #endif |
16 | ||
c96ea657 VS |
17 | #if wxUSE_IMAGE |
18 | ||
0bca0373 WS |
19 | #include "wx/image.h" |
20 | ||
8898456d WS |
21 | #ifndef WX_PRECOMP |
22 | #include "wx/log.h" | |
32d4c30a | 23 | #include "wx/hash.h" |
de6185e2 | 24 | #include "wx/utils.h" |
18680f86 | 25 | #include "wx/math.h" |
02761f6c | 26 | #include "wx/module.h" |
5ff14574 PC |
27 | #include "wx/palette.h" |
28 | #include "wx/intl.h" | |
8898456d WS |
29 | #endif |
30 | ||
dc86cb34 | 31 | #include "wx/filefn.h" |
3d05544e | 32 | #include "wx/wfstream.h" |
452418c4 | 33 | #include "wx/xpmdecod.h" |
cad61c3e | 34 | |
58a8ab88 JS |
35 | // For memcpy |
36 | #include <string.h> | |
37 | ||
6632225c VS |
38 | // make the code compile with either wxFile*Stream or wxFFile*Stream: |
39 | #define HAS_FILE_STREAMS (wxUSE_STREAMS && (wxUSE_FILE || wxUSE_FFILE)) | |
40 | ||
41 | #if HAS_FILE_STREAMS | |
8d6c5e4f | 42 | #if wxUSE_FFILE |
6632225c VS |
43 | typedef wxFFileInputStream wxImageFileInputStream; |
44 | typedef wxFFileOutputStream wxImageFileOutputStream; | |
8d6c5e4f VS |
45 | #elif wxUSE_FILE |
46 | typedef wxFileInputStream wxImageFileInputStream; | |
47 | typedef wxFileOutputStream wxImageFileOutputStream; | |
6632225c VS |
48 | #endif // wxUSE_FILE/wxUSE_FFILE |
49 | #endif // HAS_FILE_STREAMS | |
50 | ||
6f5d7825 | 51 | #if wxUSE_VARIANT |
55ccdb93 | 52 | IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT) |
6f5d7825 RR |
53 | #endif |
54 | ||
01111366 RR |
55 | //----------------------------------------------------------------------------- |
56 | // wxImage | |
57 | //----------------------------------------------------------------------------- | |
58 | ||
59 | class wxImageRefData: public wxObjectRefData | |
60 | { | |
fd0eed64 | 61 | public: |
edccf428 | 62 | wxImageRefData(); |
487659e0 | 63 | virtual ~wxImageRefData(); |
c7abc967 | 64 | |
dbda9e86 JS |
65 | int m_width; |
66 | int m_height; | |
591d3fa2 | 67 | wxBitmapType m_type; |
dbda9e86 | 68 | unsigned char *m_data; |
487659e0 | 69 | |
dbda9e86 JS |
70 | bool m_hasMask; |
71 | unsigned char m_maskRed,m_maskGreen,m_maskBlue; | |
487659e0 VZ |
72 | |
73 | // alpha channel data, may be NULL for the formats without alpha support | |
74 | unsigned char *m_alpha; | |
75 | ||
dbda9e86 | 76 | bool m_ok; |
d2502f14 VZ |
77 | |
78 | // if true, m_data is pointer to static data and shouldn't be freed | |
f6bcfd97 | 79 | bool m_static; |
487659e0 | 80 | |
d2502f14 VZ |
81 | // same as m_static but for m_alpha |
82 | bool m_staticAlpha; | |
83 | ||
d275c7eb | 84 | #if wxUSE_PALETTE |
5e5437e0 | 85 | wxPalette m_palette; |
d275c7eb | 86 | #endif // wxUSE_PALETTE |
487659e0 | 87 | |
5e5437e0 JS |
88 | wxArrayString m_optionNames; |
89 | wxArrayString m_optionValues; | |
22f3361e VZ |
90 | |
91 | DECLARE_NO_COPY_CLASS(wxImageRefData) | |
01111366 RR |
92 | }; |
93 | ||
edccf428 | 94 | wxImageRefData::wxImageRefData() |
01111366 | 95 | { |
fd0eed64 RR |
96 | m_width = 0; |
97 | m_height = 0; | |
591d3fa2 | 98 | m_type = wxBITMAP_TYPE_INVALID; |
487659e0 VZ |
99 | m_data = |
100 | m_alpha = (unsigned char *) NULL; | |
101 | ||
fd0eed64 RR |
102 | m_maskRed = 0; |
103 | m_maskGreen = 0; | |
104 | m_maskBlue = 0; | |
70cd62e9 | 105 | m_hasMask = false; |
487659e0 | 106 | |
70cd62e9 | 107 | m_ok = false; |
d2502f14 VZ |
108 | m_static = |
109 | m_staticAlpha = false; | |
01111366 RR |
110 | } |
111 | ||
edccf428 | 112 | wxImageRefData::~wxImageRefData() |
01111366 | 113 | { |
d2502f14 | 114 | if ( !m_static ) |
58c837a4 | 115 | free( m_data ); |
d2502f14 | 116 | if ( !m_staticAlpha ) |
4ea56379 | 117 | free( m_alpha ); |
01111366 RR |
118 | } |
119 | ||
120 | wxList wxImage::sm_handlers; | |
121 | ||
fec19ea9 VS |
122 | wxImage wxNullImage; |
123 | ||
01111366 RR |
124 | //----------------------------------------------------------------------------- |
125 | ||
5c33522f | 126 | #define M_IMGDATA static_cast<wxImageRefData*>(m_refData) |
01111366 | 127 | |
5e5437e0 | 128 | IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject) |
01111366 | 129 | |
ff865c13 | 130 | wxImage::wxImage( int width, int height, bool clear ) |
01111366 | 131 | { |
ff865c13 | 132 | Create( width, height, clear ); |
01111366 RR |
133 | } |
134 | ||
f6bcfd97 BP |
135 | wxImage::wxImage( int width, int height, unsigned char* data, bool static_data ) |
136 | { | |
137 | Create( width, height, data, static_data ); | |
138 | } | |
139 | ||
4ea56379 RR |
140 | wxImage::wxImage( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data ) |
141 | { | |
142 | Create( width, height, data, alpha, static_data ); | |
143 | } | |
144 | ||
e98e625c | 145 | wxImage::wxImage( const wxString& name, wxBitmapType type, int index ) |
01111366 | 146 | { |
60d43ad8 | 147 | LoadFile( name, type, index ); |
01111366 RR |
148 | } |
149 | ||
60d43ad8 | 150 | wxImage::wxImage( const wxString& name, const wxString& mimetype, int index ) |
9e9ee68e | 151 | { |
60d43ad8 | 152 | LoadFile( name, mimetype, index ); |
9e9ee68e VS |
153 | } |
154 | ||
e02afc7a | 155 | #if wxUSE_STREAMS |
e98e625c | 156 | wxImage::wxImage( wxInputStream& stream, wxBitmapType type, int index ) |
3d05544e | 157 | { |
60d43ad8 | 158 | LoadFile( stream, type, index ); |
3d05544e | 159 | } |
9e9ee68e | 160 | |
60d43ad8 | 161 | wxImage::wxImage( wxInputStream& stream, const wxString& mimetype, int index ) |
9e9ee68e | 162 | { |
60d43ad8 | 163 | LoadFile( stream, mimetype, index ); |
9e9ee68e | 164 | } |
e02afc7a | 165 | #endif // wxUSE_STREAMS |
3d05544e | 166 | |
452418c4 | 167 | wxImage::wxImage(const char* const* xpmData) |
cad61c3e JS |
168 | { |
169 | Create(xpmData); | |
170 | } | |
171 | ||
452418c4 | 172 | bool wxImage::Create(const char* const* xpmData) |
cad61c3e JS |
173 | { |
174 | #if wxUSE_XPM | |
175 | UnRef(); | |
e9b64c5e | 176 | |
cad61c3e JS |
177 | wxXPMDecoder decoder; |
178 | (*this) = decoder.ReadData(xpmData); | |
179 | return Ok(); | |
180 | #else | |
181 | return false; | |
182 | #endif | |
183 | } | |
184 | ||
aaa97828 | 185 | bool wxImage::Create( int width, int height, bool clear ) |
01111366 | 186 | { |
aadaf841 GRG |
187 | UnRef(); |
188 | ||
fd0eed64 | 189 | m_refData = new wxImageRefData(); |
c7abc967 | 190 | |
fd0eed64 | 191 | M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 ); |
aaa97828 | 192 | if (!M_IMGDATA->m_data) |
fd0eed64 RR |
193 | { |
194 | UnRef(); | |
70cd62e9 | 195 | return false; |
fd0eed64 | 196 | } |
aaa97828 | 197 | |
aaa97828 VZ |
198 | M_IMGDATA->m_width = width; |
199 | M_IMGDATA->m_height = height; | |
70cd62e9 | 200 | M_IMGDATA->m_ok = true; |
aaa97828 | 201 | |
fc3762b5 FM |
202 | if (clear) |
203 | { | |
204 | Clear(); | |
205 | } | |
206 | ||
70cd62e9 | 207 | return true; |
01111366 RR |
208 | } |
209 | ||
aaa97828 | 210 | bool wxImage::Create( int width, int height, unsigned char* data, bool static_data ) |
f6bcfd97 BP |
211 | { |
212 | UnRef(); | |
213 | ||
70cd62e9 | 214 | wxCHECK_MSG( data, false, _T("NULL data in wxImage::Create") ); |
aaa97828 | 215 | |
f6bcfd97 BP |
216 | m_refData = new wxImageRefData(); |
217 | ||
218 | M_IMGDATA->m_data = data; | |
aaa97828 VZ |
219 | M_IMGDATA->m_width = width; |
220 | M_IMGDATA->m_height = height; | |
70cd62e9 | 221 | M_IMGDATA->m_ok = true; |
aaa97828 VZ |
222 | M_IMGDATA->m_static = static_data; |
223 | ||
70cd62e9 | 224 | return true; |
f6bcfd97 BP |
225 | } |
226 | ||
4ea56379 RR |
227 | bool wxImage::Create( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data ) |
228 | { | |
229 | UnRef(); | |
230 | ||
231 | wxCHECK_MSG( data, false, _T("NULL data in wxImage::Create") ); | |
232 | ||
233 | m_refData = new wxImageRefData(); | |
234 | ||
235 | M_IMGDATA->m_data = data; | |
236 | M_IMGDATA->m_alpha = alpha; | |
237 | M_IMGDATA->m_width = width; | |
238 | M_IMGDATA->m_height = height; | |
239 | M_IMGDATA->m_ok = true; | |
240 | M_IMGDATA->m_static = static_data; | |
a805de23 | 241 | M_IMGDATA->m_staticAlpha = static_data; |
4ea56379 RR |
242 | |
243 | return true; | |
244 | } | |
245 | ||
01111366 RR |
246 | void wxImage::Destroy() |
247 | { | |
fd0eed64 | 248 | UnRef(); |
01111366 RR |
249 | } |
250 | ||
fc3762b5 FM |
251 | void wxImage::Clear(unsigned char value) |
252 | { | |
253 | memset(M_IMGDATA->m_data, value, M_IMGDATA->m_width*M_IMGDATA->m_height*3); | |
254 | } | |
255 | ||
a0f81e9f | 256 | wxObjectRefData* wxImage::CreateRefData() const |
f6bcfd97 | 257 | { |
a0f81e9f PC |
258 | return new wxImageRefData; |
259 | } | |
051924b8 | 260 | |
a0f81e9f PC |
261 | wxObjectRefData* wxImage::CloneRefData(const wxObjectRefData* that) const |
262 | { | |
5c33522f | 263 | const wxImageRefData* refData = static_cast<const wxImageRefData*>(that); |
a0f81e9f | 264 | wxCHECK_MSG(refData->m_ok, NULL, wxT("invalid image") ); |
051924b8 | 265 | |
a0f81e9f PC |
266 | wxImageRefData* refData_new = new wxImageRefData; |
267 | refData_new->m_width = refData->m_width; | |
268 | refData_new->m_height = refData->m_height; | |
269 | refData_new->m_maskRed = refData->m_maskRed; | |
270 | refData_new->m_maskGreen = refData->m_maskGreen; | |
271 | refData_new->m_maskBlue = refData->m_maskBlue; | |
272 | refData_new->m_hasMask = refData->m_hasMask; | |
273 | refData_new->m_ok = true; | |
274 | unsigned size = unsigned(refData->m_width) * unsigned(refData->m_height); | |
275 | if (refData->m_alpha != NULL) | |
a1cd9564 | 276 | { |
a0f81e9f PC |
277 | refData_new->m_alpha = (unsigned char*)malloc(size); |
278 | memcpy(refData_new->m_alpha, refData->m_alpha, size); | |
a1cd9564 | 279 | } |
a0f81e9f PC |
280 | size *= 3; |
281 | refData_new->m_data = (unsigned char*)malloc(size); | |
282 | memcpy(refData_new->m_data, refData->m_data, size); | |
283 | #if wxUSE_PALETTE | |
284 | refData_new->m_palette = refData->m_palette; | |
285 | #endif | |
286 | refData_new->m_optionNames = refData->m_optionNames; | |
287 | refData_new->m_optionValues = refData->m_optionValues; | |
288 | return refData_new; | |
289 | } | |
051924b8 | 290 | |
a0f81e9f PC |
291 | wxImage wxImage::Copy() const |
292 | { | |
293 | wxImage image; | |
294 | ||
295 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
296 | ||
297 | image.m_refData = CloneRefData(m_refData); | |
d8692f2b | 298 | |
f6bcfd97 BP |
299 | return image; |
300 | } | |
301 | ||
fd9655ad SC |
302 | wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const |
303 | { | |
304 | if( xFactor == 1 && yFactor == 1 ) | |
a0f81e9f | 305 | return *this; |
7beb59f3 | 306 | |
fd9655ad SC |
307 | wxImage image; |
308 | ||
309 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
310 | ||
311 | // can't scale to/from 0 size | |
312 | wxCHECK_MSG( (xFactor > 0) && (yFactor > 0), image, | |
313 | wxT("invalid new image size") ); | |
314 | ||
315 | long old_height = M_IMGDATA->m_height, | |
316 | old_width = M_IMGDATA->m_width; | |
7beb59f3 | 317 | |
fd9655ad SC |
318 | wxCHECK_MSG( (old_height > 0) && (old_width > 0), image, |
319 | wxT("invalid old image size") ); | |
320 | ||
321 | long width = old_width / xFactor ; | |
322 | long height = old_height / yFactor ; | |
323 | ||
ff865c13 | 324 | image.Create( width, height, false ); |
fd9655ad SC |
325 | |
326 | char unsigned *data = image.GetData(); | |
327 | ||
328 | wxCHECK_MSG( data, image, wxT("unable to create image") ); | |
329 | ||
330 | bool hasMask = false ; | |
331 | unsigned char maskRed = 0; | |
332 | unsigned char maskGreen = 0; | |
333 | unsigned char maskBlue =0 ; | |
cd0bbd03 SC |
334 | |
335 | unsigned char *source_data = M_IMGDATA->m_data; | |
336 | unsigned char *target_data = data; | |
337 | unsigned char *source_alpha = 0 ; | |
338 | unsigned char *target_alpha = 0 ; | |
fd9655ad SC |
339 | if (M_IMGDATA->m_hasMask) |
340 | { | |
341 | hasMask = true ; | |
342 | maskRed = M_IMGDATA->m_maskRed; | |
343 | maskGreen = M_IMGDATA->m_maskGreen; | |
344 | maskBlue =M_IMGDATA->m_maskBlue ; | |
7beb59f3 | 345 | |
fd9655ad SC |
346 | image.SetMaskColour( M_IMGDATA->m_maskRed, |
347 | M_IMGDATA->m_maskGreen, | |
348 | M_IMGDATA->m_maskBlue ); | |
349 | } | |
cd0bbd03 SC |
350 | else |
351 | { | |
352 | source_alpha = M_IMGDATA->m_alpha ; | |
353 | if ( source_alpha ) | |
354 | { | |
355 | image.SetAlpha() ; | |
356 | target_alpha = image.GetAlpha() ; | |
357 | } | |
358 | } | |
7beb59f3 | 359 | |
fd9655ad SC |
360 | for (long y = 0; y < height; y++) |
361 | { | |
fd9655ad SC |
362 | for (long x = 0; x < width; x++) |
363 | { | |
364 | unsigned long avgRed = 0 ; | |
365 | unsigned long avgGreen = 0; | |
366 | unsigned long avgBlue = 0; | |
cd0bbd03 | 367 | unsigned long avgAlpha = 0 ; |
fd9655ad SC |
368 | unsigned long counter = 0 ; |
369 | // determine average | |
370 | for ( int y1 = 0 ; y1 < yFactor ; ++y1 ) | |
371 | { | |
372 | long y_offset = (y * yFactor + y1) * old_width; | |
373 | for ( int x1 = 0 ; x1 < xFactor ; ++x1 ) | |
374 | { | |
375 | unsigned char *pixel = source_data + 3 * ( y_offset + x * xFactor + x1 ) ; | |
376 | unsigned char red = pixel[0] ; | |
377 | unsigned char green = pixel[1] ; | |
378 | unsigned char blue = pixel[2] ; | |
cd0bbd03 SC |
379 | unsigned char alpha = 255 ; |
380 | if ( source_alpha ) | |
381 | alpha = *(source_alpha + y_offset + x * xFactor + x1) ; | |
fd9655ad SC |
382 | if ( !hasMask || red != maskRed || green != maskGreen || blue != maskBlue ) |
383 | { | |
cd0bbd03 SC |
384 | if ( alpha > 0 ) |
385 | { | |
386 | avgRed += red ; | |
387 | avgGreen += green ; | |
388 | avgBlue += blue ; | |
389 | } | |
390 | avgAlpha += alpha ; | |
fd9655ad SC |
391 | counter++ ; |
392 | } | |
393 | } | |
394 | } | |
395 | if ( counter == 0 ) | |
396 | { | |
397 | *(target_data++) = M_IMGDATA->m_maskRed ; | |
398 | *(target_data++) = M_IMGDATA->m_maskGreen ; | |
399 | *(target_data++) = M_IMGDATA->m_maskBlue ; | |
400 | } | |
401 | else | |
402 | { | |
cd0bbd03 SC |
403 | if ( source_alpha ) |
404 | *(target_alpha++) = (unsigned char)(avgAlpha / counter ) ; | |
646c4aeb VZ |
405 | *(target_data++) = (unsigned char)(avgRed / counter); |
406 | *(target_data++) = (unsigned char)(avgGreen / counter); | |
407 | *(target_data++) = (unsigned char)(avgBlue / counter); | |
fd9655ad SC |
408 | } |
409 | } | |
410 | } | |
411 | ||
8180d40b | 412 | // In case this is a cursor, make sure the hotspot is scaled accordingly: |
fd9655ad SC |
413 | if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) ) |
414 | image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, | |
415 | (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor); | |
416 | if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) ) | |
417 | image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, | |
418 | (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y))/yFactor); | |
419 | ||
420 | return image; | |
421 | } | |
422 | ||
07aaa1a4 | 423 | wxImage wxImage::Scale( int width, int height, int quality ) const |
4bc67cc5 RR |
424 | { |
425 | wxImage image; | |
c7abc967 | 426 | |
223d09f6 | 427 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); |
c7abc967 | 428 | |
6721fc38 VZ |
429 | // can't scale to/from 0 size |
430 | wxCHECK_MSG( (width > 0) && (height > 0), image, | |
431 | wxT("invalid new image size") ); | |
432 | ||
433 | long old_height = M_IMGDATA->m_height, | |
434 | old_width = M_IMGDATA->m_width; | |
435 | wxCHECK_MSG( (old_height > 0) && (old_width > 0), image, | |
436 | wxT("invalid old image size") ); | |
c7abc967 | 437 | |
30f27c00 VZ |
438 | // If the image's new width and height are the same as the original, no |
439 | // need to waste time or CPU cycles | |
440 | if ( old_width == width && old_height == height ) | |
07aaa1a4 RR |
441 | return *this; |
442 | ||
30f27c00 VZ |
443 | // Scale the image (...or more appropriately, resample the image) using |
444 | // either the high-quality or normal method as specified | |
445 | if ( quality == wxIMAGE_QUALITY_HIGH ) | |
fd9655ad | 446 | { |
07aaa1a4 | 447 | // We need to check whether we are downsampling or upsampling the image |
30f27c00 | 448 | if ( width < old_width && height < old_height ) |
07aaa1a4 RR |
449 | { |
450 | // Downsample the image using the box averaging method for best results | |
451 | image = ResampleBox(width, height); | |
452 | } | |
453 | else | |
454 | { | |
30f27c00 VZ |
455 | // For upsampling or other random/wierd image dimensions we'll use |
456 | // a bicubic b-spline scaling method | |
07aaa1a4 RR |
457 | image = ResampleBicubic(width, height); |
458 | } | |
fd9655ad | 459 | } |
07aaa1a4 RR |
460 | else // Default scaling method == simple pixel replication |
461 | { | |
462 | if ( old_width % width == 0 && old_width >= width && | |
463 | old_height % height == 0 && old_height >= height ) | |
464 | { | |
465 | return ShrinkBy( old_width / width , old_height / height ) ; | |
466 | } | |
467 | image.Create( width, height, false ); | |
c7abc967 | 468 | |
07aaa1a4 | 469 | unsigned char *data = image.GetData(); |
c7abc967 | 470 | |
07aaa1a4 | 471 | wxCHECK_MSG( data, image, wxT("unable to create image") ); |
c7abc967 | 472 | |
07aaa1a4 RR |
473 | unsigned char *source_data = M_IMGDATA->m_data; |
474 | unsigned char *target_data = data; | |
475 | unsigned char *source_alpha = 0 ; | |
476 | unsigned char *target_alpha = 0 ; | |
e9b64c5e | 477 | |
1fc1e6af | 478 | if ( !M_IMGDATA->m_hasMask ) |
07aaa1a4 RR |
479 | { |
480 | source_alpha = M_IMGDATA->m_alpha ; | |
481 | if ( source_alpha ) | |
482 | { | |
483 | image.SetAlpha() ; | |
484 | target_alpha = image.GetAlpha() ; | |
485 | } | |
8d3b6b8a | 486 | } |
c7abc967 | 487 | |
07aaa1a4 RR |
488 | long x_delta = (old_width<<16) / width; |
489 | long y_delta = (old_height<<16) / height; | |
c7abc967 | 490 | |
07aaa1a4 | 491 | unsigned char* dest_pixel = target_data; |
6721fc38 | 492 | |
07aaa1a4 RR |
493 | long y = 0; |
494 | for ( long j = 0; j < height; j++ ) | |
ff865c13 | 495 | { |
07aaa1a4 RR |
496 | unsigned char* src_line = &source_data[(y>>16)*old_width*3]; |
497 | unsigned char* src_alpha_line = source_alpha ? &source_alpha[(y>>16)*old_width] : 0 ; | |
e9b64c5e | 498 | |
07aaa1a4 RR |
499 | long x = 0; |
500 | for ( long i = 0; i < width; i++ ) | |
501 | { | |
502 | unsigned char* src_pixel = &src_line[(x>>16)*3]; | |
503 | unsigned char* src_alpha_pixel = source_alpha ? &src_alpha_line[(x>>16)] : 0 ; | |
504 | dest_pixel[0] = src_pixel[0]; | |
505 | dest_pixel[1] = src_pixel[1]; | |
506 | dest_pixel[2] = src_pixel[2]; | |
507 | dest_pixel += 3; | |
508 | if ( source_alpha ) | |
509 | *(target_alpha++) = *src_alpha_pixel ; | |
510 | x += x_delta; | |
511 | } | |
ff865c13 | 512 | |
07aaa1a4 RR |
513 | y += y_delta; |
514 | } | |
eeca3a46 | 515 | } |
36aac195 | 516 | |
1fc1e6af | 517 | // If the original image has a mask, apply the mask to the new image |
e8a8d0dc | 518 | if (M_IMGDATA->m_hasMask) |
1fc1e6af RR |
519 | { |
520 | image.SetMaskColour( M_IMGDATA->m_maskRed, | |
521 | M_IMGDATA->m_maskGreen, | |
522 | M_IMGDATA->m_maskBlue ); | |
523 | } | |
524 | ||
8180d40b | 525 | // In case this is a cursor, make sure the hotspot is scaled accordingly: |
fd94e8aa VS |
526 | if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) ) |
527 | image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, | |
528 | (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width); | |
529 | if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) ) | |
530 | image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, | |
531 | (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y)*height)/old_height); | |
c7abc967 | 532 | |
4bc67cc5 RR |
533 | return image; |
534 | } | |
4698648f | 535 | |
07aaa1a4 RR |
536 | wxImage wxImage::ResampleBox(int width, int height) const |
537 | { | |
30f27c00 VZ |
538 | // This function implements a simple pre-blur/box averaging method for |
539 | // downsampling that gives reasonably smooth results To scale the image | |
540 | // down we will need to gather a grid of pixels of the size of the scale | |
541 | // factor in each direction and then do an averaging of the pixels. | |
07aaa1a4 RR |
542 | |
543 | wxImage ret_image(width, height, false); | |
544 | ||
30f27c00 VZ |
545 | const double scale_factor_x = double(M_IMGDATA->m_width) / width; |
546 | const double scale_factor_y = double(M_IMGDATA->m_height) / height; | |
547 | ||
548 | const int scale_factor_x_2 = (int)(scale_factor_x / 2); | |
549 | const int scale_factor_y_2 = (int)(scale_factor_y / 2); | |
07aaa1a4 | 550 | |
c7a284c7 VZ |
551 | unsigned char* src_data = M_IMGDATA->m_data; |
552 | unsigned char* src_alpha = M_IMGDATA->m_alpha; | |
07aaa1a4 RR |
553 | unsigned char* dst_data = ret_image.GetData(); |
554 | unsigned char* dst_alpha = NULL; | |
555 | ||
30f27c00 | 556 | if ( src_alpha ) |
07aaa1a4 RR |
557 | { |
558 | ret_image.SetAlpha(); | |
559 | dst_alpha = ret_image.GetAlpha(); | |
560 | } | |
561 | ||
30f27c00 | 562 | int averaged_pixels, src_pixel_index; |
07aaa1a4 RR |
563 | double sum_r, sum_g, sum_b, sum_a; |
564 | ||
30f27c00 | 565 | for ( int y = 0; y < height; y++ ) // Destination image - Y direction |
07aaa1a4 RR |
566 | { |
567 | // Source pixel in the Y direction | |
30f27c00 | 568 | int src_y = (int)(y * scale_factor_y); |
07aaa1a4 | 569 | |
30f27c00 | 570 | for ( int x = 0; x < width; x++ ) // Destination image - X direction |
07aaa1a4 RR |
571 | { |
572 | // Source pixel in the X direction | |
30f27c00 | 573 | int src_x = (int)(x * scale_factor_x); |
07aaa1a4 RR |
574 | |
575 | // Box of pixels to average | |
576 | averaged_pixels = 0; | |
577 | sum_r = sum_g = sum_b = sum_a = 0.0; | |
578 | ||
e8a8d0dc | 579 | for ( int j = int(src_y - scale_factor_y/2.0 + 1); |
30f27c00 VZ |
580 | j <= int(src_y + scale_factor_y_2); |
581 | j++ ) | |
07aaa1a4 RR |
582 | { |
583 | // We don't care to average pixels that don't exist (edges) | |
c7a284c7 | 584 | if ( j < 0 || j > M_IMGDATA->m_height - 1 ) |
07aaa1a4 RR |
585 | continue; |
586 | ||
e8a8d0dc | 587 | for ( int i = int(src_x - scale_factor_x/2.0 + 1); |
30f27c00 VZ |
588 | i <= src_x + scale_factor_x_2; |
589 | i++ ) | |
07aaa1a4 RR |
590 | { |
591 | // Don't average edge pixels | |
c7a284c7 | 592 | if ( i < 0 || i > M_IMGDATA->m_width - 1 ) |
07aaa1a4 RR |
593 | continue; |
594 | ||
595 | // Calculate the actual index in our source pixels | |
c7a284c7 | 596 | src_pixel_index = j * M_IMGDATA->m_width + i; |
07aaa1a4 RR |
597 | |
598 | sum_r += src_data[src_pixel_index * 3 + 0]; | |
599 | sum_g += src_data[src_pixel_index * 3 + 1]; | |
600 | sum_b += src_data[src_pixel_index * 3 + 2]; | |
30f27c00 | 601 | if ( src_alpha ) |
07aaa1a4 RR |
602 | sum_a += src_alpha[src_pixel_index]; |
603 | ||
604 | averaged_pixels++; | |
605 | } | |
606 | } | |
607 | ||
608 | // Calculate the average from the sum and number of averaged pixels | |
30f27c00 VZ |
609 | dst_data[0] = (unsigned char)(sum_r / averaged_pixels); |
610 | dst_data[1] = (unsigned char)(sum_g / averaged_pixels); | |
611 | dst_data[2] = (unsigned char)(sum_b / averaged_pixels); | |
07aaa1a4 | 612 | dst_data += 3; |
30f27c00 VZ |
613 | if ( src_alpha ) |
614 | *dst_alpha++ = (unsigned char)(sum_a / averaged_pixels); | |
07aaa1a4 RR |
615 | } |
616 | } | |
617 | ||
618 | return ret_image; | |
619 | } | |
620 | ||
30f27c00 VZ |
621 | // The following two local functions are for the B-spline weighting of the |
622 | // bicubic sampling algorithm | |
07aaa1a4 RR |
623 | static inline double spline_cube(double value) |
624 | { | |
625 | return value <= 0.0 ? 0.0 : value * value * value; | |
626 | } | |
627 | ||
628 | static inline double spline_weight(double value) | |
629 | { | |
30f27c00 VZ |
630 | return (spline_cube(value + 2) - |
631 | 4 * spline_cube(value + 1) + | |
632 | 6 * spline_cube(value) - | |
633 | 4 * spline_cube(value - 1)) / 6; | |
07aaa1a4 RR |
634 | } |
635 | ||
636 | // This is the bicubic resampling algorithm | |
637 | wxImage wxImage::ResampleBicubic(int width, int height) const | |
638 | { | |
30f27c00 VZ |
639 | // This function implements a Bicubic B-Spline algorithm for resampling. |
640 | // This method is certainly a little slower than wxImage's default pixel | |
641 | // replication method, however for most reasonably sized images not being | |
642 | // upsampled too much on a fairly average CPU this difference is hardly | |
643 | // noticeable and the results are far more pleasing to look at. | |
07aaa1a4 | 644 | // |
30f27c00 VZ |
645 | // This particular bicubic algorithm does pixel weighting according to a |
646 | // B-Spline that basically implements a Gaussian bell-like weighting | |
647 | // kernel. Because of this method the results may appear a bit blurry when | |
648 | // upsampling by large factors. This is basically because a slight | |
649 | // gaussian blur is being performed to get the smooth look of the upsampled | |
650 | // image. | |
07aaa1a4 RR |
651 | |
652 | // Edge pixels: 3-4 possible solutions | |
30f27c00 VZ |
653 | // - (Wrap/tile) Wrap the image, take the color value from the opposite |
654 | // side of the image. | |
655 | // - (Mirror) Duplicate edge pixels, so that pixel at coordinate (2, n), | |
656 | // where n is nonpositive, will have the value of (2, 1). | |
657 | // - (Ignore) Simply ignore the edge pixels and apply the kernel only to | |
658 | // pixels which do have all neighbours. | |
659 | // - (Clamp) Choose the nearest pixel along the border. This takes the | |
660 | // border pixels and extends them out to infinity. | |
07aaa1a4 | 661 | // |
30f27c00 VZ |
662 | // NOTE: below the y_offset and x_offset variables are being set for edge |
663 | // pixels using the "Mirror" method mentioned above | |
07aaa1a4 RR |
664 | |
665 | wxImage ret_image; | |
666 | ||
667 | ret_image.Create(width, height, false); | |
668 | ||
669 | unsigned char* src_data = M_IMGDATA->m_data; | |
670 | unsigned char* src_alpha = M_IMGDATA->m_alpha; | |
671 | unsigned char* dst_data = ret_image.GetData(); | |
672 | unsigned char* dst_alpha = NULL; | |
673 | ||
30f27c00 | 674 | if ( src_alpha ) |
07aaa1a4 RR |
675 | { |
676 | ret_image.SetAlpha(); | |
677 | dst_alpha = ret_image.GetAlpha(); | |
678 | } | |
679 | ||
30f27c00 | 680 | for ( int dsty = 0; dsty < height; dsty++ ) |
07aaa1a4 RR |
681 | { |
682 | // We need to calculate the source pixel to interpolate from - Y-axis | |
993f0845 | 683 | double srcpixy = double(dsty * M_IMGDATA->m_height) / height; |
30f27c00 | 684 | double dy = srcpixy - (int)srcpixy; |
07aaa1a4 | 685 | |
30f27c00 | 686 | for ( int dstx = 0; dstx < width; dstx++ ) |
07aaa1a4 RR |
687 | { |
688 | // X-axis of pixel to interpolate from | |
993f0845 | 689 | double srcpixx = double(dstx * M_IMGDATA->m_width) / width; |
30f27c00 | 690 | double dx = srcpixx - (int)srcpixx; |
07aaa1a4 | 691 | |
30f27c00 VZ |
692 | // Sums for each color channel |
693 | double sum_r = 0, sum_g = 0, sum_b = 0, sum_a = 0; | |
07aaa1a4 RR |
694 | |
695 | // Here we actually determine the RGBA values for the destination pixel | |
30f27c00 | 696 | for ( int k = -1; k <= 2; k++ ) |
07aaa1a4 RR |
697 | { |
698 | // Y offset | |
30f27c00 VZ |
699 | int y_offset = srcpixy + k < 0.0 |
700 | ? 0 | |
701 | : srcpixy + k >= M_IMGDATA->m_height | |
702 | ? M_IMGDATA->m_height - 1 | |
703 | : (int)(srcpixy + k); | |
07aaa1a4 RR |
704 | |
705 | // Loop across the X axis | |
30f27c00 | 706 | for ( int i = -1; i <= 2; i++ ) |
07aaa1a4 RR |
707 | { |
708 | // X offset | |
30f27c00 VZ |
709 | int x_offset = srcpixx + i < 0.0 |
710 | ? 0 | |
711 | : srcpixx + i >= M_IMGDATA->m_width | |
712 | ? M_IMGDATA->m_width - 1 | |
713 | : (int)(srcpixx + i); | |
714 | ||
715 | // Calculate the exact position where the source data | |
716 | // should be pulled from based on the x_offset and y_offset | |
717 | int src_pixel_index = y_offset*M_IMGDATA->m_width + x_offset; | |
718 | ||
719 | // Calculate the weight for the specified pixel according | |
720 | // to the bicubic b-spline kernel we're using for | |
721 | // interpolation | |
722 | double | |
723 | pixel_weight = spline_weight(i - dx)*spline_weight(k - dy); | |
724 | ||
725 | // Create a sum of all velues for each color channel | |
726 | // adjusted for the pixel's calculated weight | |
727 | sum_r += src_data[src_pixel_index * 3 + 0] * pixel_weight; | |
728 | sum_g += src_data[src_pixel_index * 3 + 1] * pixel_weight; | |
729 | sum_b += src_data[src_pixel_index * 3 + 2] * pixel_weight; | |
730 | if ( src_alpha ) | |
731 | sum_a += src_alpha[src_pixel_index] * pixel_weight; | |
07aaa1a4 RR |
732 | } |
733 | } | |
734 | ||
30f27c00 VZ |
735 | // Put the data into the destination image. The summed values are |
736 | // of double data type and are rounded here for accuracy | |
737 | dst_data[0] = (unsigned char)(sum_r + 0.5); | |
738 | dst_data[1] = (unsigned char)(sum_g + 0.5); | |
739 | dst_data[2] = (unsigned char)(sum_b + 0.5); | |
07aaa1a4 RR |
740 | dst_data += 3; |
741 | ||
30f27c00 VZ |
742 | if ( src_alpha ) |
743 | *dst_alpha++ = (unsigned char)sum_a; | |
07aaa1a4 RR |
744 | } |
745 | } | |
746 | ||
747 | return ret_image; | |
748 | } | |
749 | ||
750 | // Blur in the horizontal direction | |
24904055 | 751 | wxImage wxImage::BlurHorizontal(int blurRadius) const |
07aaa1a4 RR |
752 | { |
753 | wxImage ret_image; | |
754 | ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false); | |
755 | ||
756 | unsigned char* src_data = M_IMGDATA->m_data; | |
757 | unsigned char* dst_data = ret_image.GetData(); | |
758 | unsigned char* src_alpha = M_IMGDATA->m_alpha; | |
759 | unsigned char* dst_alpha = NULL; | |
760 | ||
761 | // Check for a mask or alpha | |
641ed513 VZ |
762 | if ( src_alpha ) |
763 | { | |
764 | ret_image.SetAlpha(); | |
765 | dst_alpha = ret_image.GetAlpha(); | |
766 | } | |
767 | else if ( M_IMGDATA->m_hasMask ) | |
30f27c00 VZ |
768 | { |
769 | ret_image.SetMaskColour(M_IMGDATA->m_maskRed, | |
770 | M_IMGDATA->m_maskGreen, | |
771 | M_IMGDATA->m_maskBlue); | |
772 | } | |
07aaa1a4 | 773 | |
30f27c00 VZ |
774 | // number of pixels we average over |
775 | const int blurArea = blurRadius*2 + 1; | |
07aaa1a4 | 776 | |
30f27c00 VZ |
777 | // Horizontal blurring algorithm - average all pixels in the specified blur |
778 | // radius in the X or horizontal direction | |
779 | for ( int y = 0; y < M_IMGDATA->m_height; y++ ) | |
07aaa1a4 | 780 | { |
30f27c00 VZ |
781 | // Variables used in the blurring algorithm |
782 | long sum_r = 0, | |
783 | sum_g = 0, | |
784 | sum_b = 0, | |
785 | sum_a = 0; | |
786 | ||
787 | long pixel_idx; | |
788 | const unsigned char *src; | |
789 | unsigned char *dst; | |
790 | ||
791 | // Calculate the average of all pixels in the blur radius for the first | |
792 | // pixel of the row | |
793 | for ( int kernel_x = -blurRadius; kernel_x <= blurRadius; kernel_x++ ) | |
07aaa1a4 | 794 | { |
30f27c00 VZ |
795 | // To deal with the pixels at the start of a row so it's not |
796 | // grabbing GOK values from memory at negative indices of the | |
797 | // image's data or grabbing from the previous row | |
798 | if ( kernel_x < 0 ) | |
07aaa1a4 RR |
799 | pixel_idx = y * M_IMGDATA->m_width; |
800 | else | |
801 | pixel_idx = kernel_x + y * M_IMGDATA->m_width; | |
802 | ||
30f27c00 VZ |
803 | src = src_data + pixel_idx*3; |
804 | sum_r += src[0]; | |
805 | sum_g += src[1]; | |
806 | sum_b += src[2]; | |
807 | if ( src_alpha ) | |
808 | sum_a += src_alpha[pixel_idx]; | |
07aaa1a4 | 809 | } |
30f27c00 VZ |
810 | |
811 | dst = dst_data + y * M_IMGDATA->m_width*3; | |
88835522 WS |
812 | dst[0] = (unsigned char)(sum_r / blurArea); |
813 | dst[1] = (unsigned char)(sum_g / blurArea); | |
814 | dst[2] = (unsigned char)(sum_b / blurArea); | |
30f27c00 | 815 | if ( src_alpha ) |
88835522 | 816 | dst_alpha[y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea); |
30f27c00 VZ |
817 | |
818 | // Now average the values of the rest of the pixels by just moving the | |
819 | // blur radius box along the row | |
820 | for ( int x = 1; x < M_IMGDATA->m_width; x++ ) | |
07aaa1a4 | 821 | { |
30f27c00 VZ |
822 | // Take care of edge pixels on the left edge by essentially |
823 | // duplicating the edge pixel | |
824 | if ( x - blurRadius - 1 < 0 ) | |
07aaa1a4 RR |
825 | pixel_idx = y * M_IMGDATA->m_width; |
826 | else | |
827 | pixel_idx = (x - blurRadius - 1) + y * M_IMGDATA->m_width; | |
828 | ||
30f27c00 VZ |
829 | // Subtract the value of the pixel at the left side of the blur |
830 | // radius box | |
831 | src = src_data + pixel_idx*3; | |
832 | sum_r -= src[0]; | |
833 | sum_g -= src[1]; | |
834 | sum_b -= src[2]; | |
835 | if ( src_alpha ) | |
836 | sum_a -= src_alpha[pixel_idx]; | |
07aaa1a4 RR |
837 | |
838 | // Take care of edge pixels on the right edge | |
30f27c00 | 839 | if ( x + blurRadius > M_IMGDATA->m_width - 1 ) |
07aaa1a4 RR |
840 | pixel_idx = M_IMGDATA->m_width - 1 + y * M_IMGDATA->m_width; |
841 | else | |
842 | pixel_idx = x + blurRadius + y * M_IMGDATA->m_width; | |
843 | ||
844 | // Add the value of the pixel being added to the end of our box | |
30f27c00 VZ |
845 | src = src_data + pixel_idx*3; |
846 | sum_r += src[0]; | |
847 | sum_g += src[1]; | |
848 | sum_b += src[2]; | |
849 | if ( src_alpha ) | |
850 | sum_a += src_alpha[pixel_idx]; | |
07aaa1a4 RR |
851 | |
852 | // Save off the averaged data | |
e8a8d0dc | 853 | dst = dst_data + x*3 + y*M_IMGDATA->m_width*3; |
88835522 WS |
854 | dst[0] = (unsigned char)(sum_r / blurArea); |
855 | dst[1] = (unsigned char)(sum_g / blurArea); | |
856 | dst[2] = (unsigned char)(sum_b / blurArea); | |
30f27c00 | 857 | if ( src_alpha ) |
88835522 | 858 | dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea); |
07aaa1a4 RR |
859 | } |
860 | } | |
861 | ||
862 | return ret_image; | |
863 | } | |
864 | ||
865 | // Blur in the vertical direction | |
24904055 | 866 | wxImage wxImage::BlurVertical(int blurRadius) const |
07aaa1a4 RR |
867 | { |
868 | wxImage ret_image; | |
869 | ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false); | |
870 | ||
871 | unsigned char* src_data = M_IMGDATA->m_data; | |
872 | unsigned char* dst_data = ret_image.GetData(); | |
873 | unsigned char* src_alpha = M_IMGDATA->m_alpha; | |
874 | unsigned char* dst_alpha = NULL; | |
875 | ||
876 | // Check for a mask or alpha | |
641ed513 VZ |
877 | if ( src_alpha ) |
878 | { | |
879 | ret_image.SetAlpha(); | |
880 | dst_alpha = ret_image.GetAlpha(); | |
881 | } | |
882 | else if ( M_IMGDATA->m_hasMask ) | |
30f27c00 VZ |
883 | { |
884 | ret_image.SetMaskColour(M_IMGDATA->m_maskRed, | |
885 | M_IMGDATA->m_maskGreen, | |
886 | M_IMGDATA->m_maskBlue); | |
887 | } | |
07aaa1a4 | 888 | |
30f27c00 VZ |
889 | // number of pixels we average over |
890 | const int blurArea = blurRadius*2 + 1; | |
07aaa1a4 | 891 | |
30f27c00 VZ |
892 | // Vertical blurring algorithm - same as horizontal but switched the |
893 | // opposite direction | |
894 | for ( int x = 0; x < M_IMGDATA->m_width; x++ ) | |
07aaa1a4 | 895 | { |
30f27c00 VZ |
896 | // Variables used in the blurring algorithm |
897 | long sum_r = 0, | |
898 | sum_g = 0, | |
899 | sum_b = 0, | |
900 | sum_a = 0; | |
901 | ||
902 | long pixel_idx; | |
903 | const unsigned char *src; | |
904 | unsigned char *dst; | |
905 | ||
906 | // Calculate the average of all pixels in our blur radius box for the | |
907 | // first pixel of the column | |
908 | for ( int kernel_y = -blurRadius; kernel_y <= blurRadius; kernel_y++ ) | |
07aaa1a4 | 909 | { |
30f27c00 VZ |
910 | // To deal with the pixels at the start of a column so it's not |
911 | // grabbing GOK values from memory at negative indices of the | |
912 | // image's data or grabbing from the previous column | |
913 | if ( kernel_y < 0 ) | |
07aaa1a4 RR |
914 | pixel_idx = x; |
915 | else | |
916 | pixel_idx = x + kernel_y * M_IMGDATA->m_width; | |
917 | ||
30f27c00 VZ |
918 | src = src_data + pixel_idx*3; |
919 | sum_r += src[0]; | |
920 | sum_g += src[1]; | |
921 | sum_b += src[2]; | |
922 | if ( src_alpha ) | |
923 | sum_a += src_alpha[pixel_idx]; | |
07aaa1a4 | 924 | } |
30f27c00 VZ |
925 | |
926 | dst = dst_data + x*3; | |
88835522 WS |
927 | dst[0] = (unsigned char)(sum_r / blurArea); |
928 | dst[1] = (unsigned char)(sum_g / blurArea); | |
929 | dst[2] = (unsigned char)(sum_b / blurArea); | |
30f27c00 | 930 | if ( src_alpha ) |
88835522 | 931 | dst_alpha[x] = (unsigned char)(sum_a / blurArea); |
30f27c00 VZ |
932 | |
933 | // Now average the values of the rest of the pixels by just moving the | |
934 | // box along the column from top to bottom | |
935 | for ( int y = 1; y < M_IMGDATA->m_height; y++ ) | |
07aaa1a4 | 936 | { |
30f27c00 VZ |
937 | // Take care of pixels that would be beyond the top edge by |
938 | // duplicating the top edge pixel for the column | |
939 | if ( y - blurRadius - 1 < 0 ) | |
07aaa1a4 RR |
940 | pixel_idx = x; |
941 | else | |
942 | pixel_idx = x + (y - blurRadius - 1) * M_IMGDATA->m_width; | |
943 | ||
944 | // Subtract the value of the pixel at the top of our blur radius box | |
30f27c00 VZ |
945 | src = src_data + pixel_idx*3; |
946 | sum_r -= src[0]; | |
947 | sum_g -= src[1]; | |
948 | sum_b -= src[2]; | |
949 | if ( src_alpha ) | |
950 | sum_a -= src_alpha[pixel_idx]; | |
951 | ||
952 | // Take care of the pixels that would be beyond the bottom edge of | |
953 | // the image similar to the top edge | |
954 | if ( y + blurRadius > M_IMGDATA->m_height - 1 ) | |
07aaa1a4 RR |
955 | pixel_idx = x + (M_IMGDATA->m_height - 1) * M_IMGDATA->m_width; |
956 | else | |
957 | pixel_idx = x + (blurRadius + y) * M_IMGDATA->m_width; | |
958 | ||
959 | // Add the value of the pixel being added to the end of our box | |
30f27c00 VZ |
960 | src = src_data + pixel_idx*3; |
961 | sum_r += src[0]; | |
962 | sum_g += src[1]; | |
963 | sum_b += src[2]; | |
964 | if ( src_alpha ) | |
965 | sum_a += src_alpha[pixel_idx]; | |
07aaa1a4 RR |
966 | |
967 | // Save off the averaged data | |
30f27c00 | 968 | dst = dst_data + (x + y * M_IMGDATA->m_width) * 3; |
88835522 WS |
969 | dst[0] = (unsigned char)(sum_r / blurArea); |
970 | dst[1] = (unsigned char)(sum_g / blurArea); | |
971 | dst[2] = (unsigned char)(sum_b / blurArea); | |
30f27c00 | 972 | if ( src_alpha ) |
88835522 | 973 | dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea); |
07aaa1a4 RR |
974 | } |
975 | } | |
976 | ||
977 | return ret_image; | |
978 | } | |
979 | ||
980 | // The new blur function | |
24904055 | 981 | wxImage wxImage::Blur(int blurRadius) const |
07aaa1a4 RR |
982 | { |
983 | wxImage ret_image; | |
984 | ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false); | |
985 | ||
986 | // Blur the image in each direction | |
987 | ret_image = BlurHorizontal(blurRadius); | |
988 | ret_image = ret_image.BlurVertical(blurRadius); | |
989 | ||
990 | return ret_image; | |
991 | } | |
992 | ||
f6bcfd97 BP |
993 | wxImage wxImage::Rotate90( bool clockwise ) const |
994 | { | |
995 | wxImage image; | |
996 | ||
997 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
998 | ||
ff865c13 | 999 | image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width, false ); |
f6bcfd97 | 1000 | |
487659e0 | 1001 | unsigned char *data = image.GetData(); |
f6bcfd97 BP |
1002 | |
1003 | wxCHECK_MSG( data, image, wxT("unable to create image") ); | |
1004 | ||
921c65ed JS |
1005 | unsigned char *source_data = M_IMGDATA->m_data; |
1006 | unsigned char *target_data; | |
1007 | unsigned char *alpha_data = 0 ; | |
1008 | unsigned char *source_alpha = 0 ; | |
1009 | unsigned char *target_alpha = 0 ; | |
1010 | ||
f6bcfd97 | 1011 | if (M_IMGDATA->m_hasMask) |
921c65ed | 1012 | { |
f6bcfd97 | 1013 | image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue ); |
921c65ed JS |
1014 | } |
1015 | else | |
1016 | { | |
1017 | source_alpha = M_IMGDATA->m_alpha ; | |
1018 | if ( source_alpha ) | |
1019 | { | |
1020 | image.SetAlpha() ; | |
1021 | alpha_data = image.GetAlpha() ; | |
1022 | } | |
1023 | } | |
f6bcfd97 BP |
1024 | |
1025 | long height = M_IMGDATA->m_height; | |
1026 | long width = M_IMGDATA->m_width; | |
1027 | ||
f6bcfd97 BP |
1028 | for (long j = 0; j < height; j++) |
1029 | { | |
1030 | for (long i = 0; i < width; i++) | |
1031 | { | |
1032 | if (clockwise) | |
921c65ed | 1033 | { |
f6bcfd97 | 1034 | target_data = data + (((i+1)*height) - j - 1)*3; |
921c65ed JS |
1035 | if(source_alpha) |
1036 | target_alpha = alpha_data + (((i+1)*height) - j - 1); | |
1037 | } | |
f6bcfd97 | 1038 | else |
921c65ed | 1039 | { |
f6bcfd97 | 1040 | target_data = data + ((height*(width-1)) + j - (i*height))*3; |
921c65ed JS |
1041 | if(source_alpha) |
1042 | target_alpha = alpha_data + ((height*(width-1)) + j - (i*height)); | |
1043 | } | |
f6bcfd97 BP |
1044 | memcpy( target_data, source_data, 3 ); |
1045 | source_data += 3; | |
921c65ed JS |
1046 | |
1047 | if(source_alpha) | |
1048 | { | |
1049 | memcpy( target_alpha, source_alpha, 1 ); | |
1050 | source_alpha += 1; | |
1051 | } | |
f6bcfd97 BP |
1052 | } |
1053 | } | |
1054 | ||
1055 | return image; | |
1056 | } | |
1057 | ||
1058 | wxImage wxImage::Mirror( bool horizontally ) const | |
1059 | { | |
1060 | wxImage image; | |
1061 | ||
1062 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
1063 | ||
ff865c13 | 1064 | image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false ); |
f6bcfd97 | 1065 | |
487659e0 | 1066 | unsigned char *data = image.GetData(); |
051924b8 | 1067 | unsigned char *alpha = NULL; |
f6bcfd97 BP |
1068 | |
1069 | wxCHECK_MSG( data, image, wxT("unable to create image") ); | |
1070 | ||
051924b8 VZ |
1071 | if (M_IMGDATA->m_alpha != NULL) { |
1072 | image.SetAlpha(); | |
1073 | alpha = image.GetAlpha(); | |
1074 | wxCHECK_MSG( alpha, image, wxT("unable to create alpha channel") ); | |
1075 | } | |
1076 | ||
f6bcfd97 BP |
1077 | if (M_IMGDATA->m_hasMask) |
1078 | image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue ); | |
1079 | ||
1080 | long height = M_IMGDATA->m_height; | |
1081 | long width = M_IMGDATA->m_width; | |
1082 | ||
487659e0 VZ |
1083 | unsigned char *source_data = M_IMGDATA->m_data; |
1084 | unsigned char *target_data; | |
f6bcfd97 BP |
1085 | |
1086 | if (horizontally) | |
1087 | { | |
1088 | for (long j = 0; j < height; j++) | |
1089 | { | |
1090 | data += width*3; | |
1091 | target_data = data-3; | |
1092 | for (long i = 0; i < width; i++) | |
1093 | { | |
1094 | memcpy( target_data, source_data, 3 ); | |
1095 | source_data += 3; | |
1096 | target_data -= 3; | |
1097 | } | |
1098 | } | |
051924b8 VZ |
1099 | |
1100 | if (alpha != NULL) | |
1101 | { | |
1102 | // src_alpha starts at the first pixel and increases by 1 after each step | |
1103 | // (a step here is the copy of the alpha value of one pixel) | |
1104 | const unsigned char *src_alpha = M_IMGDATA->m_alpha; | |
1105 | // dest_alpha starts just beyond the first line, decreases before each step, | |
1106 | // and after each line is finished, increases by 2 widths (skipping the line | |
1107 | // just copied and the line that will be copied next) | |
1108 | unsigned char *dest_alpha = alpha + width; | |
1109 | ||
1110 | for (long jj = 0; jj < height; ++jj) | |
1111 | { | |
1112 | for (long i = 0; i < width; ++i) { | |
1113 | *(--dest_alpha) = *(src_alpha++); // copy one pixel | |
1114 | } | |
1115 | dest_alpha += 2 * width; // advance beyond the end of the next line | |
1116 | } | |
1117 | } | |
f6bcfd97 BP |
1118 | } |
1119 | else | |
1120 | { | |
1121 | for (long i = 0; i < height; i++) | |
1122 | { | |
1123 | target_data = data + 3*width*(height-1-i); | |
3ca6a5f0 | 1124 | memcpy( target_data, source_data, (size_t)3*width ); |
f6bcfd97 BP |
1125 | source_data += 3*width; |
1126 | } | |
051924b8 VZ |
1127 | |
1128 | if (alpha != NULL) | |
1129 | { | |
1130 | // src_alpha starts at the first pixel and increases by 1 width after each step | |
1131 | // (a step here is the copy of the alpha channel of an entire line) | |
1132 | const unsigned char *src_alpha = M_IMGDATA->m_alpha; | |
1133 | // dest_alpha starts just beyond the last line (beyond the whole image) | |
1134 | // and decreases by 1 width before each step | |
1135 | unsigned char *dest_alpha = alpha + width * height; | |
1136 | ||
1137 | for (long jj = 0; jj < height; ++jj) | |
1138 | { | |
1139 | dest_alpha -= width; | |
1140 | memcpy( dest_alpha, src_alpha, (size_t)width ); | |
1141 | src_alpha += width; | |
1142 | } | |
1143 | } | |
f6bcfd97 BP |
1144 | } |
1145 | ||
1146 | return image; | |
1147 | } | |
1148 | ||
7b2471a0 SB |
1149 | wxImage wxImage::GetSubImage( const wxRect &rect ) const |
1150 | { | |
1151 | wxImage image; | |
1152 | ||
223d09f6 | 1153 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); |
7b2471a0 | 1154 | |
051924b8 VZ |
1155 | wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && |
1156 | (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()), | |
58c837a4 | 1157 | image, wxT("invalid subimage size") ); |
7b2471a0 | 1158 | |
051924b8 VZ |
1159 | const int subwidth = rect.GetWidth(); |
1160 | const int subheight = rect.GetHeight(); | |
7b2471a0 | 1161 | |
ff865c13 | 1162 | image.Create( subwidth, subheight, false ); |
7b2471a0 | 1163 | |
051924b8 VZ |
1164 | const unsigned char *src_data = GetData(); |
1165 | const unsigned char *src_alpha = M_IMGDATA->m_alpha; | |
1166 | unsigned char *subdata = image.GetData(); | |
1167 | unsigned char *subalpha = NULL; | |
7b2471a0 | 1168 | |
223d09f6 | 1169 | wxCHECK_MSG( subdata, image, wxT("unable to create image") ); |
7b2471a0 | 1170 | |
051924b8 VZ |
1171 | if (src_alpha != NULL) { |
1172 | image.SetAlpha(); | |
1173 | subalpha = image.GetAlpha(); | |
1174 | wxCHECK_MSG( subalpha, image, wxT("unable to create alpha channel")); | |
1175 | } | |
1176 | ||
7b2471a0 SB |
1177 | if (M_IMGDATA->m_hasMask) |
1178 | image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue ); | |
1179 | ||
051924b8 VZ |
1180 | const int width = GetWidth(); |
1181 | const int pixsoff = rect.GetLeft() + width * rect.GetTop(); | |
995612e2 | 1182 | |
051924b8 VZ |
1183 | src_data += 3 * pixsoff; |
1184 | src_alpha += pixsoff; // won't be used if was NULL, so this is ok | |
7b2471a0 SB |
1185 | |
1186 | for (long j = 0; j < subheight; ++j) | |
1187 | { | |
051924b8 VZ |
1188 | memcpy( subdata, src_data, 3 * subwidth ); |
1189 | subdata += 3 * subwidth; | |
1190 | src_data += 3 * width; | |
1191 | if (subalpha != NULL) { | |
1192 | memcpy( subalpha, src_alpha, subwidth ); | |
1193 | subalpha += subwidth; | |
1194 | src_alpha += width; | |
1195 | } | |
7b2471a0 SB |
1196 | } |
1197 | ||
1198 | return image; | |
1199 | } | |
1200 | ||
e9b64c5e | 1201 | wxImage wxImage::Size( const wxSize& size, const wxPoint& pos, |
b737ad10 RR |
1202 | int r_, int g_, int b_ ) const |
1203 | { | |
1204 | wxImage image; | |
1205 | ||
1206 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
1207 | wxCHECK_MSG( (size.GetWidth() > 0) && (size.GetHeight() > 0), image, wxT("invalid size") ); | |
1208 | ||
1209 | int width = GetWidth(), height = GetHeight(); | |
1210 | image.Create(size.GetWidth(), size.GetHeight(), false); | |
1211 | ||
1212 | unsigned char r = (unsigned char)r_; | |
1213 | unsigned char g = (unsigned char)g_; | |
1214 | unsigned char b = (unsigned char)b_; | |
1215 | if ((r_ == -1) && (g_ == -1) && (b_ == -1)) | |
1216 | { | |
1217 | GetOrFindMaskColour( &r, &g, &b ); | |
1218 | image.SetMaskColour(r, g, b); | |
1219 | } | |
1220 | ||
1221 | image.SetRGB(wxRect(), r, g, b); | |
1222 | ||
1223 | wxRect subRect(pos.x, pos.y, width, height); | |
1224 | wxRect finalRect(0, 0, size.GetWidth(), size.GetHeight()); | |
781945ea RR |
1225 | if (pos.x < 0) |
1226 | finalRect.width -= pos.x; | |
1227 | if (pos.y < 0) | |
1228 | finalRect.height -= pos.y; | |
b737ad10 RR |
1229 | |
1230 | subRect.Intersect(finalRect); | |
1231 | ||
1232 | if (!subRect.IsEmpty()) | |
1233 | { | |
1234 | if ((subRect.GetWidth() == width) && (subRect.GetHeight() == height)) | |
1235 | image.Paste(*this, pos.x, pos.y); | |
1236 | else | |
1237 | image.Paste(GetSubImage(subRect), pos.x, pos.y); | |
1238 | } | |
1239 | ||
1240 | return image; | |
1241 | } | |
1242 | ||
f6bcfd97 BP |
1243 | void wxImage::Paste( const wxImage &image, int x, int y ) |
1244 | { | |
1245 | wxCHECK_RET( Ok(), wxT("invalid image") ); | |
1246 | wxCHECK_RET( image.Ok(), wxT("invalid image") ); | |
1247 | ||
a0f81e9f PC |
1248 | AllocExclusive(); |
1249 | ||
f6bcfd97 BP |
1250 | int xx = 0; |
1251 | int yy = 0; | |
1252 | int width = image.GetWidth(); | |
1253 | int height = image.GetHeight(); | |
1254 | ||
1255 | if (x < 0) | |
1256 | { | |
1257 | xx = -x; | |
1258 | width += x; | |
1259 | } | |
1260 | if (y < 0) | |
1261 | { | |
1262 | yy = -y; | |
1263 | height += y; | |
1264 | } | |
1265 | ||
1266 | if ((x+xx)+width > M_IMGDATA->m_width) | |
1267 | width = M_IMGDATA->m_width - (x+xx); | |
1268 | if ((y+yy)+height > M_IMGDATA->m_height) | |
1269 | height = M_IMGDATA->m_height - (y+yy); | |
1270 | ||
1271 | if (width < 1) return; | |
1272 | if (height < 1) return; | |
1273 | ||
1274 | if ((!HasMask() && !image.HasMask()) || | |
b737ad10 | 1275 | (HasMask() && !image.HasMask()) || |
f6bcfd97 BP |
1276 | ((HasMask() && image.HasMask() && |
1277 | (GetMaskRed()==image.GetMaskRed()) && | |
1278 | (GetMaskGreen()==image.GetMaskGreen()) && | |
1279 | (GetMaskBlue()==image.GetMaskBlue())))) | |
1280 | { | |
f6bcfd97 BP |
1281 | unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth(); |
1282 | int source_step = image.GetWidth()*3; | |
1283 | ||
1284 | unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width; | |
1285 | int target_step = M_IMGDATA->m_width*3; | |
1286 | for (int j = 0; j < height; j++) | |
1287 | { | |
85f81873 | 1288 | memcpy( target_data, source_data, width*3 ); |
f6bcfd97 BP |
1289 | source_data += source_step; |
1290 | target_data += target_step; | |
1291 | } | |
1292 | } | |
33ac7e6f | 1293 | |
14678d6d VZ |
1294 | // Copy over the alpha channel from the original image |
1295 | if ( image.HasAlpha() ) | |
1296 | { | |
1297 | if ( !HasAlpha() ) | |
1298 | InitAlpha(); | |
1299 | ||
1300 | unsigned char* source_data = image.GetAlpha() + xx + yy*image.GetWidth(); | |
1301 | int source_step = image.GetWidth(); | |
1302 | ||
1303 | unsigned char* target_data = GetAlpha() + (x+xx) + (y+yy)*M_IMGDATA->m_width; | |
1304 | int target_step = M_IMGDATA->m_width; | |
1305 | ||
1306 | for (int j = 0; j < height; j++, | |
1307 | source_data += source_step, | |
1308 | target_data += target_step) | |
1309 | { | |
1310 | memcpy( target_data, source_data, width ); | |
1311 | } | |
1312 | } | |
1313 | ||
aa21b509 | 1314 | if (!HasMask() && image.HasMask()) |
f6bcfd97 | 1315 | { |
aa21b509 RR |
1316 | unsigned char r = image.GetMaskRed(); |
1317 | unsigned char g = image.GetMaskGreen(); | |
1318 | unsigned char b = image.GetMaskBlue(); | |
33ac7e6f | 1319 | |
aa21b509 RR |
1320 | unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth(); |
1321 | int source_step = image.GetWidth()*3; | |
1322 | ||
1323 | unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width; | |
1324 | int target_step = M_IMGDATA->m_width*3; | |
33ac7e6f | 1325 | |
aa21b509 RR |
1326 | for (int j = 0; j < height; j++) |
1327 | { | |
85f81873 | 1328 | for (int i = 0; i < width*3; i+=3) |
aa21b509 | 1329 | { |
dcc36b34 RR |
1330 | if ((source_data[i] != r) || |
1331 | (source_data[i+1] != g) || | |
aa21b509 RR |
1332 | (source_data[i+2] != b)) |
1333 | { | |
1334 | memcpy( target_data+i, source_data+i, 3 ); | |
1335 | } | |
33ac7e6f | 1336 | } |
aa21b509 RR |
1337 | source_data += source_step; |
1338 | target_data += target_step; | |
1339 | } | |
f6bcfd97 BP |
1340 | } |
1341 | } | |
1342 | ||
be25e480 RR |
1343 | void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1, |
1344 | unsigned char r2, unsigned char g2, unsigned char b2 ) | |
1345 | { | |
1346 | wxCHECK_RET( Ok(), wxT("invalid image") ); | |
1347 | ||
a0f81e9f PC |
1348 | AllocExclusive(); |
1349 | ||
487659e0 | 1350 | unsigned char *data = GetData(); |
06b466c7 | 1351 | |
be25e480 RR |
1352 | const int w = GetWidth(); |
1353 | const int h = GetHeight(); | |
1354 | ||
1355 | for (int j = 0; j < h; j++) | |
1356 | for (int i = 0; i < w; i++) | |
069d0f27 VZ |
1357 | { |
1358 | if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1)) | |
1359 | { | |
1360 | data[0] = r2; | |
1361 | data[1] = g2; | |
1362 | data[2] = b2; | |
1363 | } | |
1364 | data += 3; | |
1365 | } | |
be25e480 RR |
1366 | } |
1367 | ||
ec85956a JS |
1368 | wxImage wxImage::ConvertToGreyscale( double lr, double lg, double lb ) const |
1369 | { | |
1370 | wxImage image; | |
1371 | ||
1372 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
1373 | ||
1374 | image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false); | |
1375 | ||
1376 | unsigned char *dest = image.GetData(); | |
1377 | ||
1378 | wxCHECK_MSG( dest, image, wxT("unable to create image") ); | |
1379 | ||
1380 | unsigned char *src = M_IMGDATA->m_data; | |
1381 | bool hasMask = M_IMGDATA->m_hasMask; | |
1382 | unsigned char maskRed = M_IMGDATA->m_maskRed; | |
1383 | unsigned char maskGreen = M_IMGDATA->m_maskGreen; | |
1384 | unsigned char maskBlue = M_IMGDATA->m_maskBlue; | |
1385 | ||
1386 | if ( hasMask ) | |
1387 | image.SetMaskColour(maskRed, maskGreen, maskBlue); | |
1388 | ||
1389 | const long size = M_IMGDATA->m_width * M_IMGDATA->m_height; | |
1390 | for ( long i = 0; i < size; i++, src += 3, dest += 3 ) | |
1391 | { | |
1392 | // don't modify the mask | |
1393 | if ( hasMask && src[0] == maskRed && src[1] == maskGreen && src[2] == maskBlue ) | |
1394 | { | |
1395 | memcpy(dest, src, 3); | |
1396 | } | |
1397 | else | |
1398 | { | |
1399 | // calculate the luma | |
1400 | double luma = (src[0] * lr + src[1] * lg + src[2] * lb) + 0.5; | |
5c33522f | 1401 | dest[0] = dest[1] = dest[2] = static_cast<unsigned char>(luma); |
ec85956a JS |
1402 | } |
1403 | } | |
1404 | ||
7ce30d0b WS |
1405 | // copy the alpha channel, if any |
1406 | if (HasAlpha()) | |
1407 | { | |
1408 | const size_t alphaSize = GetWidth() * GetHeight(); | |
1409 | unsigned char *alpha = (unsigned char*)malloc(alphaSize); | |
1410 | memcpy(alpha, GetAlpha(), alphaSize); | |
1411 | image.InitAlpha(); | |
1412 | image.SetAlpha(alpha); | |
1413 | } | |
1414 | ||
ec85956a JS |
1415 | return image; |
1416 | } | |
1417 | ||
f515c25a | 1418 | wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const |
fec19ea9 VS |
1419 | { |
1420 | wxImage image; | |
1421 | ||
1422 | wxCHECK_MSG( Ok(), image, wxT("invalid image") ); | |
1423 | ||
ff865c13 | 1424 | image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false ); |
fec19ea9 | 1425 | |
487659e0 | 1426 | unsigned char *data = image.GetData(); |
fec19ea9 VS |
1427 | |
1428 | wxCHECK_MSG( data, image, wxT("unable to create image") ); | |
1429 | ||
1430 | if (M_IMGDATA->m_hasMask) | |
1431 | { | |
1432 | if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g && | |
1433 | M_IMGDATA->m_maskBlue == b) | |
1434 | image.SetMaskColour( 255, 255, 255 ); | |
1435 | else | |
1436 | image.SetMaskColour( 0, 0, 0 ); | |
1437 | } | |
1438 | ||
1439 | long size = M_IMGDATA->m_height * M_IMGDATA->m_width; | |
1440 | ||
487659e0 VZ |
1441 | unsigned char *srcd = M_IMGDATA->m_data; |
1442 | unsigned char *tard = image.GetData(); | |
fec19ea9 VS |
1443 | |
1444 | for ( long i = 0; i < size; i++, srcd += 3, tard += 3 ) | |
1445 | { | |
1446 | if (srcd[0] == r && srcd[1] == g && srcd[2] == b) | |
1447 | tard[0] = tard[1] = tard[2] = 255; | |
1448 | else | |
1449 | tard[0] = tard[1] = tard[2] = 0; | |
1450 | } | |
1451 | ||
1452 | return image; | |
1453 | } | |
1454 | ||
21dc4be5 VZ |
1455 | int wxImage::GetWidth() const |
1456 | { | |
1457 | wxCHECK_MSG( Ok(), 0, wxT("invalid image") ); | |
1458 | ||
1459 | return M_IMGDATA->m_width; | |
1460 | } | |
1461 | ||
1462 | int wxImage::GetHeight() const | |
1463 | { | |
1464 | wxCHECK_MSG( Ok(), 0, wxT("invalid image") ); | |
1465 | ||
1466 | return M_IMGDATA->m_height; | |
1467 | } | |
1468 | ||
591d3fa2 VZ |
1469 | wxBitmapType wxImage::GetType() const |
1470 | { | |
1471 | wxCHECK_MSG( IsOk(), wxBITMAP_TYPE_INVALID, wxT("invalid image") ); | |
1472 | ||
1473 | return M_IMGDATA->m_type; | |
1474 | } | |
1475 | ||
9d1c7e84 VZ |
1476 | void wxImage::SetType(wxBitmapType type) |
1477 | { | |
1478 | wxCHECK_RET( IsOk(), "must create the image before setting its type"); | |
1479 | ||
1480 | // type can be wxBITMAP_TYPE_INVALID to reset the image type to default | |
1481 | wxASSERT_MSG( type != wxBITMAP_TYPE_MAX, "invalid bitmap type" ); | |
1482 | ||
1483 | M_IMGDATA->m_type = type; | |
1484 | } | |
1485 | ||
5644ac46 | 1486 | long wxImage::XYToIndex(int x, int y) const |
ef539066 | 1487 | { |
5644ac46 VZ |
1488 | if ( Ok() && |
1489 | x >= 0 && y >= 0 && | |
1490 | x < M_IMGDATA->m_width && y < M_IMGDATA->m_height ) | |
1491 | { | |
1492 | return y*M_IMGDATA->m_width + x; | |
1493 | } | |
c7abc967 | 1494 | |
5644ac46 VZ |
1495 | return -1; |
1496 | } | |
c7abc967 | 1497 | |
5644ac46 VZ |
1498 | void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b ) |
1499 | { | |
1500 | long pos = XYToIndex(x, y); | |
1501 | wxCHECK_RET( pos != -1, wxT("invalid image coordinates") ); | |
c7abc967 | 1502 | |
a0f81e9f PC |
1503 | AllocExclusive(); |
1504 | ||
5644ac46 | 1505 | pos *= 3; |
c7abc967 | 1506 | |
ef539066 RR |
1507 | M_IMGDATA->m_data[ pos ] = r; |
1508 | M_IMGDATA->m_data[ pos+1 ] = g; | |
1509 | M_IMGDATA->m_data[ pos+2 ] = b; | |
1510 | } | |
1511 | ||
b737ad10 RR |
1512 | void wxImage::SetRGB( const wxRect& rect_, unsigned char r, unsigned char g, unsigned char b ) |
1513 | { | |
1514 | wxCHECK_RET( Ok(), wxT("invalid image") ); | |
1515 | ||
a0f81e9f PC |
1516 | AllocExclusive(); |
1517 | ||
b737ad10 RR |
1518 | wxRect rect(rect_); |
1519 | wxRect imageRect(0, 0, GetWidth(), GetHeight()); | |
1520 | if ( rect == wxRect() ) | |
1521 | { | |
1522 | rect = imageRect; | |
1523 | } | |
1524 | else | |
1525 | { | |
22a35096 VS |
1526 | wxCHECK_RET( imageRect.Contains(rect.GetTopLeft()) && |
1527 | imageRect.Contains(rect.GetBottomRight()), | |
b737ad10 RR |
1528 | wxT("invalid bounding rectangle") ); |
1529 | } | |
1530 | ||
1531 | int x1 = rect.GetLeft(), | |
1532 | y1 = rect.GetTop(), | |
1533 | x2 = rect.GetRight() + 1, | |
1534 | y2 = rect.GetBottom() + 1; | |
1535 | ||
e9b64c5e | 1536 | unsigned char *data wxDUMMY_INITIALIZE(NULL); |
b737ad10 RR |
1537 | int x, y, width = GetWidth(); |
1538 | for (y = y1; y < y2; y++) | |
1539 | { | |
1540 | data = M_IMGDATA->m_data + (y*width + x1)*3; | |
1541 | for (x = x1; x < x2; x++) | |
1542 | { | |
1543 | *data++ = r; | |
1544 | *data++ = g; | |
1545 | *data++ = b; | |
1546 | } | |
1547 | } | |
1548 | } | |
1549 | ||
f6bcfd97 | 1550 | unsigned char wxImage::GetRed( int x, int y ) const |
ef539066 | 1551 | { |
5644ac46 VZ |
1552 | long pos = XYToIndex(x, y); |
1553 | wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") ); | |
c7abc967 | 1554 | |
5644ac46 | 1555 | pos *= 3; |
c7abc967 | 1556 | |
ef539066 RR |
1557 | return M_IMGDATA->m_data[pos]; |
1558 | } | |
1559 | ||
f6bcfd97 | 1560 | unsigned char wxImage::GetGreen( int x, int y ) const |
ef539066 | 1561 | { |
5644ac46 VZ |
1562 | long pos = XYToIndex(x, y); |
1563 | wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") ); | |
c7abc967 | 1564 | |
5644ac46 | 1565 | pos *= 3; |
c7abc967 | 1566 | |
ef539066 RR |
1567 | return M_IMGDATA->m_data[pos+1]; |
1568 | } | |
1569 | ||
f6bcfd97 | 1570 | unsigned char wxImage::GetBlue( int x, int y ) const |
ef539066 | 1571 | { |
5644ac46 VZ |
1572 | long pos = XYToIndex(x, y); |
1573 | wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") ); | |
c7abc967 | 1574 | |
5644ac46 | 1575 | pos *= 3; |
c7abc967 | 1576 | |
ef539066 RR |
1577 | return M_IMGDATA->m_data[pos+2]; |
1578 | } | |
4698648f | 1579 | |
b7cacb43 | 1580 | bool wxImage::IsOk() const |
4698648f | 1581 | { |
de8c48cf VZ |
1582 | // image of 0 width or height can't be considered ok - at least because it |
1583 | // causes crashes in ConvertToBitmap() if we don't catch it in time | |
1584 | wxImageRefData *data = M_IMGDATA; | |
1585 | return data && data->m_ok && data->m_width && data->m_height; | |
01111366 RR |
1586 | } |
1587 | ||
487659e0 | 1588 | unsigned char *wxImage::GetData() const |
01111366 | 1589 | { |
487659e0 | 1590 | wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") ); |
c7abc967 | 1591 | |
fd0eed64 | 1592 | return M_IMGDATA->m_data; |
01111366 RR |
1593 | } |
1594 | ||
4013de12 | 1595 | void wxImage::SetData( unsigned char *data, bool static_data ) |
01111366 | 1596 | { |
223d09f6 | 1597 | wxCHECK_RET( Ok(), wxT("invalid image") ); |
58a8ab88 | 1598 | |
ed58dbea RR |
1599 | wxImageRefData *newRefData = new wxImageRefData(); |
1600 | ||
1601 | newRefData->m_width = M_IMGDATA->m_width; | |
1602 | newRefData->m_height = M_IMGDATA->m_height; | |
1603 | newRefData->m_data = data; | |
70cd62e9 | 1604 | newRefData->m_ok = true; |
ed58dbea RR |
1605 | newRefData->m_maskRed = M_IMGDATA->m_maskRed; |
1606 | newRefData->m_maskGreen = M_IMGDATA->m_maskGreen; | |
1607 | newRefData->m_maskBlue = M_IMGDATA->m_maskBlue; | |
1608 | newRefData->m_hasMask = M_IMGDATA->m_hasMask; | |
4013de12 | 1609 | newRefData->m_static = static_data; |
995612e2 | 1610 | |
ed58dbea | 1611 | UnRef(); |
995612e2 | 1612 | |
ed58dbea | 1613 | m_refData = newRefData; |
01111366 RR |
1614 | } |
1615 | ||
4013de12 | 1616 | void wxImage::SetData( unsigned char *data, int new_width, int new_height, bool static_data ) |
f6bcfd97 BP |
1617 | { |
1618 | wxImageRefData *newRefData = new wxImageRefData(); | |
1619 | ||
1620 | if (m_refData) | |
1621 | { | |
1622 | newRefData->m_width = new_width; | |
1623 | newRefData->m_height = new_height; | |
1624 | newRefData->m_data = data; | |
70cd62e9 | 1625 | newRefData->m_ok = true; |
f6bcfd97 BP |
1626 | newRefData->m_maskRed = M_IMGDATA->m_maskRed; |
1627 | newRefData->m_maskGreen = M_IMGDATA->m_maskGreen; | |
1628 | newRefData->m_maskBlue = M_IMGDATA->m_maskBlue; | |
1629 | newRefData->m_hasMask = M_IMGDATA->m_hasMask; | |
1630 | } | |
1631 | else | |
1632 | { | |
1633 | newRefData->m_width = new_width; | |
1634 | newRefData->m_height = new_height; | |
1635 | newRefData->m_data = data; | |
70cd62e9 | 1636 | newRefData->m_ok = true; |
f6bcfd97 | 1637 | } |
4013de12 | 1638 | newRefData->m_static = static_data; |
f6bcfd97 BP |
1639 | |
1640 | UnRef(); | |
1641 | ||
1642 | m_refData = newRefData; | |
1643 | } | |
1644 | ||
487659e0 VZ |
1645 | // ---------------------------------------------------------------------------- |
1646 | // alpha channel support | |
1647 | // ---------------------------------------------------------------------------- | |
1648 | ||
1649 | void wxImage::SetAlpha(int x, int y, unsigned char alpha) | |
1650 | { | |
5644ac46 | 1651 | wxCHECK_RET( HasAlpha(), wxT("no alpha channel") ); |
487659e0 | 1652 | |
5644ac46 VZ |
1653 | long pos = XYToIndex(x, y); |
1654 | wxCHECK_RET( pos != -1, wxT("invalid image coordinates") ); | |
487659e0 | 1655 | |
a0f81e9f PC |
1656 | AllocExclusive(); |
1657 | ||
5644ac46 | 1658 | M_IMGDATA->m_alpha[pos] = alpha; |
487659e0 VZ |
1659 | } |
1660 | ||
d30ee785 | 1661 | unsigned char wxImage::GetAlpha(int x, int y) const |
487659e0 | 1662 | { |
5644ac46 | 1663 | wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") ); |
487659e0 | 1664 | |
5644ac46 VZ |
1665 | long pos = XYToIndex(x, y); |
1666 | wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") ); | |
487659e0 | 1667 | |
5644ac46 | 1668 | return M_IMGDATA->m_alpha[pos]; |
487659e0 VZ |
1669 | } |
1670 | ||
5644ac46 VZ |
1671 | bool |
1672 | wxImage::ConvertColourToAlpha(unsigned char r, unsigned char g, unsigned char b) | |
6408deed | 1673 | { |
5644ac46 | 1674 | SetAlpha(NULL); |
b713f891 | 1675 | |
5644ac46 VZ |
1676 | const int w = M_IMGDATA->m_width; |
1677 | const int h = M_IMGDATA->m_height; | |
b713f891 | 1678 | |
6408deed RR |
1679 | unsigned char *alpha = GetAlpha(); |
1680 | unsigned char *data = GetData(); | |
b713f891 | 1681 | |
5644ac46 VZ |
1682 | for ( int y = 0; y < h; y++ ) |
1683 | { | |
1684 | for ( int x = 0; x < w; x++ ) | |
1685 | { | |
1686 | *alpha++ = *data; | |
1687 | *data++ = r; | |
1688 | *data++ = g; | |
1689 | *data++ = b; | |
1690 | } | |
1691 | } | |
6408deed RR |
1692 | |
1693 | return true; | |
1694 | } | |
1695 | ||
4013de12 | 1696 | void wxImage::SetAlpha( unsigned char *alpha, bool static_data ) |
487659e0 VZ |
1697 | { |
1698 | wxCHECK_RET( Ok(), wxT("invalid image") ); | |
1699 | ||
a0f81e9f PC |
1700 | AllocExclusive(); |
1701 | ||
487659e0 VZ |
1702 | if ( !alpha ) |
1703 | { | |
edf8e8e0 | 1704 | alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height); |
487659e0 VZ |
1705 | } |
1706 | ||
eb86e775 VZ |
1707 | if( !M_IMGDATA->m_staticAlpha ) |
1708 | free(M_IMGDATA->m_alpha); | |
1709 | ||
487659e0 | 1710 | M_IMGDATA->m_alpha = alpha; |
d2502f14 | 1711 | M_IMGDATA->m_staticAlpha = static_data; |
487659e0 VZ |
1712 | } |
1713 | ||
1714 | unsigned char *wxImage::GetAlpha() const | |
1715 | { | |
1716 | wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") ); | |
1717 | ||
1718 | return M_IMGDATA->m_alpha; | |
1719 | } | |
1720 | ||
828f0936 VZ |
1721 | void wxImage::InitAlpha() |
1722 | { | |
1723 | wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") ); | |
1724 | ||
1725 | // initialize memory for alpha channel | |
1726 | SetAlpha(); | |
1727 | ||
1728 | unsigned char *alpha = M_IMGDATA->m_alpha; | |
1729 | const size_t lenAlpha = M_IMGDATA->m_width * M_IMGDATA->m_height; | |
1730 | ||
828f0936 VZ |
1731 | if ( HasMask() ) |
1732 | { | |
1733 | // use the mask to initialize the alpha channel. | |
1734 | const unsigned char * const alphaEnd = alpha + lenAlpha; | |
1735 | ||
1736 | const unsigned char mr = M_IMGDATA->m_maskRed; | |
1737 | const unsigned char mg = M_IMGDATA->m_maskGreen; | |
1738 | const unsigned char mb = M_IMGDATA->m_maskBlue; | |
1739 | for ( unsigned char *src = M_IMGDATA->m_data; | |
1740 | alpha < alphaEnd; | |
1741 | src += 3, alpha++ ) | |
1742 | { | |
1743 | *alpha = (src[0] == mr && src[1] == mg && src[2] == mb) | |
21dc4be5 VZ |
1744 | ? wxIMAGE_ALPHA_TRANSPARENT |
1745 | : wxIMAGE_ALPHA_OPAQUE; | |
828f0936 VZ |
1746 | } |
1747 | ||
1748 | M_IMGDATA->m_hasMask = false; | |
1749 | } | |
1750 | else // no mask | |
1751 | { | |
1752 | // make the image fully opaque | |
21dc4be5 | 1753 | memset(alpha, wxIMAGE_ALPHA_OPAQUE, lenAlpha); |
828f0936 VZ |
1754 | } |
1755 | } | |
1756 | ||
487659e0 VZ |
1757 | // ---------------------------------------------------------------------------- |
1758 | // mask support | |
1759 | // ---------------------------------------------------------------------------- | |
1760 | ||
01111366 RR |
1761 | void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b ) |
1762 | { | |
223d09f6 | 1763 | wxCHECK_RET( Ok(), wxT("invalid image") ); |
c7abc967 | 1764 | |
a0f81e9f PC |
1765 | AllocExclusive(); |
1766 | ||
fd0eed64 RR |
1767 | M_IMGDATA->m_maskRed = r; |
1768 | M_IMGDATA->m_maskGreen = g; | |
1769 | M_IMGDATA->m_maskBlue = b; | |
70cd62e9 | 1770 | M_IMGDATA->m_hasMask = true; |
01111366 RR |
1771 | } |
1772 | ||
b737ad10 RR |
1773 | bool wxImage::GetOrFindMaskColour( unsigned char *r, unsigned char *g, unsigned char *b ) const |
1774 | { | |
1775 | wxCHECK_MSG( Ok(), false, wxT("invalid image") ); | |
1776 | ||
1777 | if (M_IMGDATA->m_hasMask) | |
1778 | { | |
1779 | if (r) *r = M_IMGDATA->m_maskRed; | |
1780 | if (g) *g = M_IMGDATA->m_maskGreen; | |
1781 | if (b) *b = M_IMGDATA->m_maskBlue; | |
1782 | return true; | |
1783 | } | |
1784 | else | |
1785 | { | |
1786 | FindFirstUnusedColour(r, g, b); | |
1787 | return false; | |
1788 | } | |
1789 | } | |
1790 | ||
01111366 RR |
1791 | unsigned char wxImage::GetMaskRed() const |
1792 | { | |
223d09f6 | 1793 | wxCHECK_MSG( Ok(), 0, wxT("invalid image") ); |
c7abc967 | 1794 | |
fd0eed64 | 1795 | return M_IMGDATA->m_maskRed; |
01111366 RR |
1796 | } |
1797 | ||
1798 | unsigned char wxImage::GetMaskGreen() const | |
1799 | { | |
223d09f6 | 1800 | wxCHECK_MSG( Ok(), 0, wxT("invalid image") ); |
c7abc967 | 1801 | |
fd0eed64 | 1802 | return M_IMGDATA->m_maskGreen; |
01111366 RR |
1803 | } |
1804 | ||
1805 | unsigned char wxImage::GetMaskBlue() const | |
1806 | { | |
223d09f6 | 1807 | wxCHECK_MSG( Ok(), 0, wxT("invalid image") ); |
c7abc967 | 1808 | |
fd0eed64 | 1809 | return M_IMGDATA->m_maskBlue; |
01111366 | 1810 | } |
4698648f | 1811 | |
01111366 RR |
1812 | void wxImage::SetMask( bool mask ) |
1813 | { | |
223d09f6 | 1814 | wxCHECK_RET( Ok(), wxT("invalid image") ); |
c7abc967 | 1815 | |
a0f81e9f PC |
1816 | AllocExclusive(); |
1817 | ||
fd0eed64 | 1818 | M_IMGDATA->m_hasMask = mask; |
01111366 RR |
1819 | } |
1820 | ||
1821 | bool wxImage::HasMask() const | |
1822 | { | |
70cd62e9 | 1823 | wxCHECK_MSG( Ok(), false, wxT("invalid image") ); |
c7abc967 | 1824 | |
fd0eed64 | 1825 | return M_IMGDATA->m_hasMask; |
01111366 RR |
1826 | } |
1827 | ||
21dc4be5 | 1828 | bool wxImage::IsTransparent(int x, int y, unsigned char threshold) const |
4698648f | 1829 | { |
21dc4be5 VZ |
1830 | long pos = XYToIndex(x, y); |
1831 | wxCHECK_MSG( pos != -1, false, wxT("invalid image coordinates") ); | |
c7abc967 | 1832 | |
21dc4be5 VZ |
1833 | // check mask |
1834 | if ( M_IMGDATA->m_hasMask ) | |
1835 | { | |
1836 | const unsigned char *p = M_IMGDATA->m_data + 3*pos; | |
1837 | if ( p[0] == M_IMGDATA->m_maskRed && | |
1838 | p[1] == M_IMGDATA->m_maskGreen && | |
1839 | p[2] == M_IMGDATA->m_maskBlue ) | |
1840 | { | |
1841 | return true; | |
1842 | } | |
1843 | } | |
01111366 | 1844 | |
21dc4be5 VZ |
1845 | // then check alpha |
1846 | if ( M_IMGDATA->m_alpha ) | |
1847 | { | |
1848 | if ( M_IMGDATA->m_alpha[pos] < threshold ) | |
1849 | { | |
1850 | // transparent enough | |
1851 | return true; | |
1852 | } | |
1853 | } | |
c7abc967 | 1854 | |
21dc4be5 VZ |
1855 | // not transparent |
1856 | return false; | |
01111366 RR |
1857 | } |
1858 | ||
487659e0 | 1859 | bool wxImage::SetMaskFromImage(const wxImage& mask, |
1f5b2017 | 1860 | unsigned char mr, unsigned char mg, unsigned char mb) |
52b64b0a | 1861 | { |
52b64b0a RR |
1862 | // check that the images are the same size |
1863 | if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) ) | |
1864 | { | |
bc88f66f | 1865 | wxLogError( _("Image and mask have different sizes.") ); |
70cd62e9 | 1866 | return false; |
52b64b0a | 1867 | } |
487659e0 | 1868 | |
52b64b0a RR |
1869 | // find unused colour |
1870 | unsigned char r,g,b ; | |
1f5b2017 | 1871 | if (!FindFirstUnusedColour(&r, &g, &b)) |
52b64b0a | 1872 | { |
bc88f66f | 1873 | wxLogError( _("No unused colour in image being masked.") ); |
70cd62e9 | 1874 | return false ; |
52b64b0a | 1875 | } |
487659e0 | 1876 | |
a0f81e9f PC |
1877 | AllocExclusive(); |
1878 | ||
487659e0 VZ |
1879 | unsigned char *imgdata = GetData(); |
1880 | unsigned char *maskdata = mask.GetData(); | |
52b64b0a RR |
1881 | |
1882 | const int w = GetWidth(); | |
1883 | const int h = GetHeight(); | |
1884 | ||
1885 | for (int j = 0; j < h; j++) | |
1f5b2017 | 1886 | { |
52b64b0a RR |
1887 | for (int i = 0; i < w; i++) |
1888 | { | |
1f5b2017 | 1889 | if ((maskdata[0] == mr) && (maskdata[1] == mg) && (maskdata[2] == mb)) |
52b64b0a RR |
1890 | { |
1891 | imgdata[0] = r; | |
1892 | imgdata[1] = g; | |
1893 | imgdata[2] = b; | |
1894 | } | |
1895 | imgdata += 3; | |
1896 | maskdata += 3; | |
1897 | } | |
1f5b2017 | 1898 | } |
52b64b0a | 1899 | |
1f5b2017 | 1900 | SetMaskColour(r, g, b); |
70cd62e9 | 1901 | SetMask(true); |
487659e0 | 1902 | |
70cd62e9 | 1903 | return true; |
52b64b0a | 1904 | } |
7beb59f3 | 1905 | |
8f2b21e4 | 1906 | bool wxImage::ConvertAlphaToMask(unsigned char threshold) |
ff5ad794 VS |
1907 | { |
1908 | if (!HasAlpha()) | |
1909 | return true; | |
1910 | ||
1911 | unsigned char mr, mg, mb; | |
1912 | if (!FindFirstUnusedColour(&mr, &mg, &mb)) | |
1913 | { | |
1914 | wxLogError( _("No unused colour in image being masked.") ); | |
1915 | return false; | |
1916 | } | |
94406a49 | 1917 | |
a0f81e9f PC |
1918 | AllocExclusive(); |
1919 | ||
ff5ad794 VS |
1920 | SetMask(true); |
1921 | SetMaskColour(mr, mg, mb); | |
94406a49 | 1922 | |
ff5ad794 VS |
1923 | unsigned char *imgdata = GetData(); |
1924 | unsigned char *alphadata = GetAlpha(); | |
1925 | ||
8f2b21e4 VS |
1926 | int w = GetWidth(); |
1927 | int h = GetHeight(); | |
ff5ad794 | 1928 | |
8f2b21e4 | 1929 | for (int y = 0; y < h; y++) |
ff5ad794 | 1930 | { |
8f2b21e4 | 1931 | for (int x = 0; x < w; x++, imgdata += 3, alphadata++) |
ff5ad794 | 1932 | { |
e95f0d79 | 1933 | if (*alphadata < threshold) |
ff5ad794 VS |
1934 | { |
1935 | imgdata[0] = mr; | |
1936 | imgdata[1] = mg; | |
1937 | imgdata[2] = mb; | |
1938 | } | |
1939 | } | |
1940 | } | |
1941 | ||
eb86e775 VZ |
1942 | if( !M_IMGDATA->m_staticAlpha ) |
1943 | free(M_IMGDATA->m_alpha); | |
1944 | ||
ff5ad794 | 1945 | M_IMGDATA->m_alpha = NULL; |
eb86e775 | 1946 | M_IMGDATA->m_staticAlpha = false; |
94406a49 DS |
1947 | |
1948 | return true; | |
ff5ad794 | 1949 | } |
52b64b0a | 1950 | |
21dc4be5 | 1951 | // ---------------------------------------------------------------------------- |
5e5437e0 | 1952 | // Palette functions |
21dc4be5 VZ |
1953 | // ---------------------------------------------------------------------------- |
1954 | ||
1955 | #if wxUSE_PALETTE | |
5e5437e0 JS |
1956 | |
1957 | bool wxImage::HasPalette() const | |
1958 | { | |
1959 | if (!Ok()) | |
70cd62e9 | 1960 | return false; |
5e5437e0 JS |
1961 | |
1962 | return M_IMGDATA->m_palette.Ok(); | |
1963 | } | |
1964 | ||
1965 | const wxPalette& wxImage::GetPalette() const | |
1966 | { | |
1967 | wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") ); | |
1968 | ||
1969 | return M_IMGDATA->m_palette; | |
1970 | } | |
1971 | ||
1972 | void wxImage::SetPalette(const wxPalette& palette) | |
1973 | { | |
1974 | wxCHECK_RET( Ok(), wxT("invalid image") ); | |
1975 | ||
a0f81e9f PC |
1976 | AllocExclusive(); |
1977 | ||
5e5437e0 JS |
1978 | M_IMGDATA->m_palette = palette; |
1979 | } | |
1980 | ||
d275c7eb VZ |
1981 | #endif // wxUSE_PALETTE |
1982 | ||
21dc4be5 | 1983 | // ---------------------------------------------------------------------------- |
5e5437e0 | 1984 | // Option functions (arbitrary name/value mapping) |
21dc4be5 VZ |
1985 | // ---------------------------------------------------------------------------- |
1986 | ||
5e5437e0 JS |
1987 | void wxImage::SetOption(const wxString& name, const wxString& value) |
1988 | { | |
a0f81e9f PC |
1989 | AllocExclusive(); |
1990 | ||
70cd62e9 | 1991 | int idx = M_IMGDATA->m_optionNames.Index(name, false); |
36abe9d4 | 1992 | if ( idx == wxNOT_FOUND ) |
5e5437e0 JS |
1993 | { |
1994 | M_IMGDATA->m_optionNames.Add(name); | |
1995 | M_IMGDATA->m_optionValues.Add(value); | |
1996 | } | |
1997 | else | |
1998 | { | |
1999 | M_IMGDATA->m_optionNames[idx] = name; | |
2000 | M_IMGDATA->m_optionValues[idx] = value; | |
2001 | } | |
2002 | } | |
2003 | ||
2004 | void wxImage::SetOption(const wxString& name, int value) | |
2005 | { | |
2006 | wxString valStr; | |
2007 | valStr.Printf(wxT("%d"), value); | |
2008 | SetOption(name, valStr); | |
2009 | } | |
2010 | ||
2011 | wxString wxImage::GetOption(const wxString& name) const | |
2012 | { | |
36abe9d4 VZ |
2013 | if ( !M_IMGDATA ) |
2014 | return wxEmptyString; | |
5e5437e0 | 2015 | |
70cd62e9 | 2016 | int idx = M_IMGDATA->m_optionNames.Index(name, false); |
36abe9d4 | 2017 | if ( idx == wxNOT_FOUND ) |
5e5437e0 JS |
2018 | return wxEmptyString; |
2019 | else | |
2020 | return M_IMGDATA->m_optionValues[idx]; | |
2021 | } | |
2022 | ||
2023 | int wxImage::GetOptionInt(const wxString& name) const | |
2024 | { | |
5e5437e0 JS |
2025 | return wxAtoi(GetOption(name)); |
2026 | } | |
2027 | ||
2028 | bool wxImage::HasOption(const wxString& name) const | |
2029 | { | |
36abe9d4 VZ |
2030 | return M_IMGDATA ? M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND |
2031 | : false; | |
5e5437e0 JS |
2032 | } |
2033 | ||
21dc4be5 VZ |
2034 | // ---------------------------------------------------------------------------- |
2035 | // image I/O | |
2036 | // ---------------------------------------------------------------------------- | |
2037 | ||
9a6384ca | 2038 | bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename), |
e98e625c | 2039 | wxBitmapType WXUNUSED_UNLESS_STREAMS(type), |
9a6384ca | 2040 | int WXUNUSED_UNLESS_STREAMS(index) ) |
01111366 | 2041 | { |
6632225c | 2042 | #if HAS_FILE_STREAMS |
d80207c3 | 2043 | if (wxFileExists(filename)) |
6c28fd33 | 2044 | { |
6632225c | 2045 | wxImageFileInputStream stream(filename); |
d80207c3 | 2046 | wxBufferedInputStream bstream( stream ); |
60d43ad8 | 2047 | return LoadFile(bstream, type, index); |
6c28fd33 | 2048 | } |
d80207c3 | 2049 | else |
6c28fd33 | 2050 | { |
d80207c3 KB |
2051 | wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() ); |
2052 | ||
70cd62e9 | 2053 | return false; |
6c28fd33 | 2054 | } |
6632225c | 2055 | #else // !HAS_FILE_STREAMS |
70cd62e9 | 2056 | return false; |
6632225c | 2057 | #endif // HAS_FILE_STREAMS |
9e9ee68e VS |
2058 | } |
2059 | ||
9a6384ca WS |
2060 | bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename), |
2061 | const wxString& WXUNUSED_UNLESS_STREAMS(mimetype), | |
2062 | int WXUNUSED_UNLESS_STREAMS(index) ) | |
9e9ee68e | 2063 | { |
6632225c | 2064 | #if HAS_FILE_STREAMS |
d80207c3 | 2065 | if (wxFileExists(filename)) |
6c28fd33 | 2066 | { |
6632225c | 2067 | wxImageFileInputStream stream(filename); |
d80207c3 | 2068 | wxBufferedInputStream bstream( stream ); |
60d43ad8 | 2069 | return LoadFile(bstream, mimetype, index); |
6c28fd33 | 2070 | } |
d80207c3 | 2071 | else |
6c28fd33 | 2072 | { |
d80207c3 KB |
2073 | wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() ); |
2074 | ||
70cd62e9 | 2075 | return false; |
6c28fd33 | 2076 | } |
6632225c | 2077 | #else // !HAS_FILE_STREAMS |
70cd62e9 | 2078 | return false; |
6632225c | 2079 | #endif // HAS_FILE_STREAMS |
1ccbb61a VZ |
2080 | } |
2081 | ||
45647dcf | 2082 | |
45647dcf VS |
2083 | bool wxImage::SaveFile( const wxString& filename ) const |
2084 | { | |
2085 | wxString ext = filename.AfterLast('.').Lower(); | |
487659e0 | 2086 | |
e98e625c VZ |
2087 | wxImageHandler *handler = FindHandler(ext, wxBITMAP_TYPE_ANY); |
2088 | if ( !handler) | |
45647dcf | 2089 | { |
e98e625c VZ |
2090 | wxLogError(_("Can't save image to file '%s': unknown extension."), |
2091 | filename); | |
2092 | return false; | |
45647dcf VS |
2093 | } |
2094 | ||
e98e625c | 2095 | return SaveFile(filename, handler->GetType()); |
45647dcf VS |
2096 | } |
2097 | ||
9a6384ca | 2098 | bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename), |
e98e625c | 2099 | wxBitmapType WXUNUSED_UNLESS_STREAMS(type) ) const |
1ccbb61a | 2100 | { |
6632225c | 2101 | #if HAS_FILE_STREAMS |
2a736739 VZ |
2102 | wxCHECK_MSG( Ok(), false, wxT("invalid image") ); |
2103 | ||
36aac195 | 2104 | ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename); |
fd94e8aa | 2105 | |
6632225c | 2106 | wxImageFileOutputStream stream(filename); |
9e9ee68e | 2107 | |
2b5f62a0 | 2108 | if ( stream.IsOk() ) |
1b055864 | 2109 | { |
069d0f27 | 2110 | wxBufferedOutputStream bstream( stream ); |
1b055864 RR |
2111 | return SaveFile(bstream, type); |
2112 | } | |
6632225c | 2113 | #endif // HAS_FILE_STREAMS |
3ca6a5f0 | 2114 | |
70cd62e9 | 2115 | return false; |
3d05544e | 2116 | } |
01111366 | 2117 | |
9a6384ca WS |
2118 | bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename), |
2119 | const wxString& WXUNUSED_UNLESS_STREAMS(mimetype) ) const | |
9e9ee68e | 2120 | { |
6632225c | 2121 | #if HAS_FILE_STREAMS |
2a736739 VZ |
2122 | wxCHECK_MSG( Ok(), false, wxT("invalid image") ); |
2123 | ||
36aac195 | 2124 | ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename); |
fd94e8aa | 2125 | |
6632225c | 2126 | wxImageFileOutputStream stream(filename); |
c7abc967 | 2127 | |
2b5f62a0 | 2128 | if ( stream.IsOk() ) |
1b055864 | 2129 | { |
069d0f27 | 2130 | wxBufferedOutputStream bstream( stream ); |
1b055864 RR |
2131 | return SaveFile(bstream, mimetype); |
2132 | } | |
6632225c | 2133 | #endif // HAS_FILE_STREAMS |
3ca6a5f0 | 2134 | |
70cd62e9 | 2135 | return false; |
9e9ee68e VS |
2136 | } |
2137 | ||
9a6384ca | 2138 | bool wxImage::CanRead( const wxString& WXUNUSED_UNLESS_STREAMS(name) ) |
87202f78 | 2139 | { |
6632225c VS |
2140 | #if HAS_FILE_STREAMS |
2141 | wxImageFileInputStream stream(name); | |
9a6384ca | 2142 | return CanRead(stream); |
87202f78 | 2143 | #else |
9a6384ca | 2144 | return false; |
87202f78 SB |
2145 | #endif |
2146 | } | |
2147 | ||
9a6384ca | 2148 | int wxImage::GetImageCount( const wxString& WXUNUSED_UNLESS_STREAMS(name), |
e98e625c | 2149 | wxBitmapType WXUNUSED_UNLESS_STREAMS(type) ) |
60d43ad8 | 2150 | { |
6632225c VS |
2151 | #if HAS_FILE_STREAMS |
2152 | wxImageFileInputStream stream(name); | |
9a6384ca WS |
2153 | if (stream.Ok()) |
2154 | return GetImageCount(stream, type); | |
60d43ad8 | 2155 | #endif |
2c0a4e08 VZ |
2156 | |
2157 | return 0; | |
60d43ad8 VS |
2158 | } |
2159 | ||
e02afc7a | 2160 | #if wxUSE_STREAMS |
deb2fec0 | 2161 | |
87202f78 SB |
2162 | bool wxImage::CanRead( wxInputStream &stream ) |
2163 | { | |
79fa2374 | 2164 | const wxList& list = GetHandlers(); |
004fd0c8 | 2165 | |
222ed1d6 | 2166 | for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() ) |
004fd0c8 | 2167 | { |
60d43ad8 VS |
2168 | wxImageHandler *handler=(wxImageHandler*)node->GetData(); |
2169 | if (handler->CanRead( stream )) | |
70cd62e9 | 2170 | return true; |
87202f78 SB |
2171 | } |
2172 | ||
70cd62e9 | 2173 | return false; |
60d43ad8 VS |
2174 | } |
2175 | ||
e98e625c | 2176 | int wxImage::GetImageCount( wxInputStream &stream, wxBitmapType type ) |
60d43ad8 VS |
2177 | { |
2178 | wxImageHandler *handler; | |
2179 | ||
2180 | if ( type == wxBITMAP_TYPE_ANY ) | |
2181 | { | |
f71b0c2d | 2182 | const wxList& list = GetHandlers(); |
60d43ad8 | 2183 | |
f71b0c2d VZ |
2184 | for ( wxList::compatibility_iterator node = list.GetFirst(); |
2185 | node; | |
2186 | node = node->GetNext() ) | |
60d43ad8 | 2187 | { |
f71b0c2d | 2188 | handler = (wxImageHandler*)node->GetData(); |
60d43ad8 | 2189 | if ( handler->CanRead(stream) ) |
f71b0c2d VZ |
2190 | { |
2191 | const int count = handler->GetImageCount(stream); | |
2192 | if ( count >= 0 ) | |
2193 | return count; | |
2194 | } | |
60d43ad8 VS |
2195 | |
2196 | } | |
2197 | ||
2198 | wxLogWarning(_("No handler found for image type.")); | |
2199 | return 0; | |
2200 | } | |
2201 | ||
2202 | handler = FindHandler(type); | |
2203 | ||
2204 | if ( !handler ) | |
2205 | { | |
e772e330 | 2206 | wxLogWarning(_("No image handler for type %ld defined."), type); |
70cd62e9 | 2207 | return false; |
60d43ad8 VS |
2208 | } |
2209 | ||
2210 | if ( handler->CanRead(stream) ) | |
2211 | { | |
649d13e8 | 2212 | return handler->GetImageCount(stream); |
60d43ad8 VS |
2213 | } |
2214 | else | |
2215 | { | |
e772e330 | 2216 | wxLogError(_("Image file is not of type %ld."), type); |
60d43ad8 VS |
2217 | return 0; |
2218 | } | |
87202f78 SB |
2219 | } |
2220 | ||
591d3fa2 VZ |
2221 | bool wxImage::DoLoad(wxImageHandler& handler, wxInputStream& stream, int index) |
2222 | { | |
36abe9d4 VZ |
2223 | // save the options values which can be clobbered by the handler (e.g. many |
2224 | // of them call Destroy() before trying to load the file) | |
2225 | const unsigned maxWidth = GetOptionInt(wxIMAGE_OPTION_MAX_WIDTH), | |
2226 | maxHeight = GetOptionInt(wxIMAGE_OPTION_MAX_HEIGHT); | |
2227 | ||
591d3fa2 VZ |
2228 | if ( !handler.LoadFile(this, stream, true/*verbose*/, index) ) |
2229 | return false; | |
2230 | ||
2231 | M_IMGDATA->m_type = handler.GetType(); | |
36abe9d4 VZ |
2232 | |
2233 | // rescale the image to the specified size if needed | |
2234 | if ( maxWidth || maxHeight ) | |
2235 | { | |
2236 | const unsigned widthOrig = GetWidth(), | |
2237 | heightOrig = GetHeight(); | |
2238 | ||
2239 | // this uses the same (trivial) algorithm as the JPEG handler | |
2240 | unsigned width = widthOrig, | |
2241 | height = heightOrig; | |
2242 | while ( (maxWidth && width > maxWidth) || | |
2243 | (maxHeight && height > maxHeight) ) | |
2244 | { | |
2245 | width /= 2; | |
2246 | height /= 2; | |
2247 | } | |
2248 | ||
2249 | if ( width != widthOrig || height != heightOrig ) | |
2250 | Rescale(width, height, wxIMAGE_QUALITY_HIGH); | |
2251 | } | |
2252 | ||
591d3fa2 VZ |
2253 | return true; |
2254 | } | |
2255 | ||
e98e625c | 2256 | bool wxImage::LoadFile( wxInputStream& stream, wxBitmapType type, int index ) |
3d05544e | 2257 | { |
36abe9d4 | 2258 | AllocExclusive(); |
c7abc967 | 2259 | |
deb2fec0 SB |
2260 | wxImageHandler *handler; |
2261 | ||
60d43ad8 | 2262 | if ( type == wxBITMAP_TYPE_ANY ) |
deb2fec0 | 2263 | { |
f71b0c2d VZ |
2264 | const wxList& list = GetHandlers(); |
2265 | for ( wxList::compatibility_iterator node = list.GetFirst(); | |
2266 | node; | |
2267 | node = node->GetNext() ) | |
995612e2 | 2268 | { |
f71b0c2d | 2269 | handler = (wxImageHandler*)node->GetData(); |
591d3fa2 | 2270 | if ( handler->CanRead(stream) && DoLoad(*handler, stream, index) ) |
f71b0c2d | 2271 | return true; |
995612e2 | 2272 | } |
deb2fec0 | 2273 | |
58c837a4 | 2274 | wxLogWarning( _("No handler found for image type.") ); |
f71b0c2d | 2275 | |
70cd62e9 | 2276 | return false; |
deb2fec0 | 2277 | } |
e98e625c | 2278 | //else: have specific type |
deb2fec0 SB |
2279 | |
2280 | handler = FindHandler(type); | |
e98e625c | 2281 | if ( !handler ) |
fd0eed64 | 2282 | { |
e772e330 | 2283 | wxLogWarning( _("No image handler for type %ld defined."), type ); |
70cd62e9 | 2284 | return false; |
fd0eed64 | 2285 | } |
c7abc967 | 2286 | |
e98e625c | 2287 | if ( stream.IsSeekable() && !handler->CanRead(stream) ) |
dd9ea234 | 2288 | { |
e772e330 | 2289 | wxLogError(_("Image file is not of type %ld."), type); |
dd9ea234 JS |
2290 | return false; |
2291 | } | |
e98e625c | 2292 | |
591d3fa2 | 2293 | return DoLoad(*handler, stream, index); |
01111366 RR |
2294 | } |
2295 | ||
60d43ad8 | 2296 | bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index ) |
9e9ee68e VS |
2297 | { |
2298 | UnRef(); | |
2299 | ||
2300 | m_refData = new wxImageRefData; | |
2301 | ||
2302 | wxImageHandler *handler = FindHandlerMime(mimetype); | |
2303 | ||
e98e625c | 2304 | if ( !handler ) |
9e9ee68e | 2305 | { |
58c837a4 | 2306 | wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() ); |
70cd62e9 | 2307 | return false; |
9e9ee68e VS |
2308 | } |
2309 | ||
e98e625c | 2310 | if ( stream.IsSeekable() && !handler->CanRead(stream) ) |
dd9ea234 | 2311 | { |
86501081 | 2312 | wxLogError(_("Image file is not of type %s."), mimetype); |
dd9ea234 JS |
2313 | return false; |
2314 | } | |
e98e625c | 2315 | |
591d3fa2 VZ |
2316 | return DoLoad(*handler, stream, index); |
2317 | } | |
2318 | ||
2319 | bool wxImage::DoSave(wxImageHandler& handler, wxOutputStream& stream) const | |
2320 | { | |
5c33522f | 2321 | wxImage * const self = const_cast<wxImage *>(this); |
591d3fa2 VZ |
2322 | if ( !handler.SaveFile(self, stream) ) |
2323 | return false; | |
2324 | ||
2325 | M_IMGDATA->m_type = handler.GetType(); | |
2326 | return true; | |
9e9ee68e VS |
2327 | } |
2328 | ||
e98e625c | 2329 | bool wxImage::SaveFile( wxOutputStream& stream, wxBitmapType type ) const |
01111366 | 2330 | { |
70cd62e9 | 2331 | wxCHECK_MSG( Ok(), false, wxT("invalid image") ); |
c7abc967 | 2332 | |
fd0eed64 | 2333 | wxImageHandler *handler = FindHandler(type); |
2a736739 | 2334 | if ( !handler ) |
fd0eed64 | 2335 | { |
58c837a4 | 2336 | wxLogWarning( _("No image handler for type %d defined."), type ); |
70cd62e9 | 2337 | return false; |
9e9ee68e VS |
2338 | } |
2339 | ||
591d3fa2 | 2340 | return DoSave(*handler, stream); |
9e9ee68e VS |
2341 | } |
2342 | ||
e0a76d8d | 2343 | bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const |
9e9ee68e | 2344 | { |
70cd62e9 | 2345 | wxCHECK_MSG( Ok(), false, wxT("invalid image") ); |
c7abc967 | 2346 | |
9e9ee68e | 2347 | wxImageHandler *handler = FindHandlerMime(mimetype); |
2a736739 | 2348 | if ( !handler ) |
9e9ee68e | 2349 | { |
58c837a4 | 2350 | wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() ); |
fd0eed64 | 2351 | } |
c7abc967 | 2352 | |
591d3fa2 | 2353 | return DoSave(*handler, stream); |
01111366 | 2354 | } |
e98e625c | 2355 | |
e02afc7a | 2356 | #endif // wxUSE_STREAMS |
01111366 | 2357 | |
21dc4be5 VZ |
2358 | // ---------------------------------------------------------------------------- |
2359 | // image I/O handlers | |
2360 | // ---------------------------------------------------------------------------- | |
2361 | ||
01111366 RR |
2362 | void wxImage::AddHandler( wxImageHandler *handler ) |
2363 | { | |
2b5f62a0 VZ |
2364 | // Check for an existing handler of the type being added. |
2365 | if (FindHandler( handler->GetType() ) == 0) | |
2366 | { | |
2367 | sm_handlers.Append( handler ); | |
2368 | } | |
2369 | else | |
2370 | { | |
2371 | // This is not documented behaviour, merely the simplest 'fix' | |
2372 | // for preventing duplicate additions. If someone ever has | |
2373 | // a good reason to add and remove duplicate handlers (and they | |
2374 | // may) we should probably refcount the duplicates. | |
2375 | // also an issue in InsertHandler below. | |
2376 | ||
2377 | wxLogDebug( _T("Adding duplicate image handler for '%s'"), | |
2378 | handler->GetName().c_str() ); | |
2379 | delete handler; | |
2380 | } | |
01111366 RR |
2381 | } |
2382 | ||
2383 | void wxImage::InsertHandler( wxImageHandler *handler ) | |
2384 | { | |
2b5f62a0 VZ |
2385 | // Check for an existing handler of the type being added. |
2386 | if (FindHandler( handler->GetType() ) == 0) | |
2387 | { | |
2388 | sm_handlers.Insert( handler ); | |
2389 | } | |
2390 | else | |
2391 | { | |
2392 | // see AddHandler for additional comments. | |
2393 | wxLogDebug( _T("Inserting duplicate image handler for '%s'"), | |
2394 | handler->GetName().c_str() ); | |
2395 | delete handler; | |
2396 | } | |
01111366 RR |
2397 | } |
2398 | ||
2399 | bool wxImage::RemoveHandler( const wxString& name ) | |
2400 | { | |
fd0eed64 RR |
2401 | wxImageHandler *handler = FindHandler(name); |
2402 | if (handler) | |
2403 | { | |
2404 | sm_handlers.DeleteObject(handler); | |
222ed1d6 | 2405 | delete handler; |
70cd62e9 | 2406 | return true; |
fd0eed64 RR |
2407 | } |
2408 | else | |
70cd62e9 | 2409 | return false; |
01111366 RR |
2410 | } |
2411 | ||
2412 | wxImageHandler *wxImage::FindHandler( const wxString& name ) | |
2413 | { | |
222ed1d6 | 2414 | wxList::compatibility_iterator node = sm_handlers.GetFirst(); |
fd0eed64 RR |
2415 | while (node) |
2416 | { | |
b1d4dd7a | 2417 | wxImageHandler *handler = (wxImageHandler*)node->GetData(); |
ce3ed50d | 2418 | if (handler->GetName().Cmp(name) == 0) return handler; |
c7abc967 | 2419 | |
b1d4dd7a | 2420 | node = node->GetNext(); |
fd0eed64 | 2421 | } |
b4c26503 | 2422 | return NULL; |
01111366 RR |
2423 | } |
2424 | ||
e98e625c | 2425 | wxImageHandler *wxImage::FindHandler( const wxString& extension, wxBitmapType bitmapType ) |
01111366 | 2426 | { |
222ed1d6 | 2427 | wxList::compatibility_iterator node = sm_handlers.GetFirst(); |
fd0eed64 RR |
2428 | while (node) |
2429 | { | |
b1d4dd7a | 2430 | wxImageHandler *handler = (wxImageHandler*)node->GetData(); |
ce3ed50d | 2431 | if ( (handler->GetExtension().Cmp(extension) == 0) && |
e98e625c VZ |
2432 | ( (bitmapType == wxBITMAP_TYPE_ANY) || (handler->GetType() == bitmapType)) ) |
2433 | { | |
dbda9e86 | 2434 | return handler; |
e98e625c | 2435 | } |
b1d4dd7a | 2436 | node = node->GetNext(); |
fd0eed64 | 2437 | } |
b4c26503 | 2438 | return NULL; |
01111366 RR |
2439 | } |
2440 | ||
e98e625c | 2441 | wxImageHandler *wxImage::FindHandler(wxBitmapType bitmapType ) |
01111366 | 2442 | { |
222ed1d6 | 2443 | wxList::compatibility_iterator node = sm_handlers.GetFirst(); |
fd0eed64 RR |
2444 | while (node) |
2445 | { | |
b1d4dd7a | 2446 | wxImageHandler *handler = (wxImageHandler *)node->GetData(); |
fd0eed64 | 2447 | if (handler->GetType() == bitmapType) return handler; |
b1d4dd7a | 2448 | node = node->GetNext(); |
fd0eed64 | 2449 | } |
b4c26503 | 2450 | return NULL; |
fd0eed64 RR |
2451 | } |
2452 | ||
9e9ee68e VS |
2453 | wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype ) |
2454 | { | |
222ed1d6 | 2455 | wxList::compatibility_iterator node = sm_handlers.GetFirst(); |
9e9ee68e VS |
2456 | while (node) |
2457 | { | |
b1d4dd7a | 2458 | wxImageHandler *handler = (wxImageHandler *)node->GetData(); |
70cd62e9 | 2459 | if (handler->GetMimeType().IsSameAs(mimetype, false)) return handler; |
b1d4dd7a | 2460 | node = node->GetNext(); |
9e9ee68e | 2461 | } |
b4c26503 | 2462 | return NULL; |
9e9ee68e VS |
2463 | } |
2464 | ||
fd0eed64 RR |
2465 | void wxImage::InitStandardHandlers() |
2466 | { | |
77fac225 | 2467 | #if wxUSE_STREAMS |
66e23ad2 | 2468 | AddHandler(new wxBMPHandler); |
77fac225 | 2469 | #endif // wxUSE_STREAMS |
01111366 RR |
2470 | } |
2471 | ||
2472 | void wxImage::CleanUpHandlers() | |
2473 | { | |
222ed1d6 | 2474 | wxList::compatibility_iterator node = sm_handlers.GetFirst(); |
fd0eed64 RR |
2475 | while (node) |
2476 | { | |
b1d4dd7a | 2477 | wxImageHandler *handler = (wxImageHandler *)node->GetData(); |
222ed1d6 | 2478 | wxList::compatibility_iterator next = node->GetNext(); |
fd0eed64 | 2479 | delete handler; |
fd0eed64 RR |
2480 | node = next; |
2481 | } | |
01111366 | 2482 | |
222ed1d6 MB |
2483 | sm_handlers.Clear(); |
2484 | } | |
ff865c13 | 2485 | |
939fadc8 JS |
2486 | wxString wxImage::GetImageExtWildcard() |
2487 | { | |
2488 | wxString fmts; | |
2489 | ||
2490 | wxList& Handlers = wxImage::GetHandlers(); | |
222ed1d6 | 2491 | wxList::compatibility_iterator Node = Handlers.GetFirst(); |
939fadc8 JS |
2492 | while ( Node ) |
2493 | { | |
2494 | wxImageHandler* Handler = (wxImageHandler*)Node->GetData(); | |
2495 | fmts += wxT("*.") + Handler->GetExtension(); | |
2496 | Node = Node->GetNext(); | |
2497 | if ( Node ) fmts += wxT(";"); | |
2498 | } | |
2499 | ||
2500 | return wxT("(") + fmts + wxT(")|") + fmts; | |
2501 | } | |
2502 | ||
978d3d36 VZ |
2503 | wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb) |
2504 | { | |
978d3d36 VZ |
2505 | const double red = rgb.red / 255.0, |
2506 | green = rgb.green / 255.0, | |
2507 | blue = rgb.blue / 255.0; | |
2508 | ||
c77a6796 VZ |
2509 | // find the min and max intensity (and remember which one was it for the |
2510 | // latter) | |
978d3d36 | 2511 | double minimumRGB = red; |
c77a6796 | 2512 | if ( green < minimumRGB ) |
978d3d36 | 2513 | minimumRGB = green; |
c77a6796 | 2514 | if ( blue < minimumRGB ) |
978d3d36 VZ |
2515 | minimumRGB = blue; |
2516 | ||
c77a6796 | 2517 | enum { RED, GREEN, BLUE } chMax = RED; |
978d3d36 | 2518 | double maximumRGB = red; |
c77a6796 VZ |
2519 | if ( green > maximumRGB ) |
2520 | { | |
2521 | chMax = GREEN; | |
978d3d36 | 2522 | maximumRGB = green; |
c77a6796 VZ |
2523 | } |
2524 | if ( blue > maximumRGB ) | |
2525 | { | |
2526 | chMax = BLUE; | |
978d3d36 | 2527 | maximumRGB = blue; |
c77a6796 | 2528 | } |
978d3d36 | 2529 | |
c77a6796 | 2530 | const double value = maximumRGB; |
978d3d36 | 2531 | |
38d4b1e4 | 2532 | double hue = 0.0, saturation; |
c77a6796 VZ |
2533 | const double deltaRGB = maximumRGB - minimumRGB; |
2534 | if ( wxIsNullDouble(deltaRGB) ) | |
978d3d36 VZ |
2535 | { |
2536 | // Gray has no color | |
2537 | hue = 0.0; | |
2538 | saturation = 0.0; | |
2539 | } | |
2540 | else | |
2541 | { | |
c77a6796 VZ |
2542 | switch ( chMax ) |
2543 | { | |
2544 | case RED: | |
2545 | hue = (green - blue) / deltaRGB; | |
2546 | break; | |
978d3d36 | 2547 | |
c77a6796 VZ |
2548 | case GREEN: |
2549 | hue = 2.0 + (blue - red) / deltaRGB; | |
2550 | break; | |
978d3d36 | 2551 | |
c77a6796 VZ |
2552 | case BLUE: |
2553 | hue = 4.0 + (red - green) / deltaRGB; | |
2554 | break; | |
38d4b1e4 WS |
2555 | |
2556 | default: | |
2557 | wxFAIL_MSG(wxT("hue not specified")); | |
2558 | break; | |
c77a6796 VZ |
2559 | } |
2560 | ||
2561 | hue /= 6.0; | |
978d3d36 | 2562 | |
c77a6796 VZ |
2563 | if ( hue < 0.0 ) |
2564 | hue += 1.0; | |
978d3d36 | 2565 | |
c77a6796 | 2566 | saturation = deltaRGB / maximumRGB; |
978d3d36 VZ |
2567 | } |
2568 | ||
2569 | return HSVValue(hue, saturation, value); | |
2570 | } | |
2571 | ||
2572 | wxImage::RGBValue wxImage::HSVtoRGB(const HSVValue& hsv) | |
2573 | { | |
2574 | double red, green, blue; | |
2575 | ||
c77a6796 | 2576 | if ( wxIsNullDouble(hsv.saturation) ) |
978d3d36 | 2577 | { |
c77a6796 VZ |
2578 | // Grey |
2579 | red = hsv.value; | |
978d3d36 | 2580 | green = hsv.value; |
c77a6796 | 2581 | blue = hsv.value; |
978d3d36 | 2582 | } |
c77a6796 | 2583 | else // not grey |
978d3d36 VZ |
2584 | { |
2585 | double hue = hsv.hue * 6.0; // sector 0 to 5 | |
2586 | int i = (int)floor(hue); | |
2587 | double f = hue - i; // fractional part of h | |
2588 | double p = hsv.value * (1.0 - hsv.saturation); | |
2589 | ||
2590 | switch (i) | |
2591 | { | |
2592 | case 0: | |
2593 | red = hsv.value; | |
2594 | green = hsv.value * (1.0 - hsv.saturation * (1.0 - f)); | |
2595 | blue = p; | |
2596 | break; | |
2597 | ||
2598 | case 1: | |
2599 | red = hsv.value * (1.0 - hsv.saturation * f); | |
2600 | green = hsv.value; | |
2601 | blue = p; | |
2602 | break; | |
2603 | ||
2604 | case 2: | |
2605 | red = p; | |
2606 | green = hsv.value; | |
2607 | blue = hsv.value * (1.0 - hsv.saturation * (1.0 - f)); | |
2608 | break; | |
2609 | ||
2610 | case 3: | |
2611 | red = p; | |
2612 | green = hsv.value * (1.0 - hsv.saturation * f); | |
2613 | blue = hsv.value; | |
2614 | break; | |
2615 | ||
2616 | case 4: | |
2617 | red = hsv.value * (1.0 - hsv.saturation * (1.0 - f)); | |
2618 | green = p; | |
2619 | blue = hsv.value; | |
2620 | break; | |
2621 | ||
2622 | default: // case 5: | |
2623 | red = hsv.value; | |
2624 | green = p; | |
2625 | blue = hsv.value * (1.0 - hsv.saturation * f); | |
2626 | break; | |
2627 | } | |
2628 | } | |
2629 | ||
2630 | return RGBValue((unsigned char)(red * 255.0), | |
2631 | (unsigned char)(green * 255.0), | |
2632 | (unsigned char)(blue * 255.0)); | |
2633 | } | |
2634 | ||
2635 | /* | |
2636 | * Rotates the hue of each pixel of the image. angle is a double in the range | |
2637 | * -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees | |
2638 | */ | |
2639 | void wxImage::RotateHue(double angle) | |
2640 | { | |
a0f81e9f PC |
2641 | AllocExclusive(); |
2642 | ||
978d3d36 VZ |
2643 | unsigned char *srcBytePtr; |
2644 | unsigned char *dstBytePtr; | |
2645 | unsigned long count; | |
2646 | wxImage::HSVValue hsv; | |
2647 | wxImage::RGBValue rgb; | |
2648 | ||
6926b9c4 | 2649 | wxASSERT (angle >= -1.0 && angle <= 1.0); |
978d3d36 | 2650 | count = M_IMGDATA->m_width * M_IMGDATA->m_height; |
c77a6796 | 2651 | if ( count > 0 && !wxIsNullDouble(angle) ) |
978d3d36 VZ |
2652 | { |
2653 | srcBytePtr = M_IMGDATA->m_data; | |
2654 | dstBytePtr = srcBytePtr; | |
2655 | do | |
2656 | { | |
2657 | rgb.red = *srcBytePtr++; | |
2658 | rgb.green = *srcBytePtr++; | |
2659 | rgb.blue = *srcBytePtr++; | |
2660 | hsv = RGBtoHSV(rgb); | |
2661 | ||
2662 | hsv.hue = hsv.hue + angle; | |
2663 | if (hsv.hue > 1.0) | |
2664 | hsv.hue = hsv.hue - 1.0; | |
2665 | else if (hsv.hue < 0.0) | |
2666 | hsv.hue = hsv.hue + 1.0; | |
2667 | ||
2668 | rgb = HSVtoRGB(hsv); | |
2669 | *dstBytePtr++ = rgb.red; | |
2670 | *dstBytePtr++ = rgb.green; | |
2671 | *dstBytePtr++ = rgb.blue; | |
2672 | } while (--count != 0); | |
2673 | } | |
2674 | } | |
2675 | ||
01111366 RR |
2676 | //----------------------------------------------------------------------------- |
2677 | // wxImageHandler | |
2678 | //----------------------------------------------------------------------------- | |
2679 | ||
63d963a1 | 2680 | IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject) |
01111366 | 2681 | |
e02afc7a | 2682 | #if wxUSE_STREAMS |
700ec454 | 2683 | bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) ) |
01111366 | 2684 | { |
70cd62e9 | 2685 | return false; |
01111366 RR |
2686 | } |
2687 | ||
deb2fec0 | 2688 | bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) ) |
01111366 | 2689 | { |
70cd62e9 | 2690 | return false; |
01111366 | 2691 | } |
0828c087 | 2692 | |
649d13e8 | 2693 | int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) ) |
700ec454 RR |
2694 | { |
2695 | return 1; | |
2696 | } | |
2697 | ||
0828c087 VS |
2698 | bool wxImageHandler::CanRead( const wxString& name ) |
2699 | { | |
0828c087 VS |
2700 | if (wxFileExists(name)) |
2701 | { | |
6632225c | 2702 | wxImageFileInputStream stream(name); |
0828c087 VS |
2703 | return CanRead(stream); |
2704 | } | |
2705 | ||
39d16996 | 2706 | wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() ); |
0828c087 | 2707 | |
70cd62e9 | 2708 | return false; |
39d16996 VZ |
2709 | } |
2710 | ||
2711 | bool wxImageHandler::CallDoCanRead(wxInputStream& stream) | |
2712 | { | |
30984dea | 2713 | wxFileOffset posOld = stream.TellI(); |
39d16996 VZ |
2714 | if ( posOld == wxInvalidOffset ) |
2715 | { | |
2716 | // can't test unseekable stream | |
70cd62e9 | 2717 | return false; |
39d16996 VZ |
2718 | } |
2719 | ||
2720 | bool ok = DoCanRead(stream); | |
2721 | ||
2722 | // restore the old position to be able to test other formats and so on | |
2723 | if ( stream.SeekI(posOld) == wxInvalidOffset ) | |
2724 | { | |
2725 | wxLogDebug(_T("Failed to rewind the stream in wxImageHandler!")); | |
2726 | ||
2727 | // reading would fail anyhow as we're not at the right position | |
70cd62e9 | 2728 | return false; |
0828c087 | 2729 | } |
39d16996 VZ |
2730 | |
2731 | return ok; | |
0828c087 VS |
2732 | } |
2733 | ||
e02afc7a | 2734 | #endif // wxUSE_STREAMS |
01111366 | 2735 | |
361f4288 VZ |
2736 | /* static */ |
2737 | wxImageResolution | |
2738 | wxImageHandler::GetResolutionFromOptions(const wxImage& image, int *x, int *y) | |
2739 | { | |
2740 | wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, _T("NULL pointer") ); | |
2741 | ||
2742 | if ( image.HasOption(wxIMAGE_OPTION_RESOLUTIONX) && | |
2743 | image.HasOption(wxIMAGE_OPTION_RESOLUTIONY) ) | |
2744 | { | |
2745 | *x = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX); | |
2746 | *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY); | |
2747 | } | |
2748 | else if ( image.HasOption(wxIMAGE_OPTION_RESOLUTION) ) | |
2749 | { | |
2750 | *x = | |
2751 | *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTION); | |
2752 | } | |
2753 | else // no resolution options specified | |
2754 | { | |
2755 | *x = | |
2756 | *y = 0; | |
2757 | ||
2758 | return wxIMAGE_RESOLUTION_NONE; | |
2759 | } | |
2760 | ||
2761 | // get the resolution unit too | |
2762 | int resUnit = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT); | |
2763 | if ( !resUnit ) | |
2764 | { | |
2765 | // this is the default | |
2766 | resUnit = wxIMAGE_RESOLUTION_INCHES; | |
2767 | } | |
2768 | ||
2769 | return (wxImageResolution)resUnit; | |
2770 | } | |
2771 | ||
487659e0 VZ |
2772 | // ---------------------------------------------------------------------------- |
2773 | // image histogram stuff | |
2774 | // ---------------------------------------------------------------------------- | |
2775 | ||
2776 | bool | |
2777 | wxImageHistogram::FindFirstUnusedColour(unsigned char *r, | |
2778 | unsigned char *g, | |
2779 | unsigned char *b, | |
2780 | unsigned char r2, | |
2781 | unsigned char b2, | |
2782 | unsigned char g2) const | |
2783 | { | |
2784 | unsigned long key = MakeKey(r2, g2, b2); | |
2785 | ||
2786 | while ( find(key) != end() ) | |
2787 | { | |
2788 | // color already used | |
2789 | r2++; | |
2790 | if ( r2 >= 255 ) | |
2791 | { | |
2792 | r2 = 0; | |
2793 | g2++; | |
2794 | if ( g2 >= 255 ) | |
2795 | { | |
2796 | g2 = 0; | |
2797 | b2++; | |
2798 | if ( b2 >= 255 ) | |
2799 | { | |
bc88f66f | 2800 | wxLogError(_("No unused colour in image.") ); |
70cd62e9 | 2801 | return false; |
487659e0 VZ |
2802 | } |
2803 | } | |
2804 | } | |
2805 | ||
2806 | key = MakeKey(r2, g2, b2); | |
2807 | } | |
2808 | ||
2809 | if ( r ) | |
2810 | *r = r2; | |
2811 | if ( g ) | |
2812 | *g = g2; | |
2813 | if ( b ) | |
2814 | *b = b2; | |
2815 | ||
70cd62e9 | 2816 | return true; |
487659e0 VZ |
2817 | } |
2818 | ||
2819 | bool | |
2820 | wxImage::FindFirstUnusedColour(unsigned char *r, | |
2821 | unsigned char *g, | |
2822 | unsigned char *b, | |
2823 | unsigned char r2, | |
2824 | unsigned char b2, | |
2825 | unsigned char g2) const | |
2826 | { | |
2827 | wxImageHistogram histogram; | |
2828 | ||
2829 | ComputeHistogram(histogram); | |
2830 | ||
2831 | return histogram.FindFirstUnusedColour(r, g, b, r2, g2, b2); | |
2832 | } | |
2833 | ||
2834 | ||
c9d01afd | 2835 | |
89d00456 GRG |
2836 | // GRG, Dic/99 |
2837 | // Counts and returns the number of different colours. Optionally stops | |
cc9f7d79 GRG |
2838 | // when it exceeds 'stopafter' different colours. This is useful, for |
2839 | // example, to see if the image can be saved as 8-bit (256 colour or | |
2840 | // less, in this case it would be invoked as CountColours(256)). Default | |
2841 | // value for stopafter is -1 (don't care). | |
89d00456 | 2842 | // |
e0a76d8d | 2843 | unsigned long wxImage::CountColours( unsigned long stopafter ) const |
89d00456 GRG |
2844 | { |
2845 | wxHashTable h; | |
ad30de59 | 2846 | wxObject dummy; |
33ac7e6f | 2847 | unsigned char r, g, b; |
eeca3a46 | 2848 | unsigned char *p; |
89d00456 GRG |
2849 | unsigned long size, nentries, key; |
2850 | ||
2851 | p = GetData(); | |
2852 | size = GetWidth() * GetHeight(); | |
2853 | nentries = 0; | |
2854 | ||
cc9f7d79 | 2855 | for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++) |
89d00456 GRG |
2856 | { |
2857 | r = *(p++); | |
2858 | g = *(p++); | |
2859 | b = *(p++); | |
487659e0 | 2860 | key = wxImageHistogram::MakeKey(r, g, b); |
89d00456 | 2861 | |
ad30de59 | 2862 | if (h.Get(key) == NULL) |
89d00456 | 2863 | { |
ad30de59 | 2864 | h.Put(key, &dummy); |
89d00456 GRG |
2865 | nentries++; |
2866 | } | |
2867 | } | |
2868 | ||
89d00456 GRG |
2869 | return nentries; |
2870 | } | |
2871 | ||
2872 | ||
e0a76d8d | 2873 | unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const |
c9d01afd | 2874 | { |
487659e0 VZ |
2875 | unsigned char *p = GetData(); |
2876 | unsigned long nentries = 0; | |
952ae1e8 VS |
2877 | |
2878 | h.clear(); | |
c9d01afd | 2879 | |
487659e0 | 2880 | const unsigned long size = GetWidth() * GetHeight(); |
c9d01afd | 2881 | |
487659e0 VZ |
2882 | unsigned char r, g, b; |
2883 | for ( unsigned long n = 0; n < size; n++ ) | |
c9d01afd | 2884 | { |
487659e0 VZ |
2885 | r = *p++; |
2886 | g = *p++; | |
2887 | b = *p++; | |
2888 | ||
2889 | wxImageHistogramEntry& entry = h[wxImageHistogram::MakeKey(r, g, b)]; | |
c9d01afd | 2890 | |
952ae1e8 VS |
2891 | if ( entry.value++ == 0 ) |
2892 | entry.index = nentries++; | |
c9d01afd GRG |
2893 | } |
2894 | ||
2895 | return nentries; | |
2896 | } | |
2897 | ||
7a632f10 JS |
2898 | /* |
2899 | * Rotation code by Carlos Moreno | |
2900 | */ | |
2901 | ||
3fff3966 | 2902 | static const double wxROTATE_EPSILON = 1e-10; |
7a632f10 JS |
2903 | |
2904 | // Auxiliary function to rotate a point (x,y) with respect to point p0 | |
2905 | // make it inline and use a straight return to facilitate optimization | |
2906 | // also, the function receives the sine and cosine of the angle to avoid | |
2907 | // repeating the time-consuming calls to these functions -- sin/cos can | |
2908 | // be computed and stored in the calling function. | |
2909 | ||
3fff3966 VZ |
2910 | static inline wxRealPoint |
2911 | wxRotatePoint(const wxRealPoint& p, double cos_angle, double sin_angle, | |
2912 | const wxRealPoint& p0) | |
7a632f10 | 2913 | { |
3fff3966 VZ |
2914 | return wxRealPoint(p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle, |
2915 | p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle); | |
7a632f10 JS |
2916 | } |
2917 | ||
3fff3966 VZ |
2918 | static inline wxRealPoint |
2919 | wxRotatePoint(double x, double y, double cos_angle, double sin_angle, | |
2920 | const wxRealPoint & p0) | |
7a632f10 | 2921 | { |
3fff3966 | 2922 | return wxRotatePoint (wxRealPoint(x,y), cos_angle, sin_angle, p0); |
7a632f10 JS |
2923 | } |
2924 | ||
e26d5213 VZ |
2925 | wxImage wxImage::Rotate(double angle, |
2926 | const wxPoint& centre_of_rotation, | |
2927 | bool interpolating, | |
2928 | wxPoint *offset_after_rotation) const | |
7a632f10 | 2929 | { |
e26d5213 VZ |
2930 | // screen coordinates are a mirror image of "real" coordinates |
2931 | angle = -angle; | |
2932 | ||
2933 | const bool has_alpha = HasAlpha(); | |
2934 | ||
2935 | const int w = GetWidth(); | |
2936 | const int h = GetHeight(); | |
b713f891 | 2937 | |
e26d5213 | 2938 | int i; |
7a632f10 | 2939 | |
ad30de59 | 2940 | // Create pointer-based array to accelerate access to wxImage's data |
e26d5213 | 2941 | unsigned char ** data = new unsigned char * [h]; |
b5c91ac6 | 2942 | data[0] = GetData(); |
e26d5213 VZ |
2943 | for (i = 1; i < h; i++) |
2944 | data[i] = data[i - 1] + (3 * w); | |
7a632f10 | 2945 | |
b713f891 | 2946 | // Same for alpha channel |
6408deed RR |
2947 | unsigned char ** alpha = NULL; |
2948 | if (has_alpha) | |
2949 | { | |
e26d5213 | 2950 | alpha = new unsigned char * [h]; |
6408deed | 2951 | alpha[0] = GetAlpha(); |
e26d5213 VZ |
2952 | for (i = 1; i < h; i++) |
2953 | alpha[i] = alpha[i - 1] + w; | |
6408deed RR |
2954 | } |
2955 | ||
b5c91ac6 | 2956 | // precompute coefficients for rotation formula |
7a632f10 JS |
2957 | const double cos_angle = cos(angle); |
2958 | const double sin_angle = sin(angle); | |
2959 | ||
ad30de59 GRG |
2960 | // Create new Image to store the result |
2961 | // First, find rectangle that covers the rotated image; to do that, | |
2962 | // rotate the four corners | |
7a632f10 | 2963 | |
b5c91ac6 | 2964 | const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y); |
7a632f10 | 2965 | |
3fff3966 | 2966 | wxRealPoint p1 = wxRotatePoint (0, 0, cos_angle, sin_angle, p0); |
e26d5213 VZ |
2967 | wxRealPoint p2 = wxRotatePoint (0, h, cos_angle, sin_angle, p0); |
2968 | wxRealPoint p3 = wxRotatePoint (w, 0, cos_angle, sin_angle, p0); | |
2969 | wxRealPoint p4 = wxRotatePoint (w, h, cos_angle, sin_angle, p0); | |
7a632f10 | 2970 | |
4e115ed2 VZ |
2971 | int x1a = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x))); |
2972 | int y1a = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y))); | |
2973 | int x2a = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x))); | |
2974 | int y2a = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y))); | |
7a632f10 | 2975 | |
6408deed | 2976 | // Create rotated image |
4e115ed2 | 2977 | wxImage rotated (x2a - x1a + 1, y2a - y1a + 1, false); |
6408deed RR |
2978 | // With alpha channel |
2979 | if (has_alpha) | |
2980 | rotated.SetAlpha(); | |
7a632f10 JS |
2981 | |
2982 | if (offset_after_rotation != NULL) | |
2983 | { | |
4e115ed2 | 2984 | *offset_after_rotation = wxPoint (x1a, y1a); |
7a632f10 JS |
2985 | } |
2986 | ||
e26d5213 VZ |
2987 | // the rotated (destination) image is always accessed sequentially via this |
2988 | // pointer, there is no need for pointer-based arrays here | |
2989 | unsigned char *dst = rotated.GetData(); | |
b713f891 | 2990 | |
e26d5213 | 2991 | unsigned char *alpha_dst = has_alpha ? rotated.GetAlpha() : NULL; |
7a632f10 | 2992 | |
e26d5213 VZ |
2993 | // if the original image has a mask, use its RGB values as the blank pixel, |
2994 | // else, fall back to default (black). | |
b5c91ac6 GRG |
2995 | unsigned char blank_r = 0; |
2996 | unsigned char blank_g = 0; | |
2997 | unsigned char blank_b = 0; | |
ad30de59 GRG |
2998 | |
2999 | if (HasMask()) | |
3000 | { | |
b5c91ac6 GRG |
3001 | blank_r = GetMaskRed(); |
3002 | blank_g = GetMaskGreen(); | |
3003 | blank_b = GetMaskBlue(); | |
3004 | rotated.SetMaskColour( blank_r, blank_g, blank_b ); | |
ad30de59 GRG |
3005 | } |
3006 | ||
3007 | // Now, for each point of the rotated image, find where it came from, by | |
3008 | // performing an inverse rotation (a rotation of -angle) and getting the | |
3009 | // pixel at those coordinates | |
3010 | ||
e26d5213 VZ |
3011 | const int rH = rotated.GetHeight(); |
3012 | const int rW = rotated.GetWidth(); | |
7a632f10 | 3013 | |
e26d5213 VZ |
3014 | // do the (interpolating) test outside of the loops, so that it is done |
3015 | // only once, instead of repeating it for each pixel. | |
b5c91ac6 | 3016 | if (interpolating) |
7a632f10 | 3017 | { |
e26d5213 | 3018 | for (int y = 0; y < rH; y++) |
7a632f10 | 3019 | { |
e26d5213 | 3020 | for (int x = 0; x < rW; x++) |
7a632f10 | 3021 | { |
3fff3966 | 3022 | wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0); |
b5c91ac6 | 3023 | |
e26d5213 VZ |
3024 | if (-0.25 < src.x && src.x < w - 0.75 && |
3025 | -0.25 < src.y && src.y < h - 0.75) | |
7a632f10 | 3026 | { |
ad30de59 GRG |
3027 | // interpolate using the 4 enclosing grid-points. Those |
3028 | // points can be obtained using floor and ceiling of the | |
3029 | // exact coordinates of the point | |
f2506310 JS |
3030 | int x1, y1, x2, y2; |
3031 | ||
e26d5213 | 3032 | if (0 < src.x && src.x < w - 1) |
f2506310 | 3033 | { |
3fff3966 VZ |
3034 | x1 = wxRound(floor(src.x)); |
3035 | x2 = wxRound(ceil(src.x)); | |
f2506310 JS |
3036 | } |
3037 | else // else means that x is near one of the borders (0 or width-1) | |
3038 | { | |
3fff3966 | 3039 | x1 = x2 = wxRound (src.x); |
f2506310 JS |
3040 | } |
3041 | ||
e26d5213 | 3042 | if (0 < src.y && src.y < h - 1) |
f2506310 | 3043 | { |
3fff3966 VZ |
3044 | y1 = wxRound(floor(src.y)); |
3045 | y2 = wxRound(ceil(src.y)); | |
f2506310 JS |
3046 | } |
3047 | else | |
3048 | { | |
3fff3966 | 3049 | y1 = y2 = wxRound (src.y); |
f2506310 | 3050 | } |
7a632f10 | 3051 | |
ad30de59 GRG |
3052 | // get four points and the distances (square of the distance, |
3053 | // for efficiency reasons) for the interpolation formula | |
b5c91ac6 GRG |
3054 | |
3055 | // GRG: Do not calculate the points until they are | |
3056 | // really needed -- this way we can calculate | |
3057 | // just one, instead of four, if d1, d2, d3 | |
3fff3966 | 3058 | // or d4 are < wxROTATE_EPSILON |
7a632f10 JS |
3059 | |
3060 | const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1); | |
3061 | const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1); | |
3062 | const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2); | |
3063 | const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2); | |
3064 | ||
ad30de59 GRG |
3065 | // Now interpolate as a weighted average of the four surrounding |
3066 | // points, where the weights are the distances to each of those points | |
7a632f10 | 3067 | |
ad30de59 GRG |
3068 | // If the point is exactly at one point of the grid of the source |
3069 | // image, then don't interpolate -- just assign the pixel | |
7a632f10 | 3070 | |
3fff3966 VZ |
3071 | // d1,d2,d3,d4 are positive -- no need for abs() |
3072 | if (d1 < wxROTATE_EPSILON) | |
7a632f10 | 3073 | { |
b5c91ac6 GRG |
3074 | unsigned char *p = data[y1] + (3 * x1); |
3075 | *(dst++) = *(p++); | |
3076 | *(dst++) = *(p++); | |
6408deed | 3077 | *(dst++) = *p; |
b713f891 | 3078 | |
6408deed | 3079 | if (has_alpha) |
4e115ed2 | 3080 | *(alpha_dst++) = *(alpha[y1] + x1); |
7a632f10 | 3081 | } |
3fff3966 | 3082 | else if (d2 < wxROTATE_EPSILON) |
7a632f10 | 3083 | { |
b5c91ac6 GRG |
3084 | unsigned char *p = data[y1] + (3 * x2); |
3085 | *(dst++) = *(p++); | |
3086 | *(dst++) = *(p++); | |
6408deed | 3087 | *(dst++) = *p; |
b713f891 | 3088 | |
6408deed | 3089 | if (has_alpha) |
4e115ed2 | 3090 | *(alpha_dst++) = *(alpha[y1] + x2); |
7a632f10 | 3091 | } |
3fff3966 | 3092 | else if (d3 < wxROTATE_EPSILON) |
7a632f10 | 3093 | { |
b5c91ac6 GRG |
3094 | unsigned char *p = data[y2] + (3 * x2); |
3095 | *(dst++) = *(p++); | |
3096 | *(dst++) = *(p++); | |
6408deed | 3097 | *(dst++) = *p; |
b713f891 | 3098 | |
6408deed | 3099 | if (has_alpha) |
4e115ed2 | 3100 | *(alpha_dst++) = *(alpha[y2] + x2); |
7a632f10 | 3101 | } |
3fff3966 | 3102 | else if (d4 < wxROTATE_EPSILON) |
7a632f10 | 3103 | { |
b5c91ac6 GRG |
3104 | unsigned char *p = data[y2] + (3 * x1); |
3105 | *(dst++) = *(p++); | |
3106 | *(dst++) = *(p++); | |
6408deed | 3107 | *(dst++) = *p; |
b713f891 | 3108 | |
6408deed | 3109 | if (has_alpha) |
4e115ed2 | 3110 | *(alpha_dst++) = *(alpha[y2] + x1); |
7a632f10 JS |
3111 | } |
3112 | else | |
3113 | { | |
06b466c7 | 3114 | // weights for the weighted average are proportional to the inverse of the distance |
b5c91ac6 GRG |
3115 | unsigned char *v1 = data[y1] + (3 * x1); |
3116 | unsigned char *v2 = data[y1] + (3 * x2); | |
3117 | unsigned char *v3 = data[y2] + (3 * x2); | |
3118 | unsigned char *v4 = data[y2] + (3 * x1); | |
3119 | ||
06b466c7 VZ |
3120 | const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4; |
3121 | ||
b5c91ac6 GRG |
3122 | // GRG: Unrolled. |
3123 | ||
3124 | *(dst++) = (unsigned char) | |
3125 | ( (w1 * *(v1++) + w2 * *(v2++) + | |
3126 | w3 * *(v3++) + w4 * *(v4++)) / | |
3127 | (w1 + w2 + w3 + w4) ); | |
3128 | *(dst++) = (unsigned char) | |
3129 | ( (w1 * *(v1++) + w2 * *(v2++) + | |
3130 | w3 * *(v3++) + w4 * *(v4++)) / | |
3131 | (w1 + w2 + w3 + w4) ); | |
3132 | *(dst++) = (unsigned char) | |
999836aa VZ |
3133 | ( (w1 * *v1 + w2 * *v2 + |
3134 | w3 * *v3 + w4 * *v4) / | |
b5c91ac6 | 3135 | (w1 + w2 + w3 + w4) ); |
b713f891 | 3136 | |
6408deed RR |
3137 | if (has_alpha) |
3138 | { | |
4e115ed2 VZ |
3139 | v1 = alpha[y1] + (x1); |
3140 | v2 = alpha[y1] + (x2); | |
3141 | v3 = alpha[y2] + (x2); | |
3142 | v4 = alpha[y2] + (x1); | |
6408deed RR |
3143 | |
3144 | *(alpha_dst++) = (unsigned char) | |
3145 | ( (w1 * *v1 + w2 * *v2 + | |
3146 | w3 * *v3 + w4 * *v4) / | |
3147 | (w1 + w2 + w3 + w4) ); | |
3148 | } | |
7a632f10 JS |
3149 | } |
3150 | } | |
3151 | else | |
3152 | { | |
b5c91ac6 GRG |
3153 | *(dst++) = blank_r; |
3154 | *(dst++) = blank_g; | |
3155 | *(dst++) = blank_b; | |
b713f891 | 3156 | |
6408deed RR |
3157 | if (has_alpha) |
3158 | *(alpha_dst++) = 0; | |
7a632f10 JS |
3159 | } |
3160 | } | |
b5c91ac6 GRG |
3161 | } |
3162 | } | |
e26d5213 | 3163 | else // not interpolating |
b5c91ac6 | 3164 | { |
e26d5213 | 3165 | for (int y = 0; y < rH; y++) |
b5c91ac6 | 3166 | { |
e26d5213 | 3167 | for (int x = 0; x < rW; x++) |
7a632f10 | 3168 | { |
3fff3966 | 3169 | wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0); |
b5c91ac6 | 3170 | |
3fff3966 VZ |
3171 | const int xs = wxRound (src.x); // wxRound rounds to the |
3172 | const int ys = wxRound (src.y); // closest integer | |
7a632f10 | 3173 | |
e26d5213 | 3174 | if (0 <= xs && xs < w && 0 <= ys && ys < h) |
7a632f10 | 3175 | { |
b5c91ac6 GRG |
3176 | unsigned char *p = data[ys] + (3 * xs); |
3177 | *(dst++) = *(p++); | |
3178 | *(dst++) = *(p++); | |
999836aa | 3179 | *(dst++) = *p; |
b713f891 | 3180 | |
6408deed | 3181 | if (has_alpha) |
4e115ed2 | 3182 | *(alpha_dst++) = *(alpha[ys] + (xs)); |
7a632f10 JS |
3183 | } |
3184 | else | |
3185 | { | |
b5c91ac6 GRG |
3186 | *(dst++) = blank_r; |
3187 | *(dst++) = blank_g; | |
3188 | *(dst++) = blank_b; | |
b713f891 | 3189 | |
6408deed RR |
3190 | if (has_alpha) |
3191 | *(alpha_dst++) = 255; | |
7a632f10 JS |
3192 | } |
3193 | } | |
3194 | } | |
3195 | } | |
3196 | ||
4aff28fc | 3197 | delete [] data; |
e26d5213 | 3198 | delete [] alpha; |
4aff28fc | 3199 | |
7a632f10 JS |
3200 | return rotated; |
3201 | } | |
c9d01afd | 3202 | |
ef8f37e0 VS |
3203 | |
3204 | ||
3205 | ||
3206 | ||
3207 | // A module to allow wxImage initialization/cleanup | |
3208 | // without calling these functions from app.cpp or from | |
3209 | // the user's application. | |
3210 | ||
3211 | class wxImageModule: public wxModule | |
3212 | { | |
3213 | DECLARE_DYNAMIC_CLASS(wxImageModule) | |
3214 | public: | |
3215 | wxImageModule() {} | |
47b378bd VS |
3216 | bool OnInit() { wxImage::InitStandardHandlers(); return true; } |
3217 | void OnExit() { wxImage::CleanUpHandlers(); } | |
ef8f37e0 VS |
3218 | }; |
3219 | ||
3220 | IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule) | |
3221 | ||
3222 | ||
c96ea657 | 3223 | #endif // wxUSE_IMAGE |