?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
android: Update app-specific/MIME type icons
[LibreOffice.git] / vcl / source / bitmap / BitmapEx.cxx
blobad4adca6319e1b5b3f94fc8816d22747686ed2dc
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/log.hxx>
21 #include <rtl/math.hxx>
22 #include <o3tl/underlyingenumvalue.hxx>
23 #include <osl/diagnose.h>
24 #include <basegfx/matrix/b2dhommatrixtools.hxx>
25 #include <basegfx/color/bcolormodifier.hxx>
26
27 #include <vcl/ImageTree.hxx>
28 #include <vcl/outdev.hxx>
29 #include <vcl/alpha.hxx>
30 #include <vcl/bitmapex.hxx>
31 #include <vcl/svapp.hxx>
32 #include <vcl/virdev.hxx>
33 #include <vcl/settings.hxx>
34 #include <vcl/BitmapMonochromeFilter.hxx>
35
36 // BitmapEx::Create
37 #include <salbmp.hxx>
38 #include <salinst.hxx>
39 #include <svdata.hxx>
40 #include <bitmap/BitmapWriteAccess.hxx>
41 #include <bitmap/BitmapMaskToAlphaFilter.hxx>
42
43 #include <o3tl/any.hxx>
44 #include <tools/stream.hxx>
45 #include <vcl/filter/PngImageWriter.hxx>
46
47 #include <com/sun/star/beans/XFastPropertySet.hpp>
48
49 #include <memory>
50
51 using namespace ::com::sun::star;
52
53 BitmapEx::BitmapEx()
54 {
55 }
56
57 BitmapEx::BitmapEx( const BitmapEx& ) = default;
58
59 BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize )
60 {
61 if( rBitmapEx.IsEmpty() || aSize.IsEmpty() )
62 return;
63
64 maBitmap = Bitmap(aSize, rBitmapEx.maBitmap.getPixelFormat());
65 SetSizePixel(aSize);
66 if( rBitmapEx.IsAlpha() )
67 maAlphaMask = AlphaMask( aSize ).ImplGetBitmap();
68
69 tools::Rectangle aDestRect( Point( 0, 0 ), aSize );
70 tools::Rectangle aSrcRect( aSrc, aSize );
71 CopyPixel( aDestRect, aSrcRect, &rBitmapEx );
72 }
73
74 BitmapEx::BitmapEx(Size aSize, vcl::PixelFormat ePixelFormat)
75 {
76 maBitmap = Bitmap(aSize, ePixelFormat);
77 SetSizePixel(aSize);
78 }
79
80 BitmapEx::BitmapEx( const OUString& rIconName )
81 {
82 loadFromIconTheme( rIconName );
83 }
84
85 void BitmapEx::loadFromIconTheme( const OUString& rIconName )
86 {
87 bool bSuccess;
88 OUString aIconTheme;
89
90 try
91 {
92 aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme();
93 bSuccess = ImageTree::get().loadImage(rIconName, aIconTheme, *this, true);
94 }
95 catch (...)
96 {
97 bSuccess = false;
98 }
99
100 SAL_WARN_IF( !bSuccess, "vcl", "BitmapEx::BitmapEx(): could not load image " << rIconName << " via icon theme " << aIconTheme);
101 }
102
103 BitmapEx::BitmapEx( const Bitmap& rBmp ) :
104 maBitmap ( rBmp ),
105 maBitmapSize ( maBitmap.GetSizePixel() )
106 {
107 }
108
109 BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
110 maBitmap ( rBmp ),
111 maBitmapSize ( maBitmap.GetSizePixel() )
112 {
113 if (rMask.IsEmpty())
114 return;
115
116 if( rMask.getPixelFormat() == vcl::PixelFormat::N8_BPP && rMask.HasGreyPalette8Bit() )
117 maAlphaMask = rMask;
118 else if( rMask.getPixelFormat() == vcl::PixelFormat::N8_BPP )
119 {
120 BitmapEx aMaskEx(rMask);
121 BitmapFilter::Filter(aMaskEx, BitmapMonochromeFilter(255));
122 maAlphaMask = aMaskEx.GetBitmap();
123 }
124 else
125 {
126 // convert to alpha bitmap
127 SAL_WARN( "vcl", "BitmapEx: forced mask to monochrome");
128 BitmapEx aMaskEx(rMask);
129 BitmapFilter::Filter(aMaskEx, BitmapMonochromeFilter(255));
130 maAlphaMask = aMaskEx.GetBitmap();
131 }
132
133 if (!maBitmap.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel())
134 {
135 OSL_ENSURE(false, "Mask size differs from Bitmap size, corrected Mask (!)");
136 maAlphaMask.Scale(maBitmap.GetSizePixel(), BmpScaleFlag::Fast);
137 }
138 }
139
140 BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
141 maBitmap ( rBmp ),
142 maAlphaMask ( rAlphaMask.ImplGetBitmap() ),
143 maBitmapSize ( maBitmap.GetSizePixel() )
144 {
145 if (!maBitmap.IsEmpty() && !maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel())
146 {
147 OSL_ENSURE(false, "Alpha size differs from Bitmap size, corrected Mask (!)");
148 maAlphaMask.Scale(rBmp.GetSizePixel(), BmpScaleFlag::Fast);
149 }
150 }
151
152
153 BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
154 maBitmap ( rBmp ),
155 maBitmapSize ( maBitmap.GetSizePixel() )
156 {
157 maAlphaMask = maBitmap.CreateMask( rTransparentColor );
158
159 SAL_WARN_IF(rBmp.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
160 "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask.");
161 }
162
163
164 BitmapEx& BitmapEx::operator=( const BitmapEx& ) = default;
165
166 bool BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
167 {
168 if (GetSizePixel() != rBitmapEx.GetSizePixel())
169 return false;
170
171 if (maBitmap != rBitmapEx.maBitmap)
172 return false;
173
174 return maAlphaMask == rBitmapEx.maAlphaMask;
175 }
176
177 bool BitmapEx::IsEmpty() const
178 {
179 return( maBitmap.IsEmpty() && maAlphaMask.IsEmpty() );
180 }
181
182 void BitmapEx::SetEmpty()
183 {
184 maBitmap.SetEmpty();
185 maAlphaMask.SetEmpty();
186 }
187
188 void BitmapEx::Clear()
189 {
190 SetEmpty();
191 }
192
193 void BitmapEx::ClearAlpha()
194 {
195 maAlphaMask.SetEmpty();
196 }
197
198 bool BitmapEx::IsAlpha() const
199 {
200 return !maAlphaMask.IsEmpty();
201 }
202
203 const Bitmap& BitmapEx::GetBitmap() const
204 {
205 return maBitmap;
206 }
207
208 Bitmap BitmapEx::GetBitmap( Color aTransparentReplaceColor ) const
209 {
210 Bitmap aRetBmp( maBitmap );
211
212 if( !maAlphaMask.IsEmpty() )
213 {
214 aRetBmp.Replace( maAlphaMask, aTransparentReplaceColor );
215 }
216
217 return aRetBmp;
218 }
219
220 sal_Int64 BitmapEx::GetSizeBytes() const
221 {
222 sal_Int64 nSizeBytes = maBitmap.GetSizeBytes();
223
224 if( !maAlphaMask.IsEmpty() )
225 nSizeBytes += maAlphaMask.GetSizeBytes();
226
227 return nSizeBytes;
228 }
229
230 BitmapChecksum BitmapEx::GetChecksum() const
231 {
232 BitmapChecksum nCrc = maBitmap.GetChecksum();
233
234 if( !maAlphaMask.IsEmpty() )
235 {
236 BitmapChecksumOctetArray aBCOA;
237 BCToBCOA( maAlphaMask.GetChecksum(), aBCOA );
238 nCrc = vcl_get_checksum( nCrc, aBCOA, BITMAP_CHECKSUM_SIZE );
239 }
240
241 return nCrc;
242 }
243
244 void BitmapEx::SetSizePixel(const Size& rNewSize)
245 {
246 maBitmapSize = rNewSize;
247 }
248
249 bool BitmapEx::Invert()
250 {
251 bool bRet = false;
252
253 if (!maBitmap.IsEmpty())
254 bRet = maBitmap.Invert();
255
256 return bRet;
257 }
258
259 bool BitmapEx::Mirror( BmpMirrorFlags nMirrorFlags )
260 {
261 bool bRet = false;
262
263 if( !maBitmap.IsEmpty() )
264 {
265 bRet = maBitmap.Mirror( nMirrorFlags );
266
267 if( bRet && !maAlphaMask.IsEmpty() )
268 maAlphaMask.Mirror( nMirrorFlags );
269 }
270
271 return bRet;
272 }
273
274 bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag )
275 {
276 bool bRet = false;
277
278 if( !maBitmap.IsEmpty() )
279 {
280 bRet = maBitmap.Scale( rScaleX, rScaleY, nScaleFlag );
281
282 if( bRet && !maAlphaMask.IsEmpty() )
283 {
284 maAlphaMask.Scale( rScaleX, rScaleY, nScaleFlag );
285 }
286
287 SetSizePixel(maBitmap.GetSizePixel());
288
289 SAL_WARN_IF( !maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
290 "BitmapEx::Scale(): size mismatch for bitmap and alpha mask." );
291 }
292
293 return bRet;
294 }
295
296 bool BitmapEx::Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag )
297 {
298 bool bRet;
299
300 if (GetSizePixel().Width() && GetSizePixel().Height()
301 && (rNewSize.Width() != GetSizePixel().Width()
302 || rNewSize.Height() != GetSizePixel().Height() ) )
303 {
304 bRet = Scale( static_cast<double>(rNewSize.Width()) / GetSizePixel().Width(),
305 static_cast<double>(rNewSize.Height()) / GetSizePixel().Height(),
306 nScaleFlag );
307 }
308 else
309 {
310 bRet = true;
311 }
312
313 return bRet;
314 }
315
316 bool BitmapEx::Rotate( Degree10 nAngle10, const Color& rFillColor )
317 {
318 bool bRet = false;
319
320 if( !maBitmap.IsEmpty() )
321 {
322 const bool bTransRotate = ( COL_TRANSPARENT == rFillColor );
323
324 if( bTransRotate )
325 {
326 bRet = maBitmap.Rotate( nAngle10, COL_BLACK );
327
328 if( maAlphaMask.IsEmpty() )
329 {
330 maAlphaMask = Bitmap(GetSizePixel(), vcl::PixelFormat::N8_BPP, &Bitmap::GetGreyPalette(256));
331 maAlphaMask.Erase( 0 );
332 }
333
334 if( bRet && !maAlphaMask.IsEmpty() )
335 maAlphaMask.Rotate( nAngle10, COL_WHITE );
336 }
337 else
338 {
339 bRet = maBitmap.Rotate( nAngle10, rFillColor );
340
341 if( bRet && !maAlphaMask.IsEmpty() )
342 maAlphaMask.Rotate( nAngle10, COL_WHITE );
343 }
344
345 SetSizePixel(maBitmap.GetSizePixel());
346
347 SAL_WARN_IF(!maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
348 "BitmapEx::Rotate(): size mismatch for bitmap and alpha mask.");
349 }
350
351 return bRet;
352 }
353
354 bool BitmapEx::Crop( const tools::Rectangle& rRectPixel )
355 {
356 bool bRet = false;
357
358 if( !maBitmap.IsEmpty() )
359 {
360 bRet = maBitmap.Crop( rRectPixel );
361
362 if( bRet && !maAlphaMask.IsEmpty() )
363 maAlphaMask.Crop( rRectPixel );
364
365 SetSizePixel(maBitmap.GetSizePixel());
366
367 SAL_WARN_IF(!maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
368 "BitmapEx::Crop(): size mismatch for bitmap and alpha mask.");
369 }
370
371 return bRet;
372 }
373
374 bool BitmapEx::Convert( BmpConversion eConversion )
375 {
376 return !maBitmap.IsEmpty() && maBitmap.Convert( eConversion );
377 }
378
379 void BitmapEx::Expand( sal_Int32 nDX, sal_Int32 nDY, bool bExpandTransparent )
380 {
381 bool bRet = false;
382
383 if( maBitmap.IsEmpty() )
384 return;
385
386 bRet = maBitmap.Expand( nDX, nDY );
387
388 if( bRet && !maAlphaMask.IsEmpty() )
389 {
390 Color aColor( bExpandTransparent ? COL_WHITE : COL_BLACK );
391 maAlphaMask.Expand( nDX, nDY, &aColor );
392 }
393
394 SetSizePixel(maBitmap.GetSizePixel());
395
396 SAL_WARN_IF(!maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
397 "BitmapEx::Expand(): size mismatch for bitmap and alpha mask.");
398 }
399
400 bool BitmapEx::CopyPixel( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc,
401 const BitmapEx* pBmpExSrc )
402 {
403 bool bRet = false;
404
405 if( !pBmpExSrc || pBmpExSrc->IsEmpty() )
406 {
407 if( !maBitmap.IsEmpty() )
408 {
409 bRet = maBitmap.CopyPixel( rRectDst, rRectSrc );
410
411 if( bRet && !maAlphaMask.IsEmpty() )
412 maAlphaMask.CopyPixel( rRectDst, rRectSrc );
413 }
414 }
415 else
416 {
417 if( !maBitmap.IsEmpty() )
418 {
419 bRet = maBitmap.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->maBitmap );
420
421 if( bRet )
422 {
423 if( pBmpExSrc->IsAlpha() )
424 {
425 if( IsAlpha() )
426 // cast to use the optimized AlphaMask::CopyPixel
427 maAlphaMask.CopyPixel_AlphaOptimized( rRectDst, rRectSrc, &pBmpExSrc->maAlphaMask );
428 else
429 {
430 sal_uInt8 cBlack = 0;
431 std::optional<AlphaMask> pAlpha(std::in_place, GetSizePixel(), &cBlack);
432
433 maAlphaMask = pAlpha->ImplGetBitmap();
434 pAlpha.reset();
435 maAlphaMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->maAlphaMask );
436 }
437 }
438 else if (IsAlpha())
439 {
440 sal_uInt8 cBlack = 0;
441 const AlphaMask aAlphaSrc(pBmpExSrc->GetSizePixel(), &cBlack);
442
443 maAlphaMask.CopyPixel( rRectDst, rRectSrc, &aAlphaSrc.ImplGetBitmap() );
444 }
445 }
446 }
447 }
448
449 return bRet;
450 }
451
452 bool BitmapEx::Erase( const Color& rFillColor )
453 {
454 bool bRet = false;
455
456 if( !maBitmap.IsEmpty() )
457 {
458 bRet = maBitmap.Erase( rFillColor );
459
460 if( bRet && !maAlphaMask.IsEmpty() )
461 {
462 // Respect transparency on fill color
463 if( rFillColor.IsTransparent() )
464 maAlphaMask.Erase( 255 - rFillColor.GetAlpha() );
465 else
466 maAlphaMask.Erase( 0 );
467 }
468 }
469
470 return bRet;
471 }
472
473 void BitmapEx::Replace( const Color& rSearchColor, const Color& rReplaceColor )
474 {
475 if (!maBitmap.IsEmpty())
476 maBitmap.Replace( rSearchColor, rReplaceColor );
477 }
478
479 void BitmapEx::Replace( const Color* pSearchColors, const Color* pReplaceColors, size_t nColorCount )
480 {
481 if (!maBitmap.IsEmpty())
482 maBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, /*pTols*/nullptr );
483 }
484
485 bool BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
486 short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
487 double fGamma, bool bInvert, bool msoBrightness )
488 {
489 return !maBitmap.IsEmpty() && maBitmap.Adjust( nLuminancePercent, nContrastPercent,
490 nChannelRPercent, nChannelGPercent, nChannelBPercent,
491 fGamma, bInvert, msoBrightness );
492 }
493
494 void BitmapEx::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
495 {
496 pOutDev->DrawBitmapEx( rDestPt, *this );
497 }
498
499 void BitmapEx::Draw( OutputDevice* pOutDev,
500 const Point& rDestPt, const Size& rDestSize ) const
501 {
502 pOutDev->DrawBitmapEx( rDestPt, rDestSize, *this );
503 }
504
505 BitmapEx BitmapEx:: AutoScaleBitmap(BitmapEx const & aBitmap, const tools::Long aStandardSize)
506 {
507 Point aEmptyPoint(0,0);
508 double imgposX = 0;
509 double imgposY = 0;
510 BitmapEx aRet = aBitmap;
511 double imgOldWidth = aRet.GetSizePixel().Width();
512 double imgOldHeight = aRet.GetSizePixel().Height();
513
514 if (imgOldWidth >= aStandardSize || imgOldHeight >= aStandardSize)
515 {
516 sal_Int32 imgNewWidth = 0;
517 sal_Int32 imgNewHeight = 0;
518 if (imgOldWidth >= imgOldHeight)
519 {
520 imgNewWidth = aStandardSize;
521 imgNewHeight = sal_Int32(imgOldHeight / (imgOldWidth / aStandardSize) + 0.5);
522 imgposX = 0;
523 imgposY = (aStandardSize - (imgOldHeight / (imgOldWidth / aStandardSize) + 0.5)) / 2 + 0.5;
524 }
525 else
526 {
527 imgNewHeight = aStandardSize;
528 imgNewWidth = sal_Int32(imgOldWidth / (imgOldHeight / aStandardSize) + 0.5);
529 imgposY = 0;
530 imgposX = (aStandardSize - (imgOldWidth / (imgOldHeight / aStandardSize) + 0.5)) / 2 + 0.5;
531 }
532
533 Size aScaledSize( imgNewWidth, imgNewHeight );
534 aRet.Scale( aScaledSize, BmpScaleFlag::BestQuality );
535 }
536 else
537 {
538 imgposX = (aStandardSize - imgOldWidth) / 2 + 0.5;
539 imgposY = (aStandardSize - imgOldHeight) / 2 + 0.5;
540 }
541
542 Size aStdSize( aStandardSize, aStandardSize );
543 tools::Rectangle aRect(aEmptyPoint, aStdSize );
544
545 ScopedVclPtrInstance< VirtualDevice > aVirDevice(*Application::GetDefaultDevice());
546 aVirDevice->SetOutputSizePixel( aStdSize );
547 aVirDevice->SetFillColor( COL_TRANSPARENT );
548 aVirDevice->SetLineColor( COL_TRANSPARENT );
549
550 // Draw a rect into virDevice
551 aVirDevice->DrawRect( aRect );
552 Point aPointPixel( static_cast<tools::Long>(imgposX), static_cast<tools::Long>(imgposY) );
553 aVirDevice->DrawBitmapEx( aPointPixel, aRet );
554 aRet = aVirDevice->GetBitmapEx( aEmptyPoint, aStdSize );
555
556 return aRet;
557 }
558
559 sal_uInt8 BitmapEx::GetAlpha(sal_Int32 nX, sal_Int32 nY) const
560 {
561 if(maBitmap.IsEmpty())
562 return 0;
563
564 if (nX < 0 || nX >= GetSizePixel().Width() || nY < 0 || nY >= GetSizePixel().Height())
565 return 0;
566
567 if (maBitmap.getPixelFormat() == vcl::PixelFormat::N32_BPP)
568 return GetPixelColor(nX, nY).GetAlpha();
569
570 sal_uInt8 nAlpha(0);
571 if (maAlphaMask.IsEmpty())
572 {
573 // Not transparent, ergo all covered
574 nAlpha = 255;
575 }
576 else
577 {
578 Bitmap aTestBitmap(maAlphaMask);
579 Bitmap::ScopedReadAccess pRead(aTestBitmap);
580
581 if(pRead)
582 {
583 const BitmapColor aBitmapColor(pRead->GetPixel(nY, nX));
584 nAlpha = 255 - aBitmapColor.GetIndex();
585 }
586 }
587 return nAlpha;
588 }
589
590
591 Color BitmapEx::GetPixelColor(sal_Int32 nX, sal_Int32 nY) const
592 {
593 Bitmap::ScopedReadAccess pReadAccess( const_cast<Bitmap&>(maBitmap) );
594 assert(pReadAccess);
595
596 BitmapColor aColor = pReadAccess->GetColor(nY, nX);
597
598 if (IsAlpha())
599 {
600 AlphaMask aAlpha = GetAlphaMask();
601 AlphaMask::ScopedReadAccess pAlphaReadAccess(aAlpha);
602 aColor.SetAlpha(255 - pAlphaReadAccess->GetPixel(nY, nX).GetIndex());
603 }
604 else if (maBitmap.getPixelFormat() != vcl::PixelFormat::N32_BPP)
605 {
606 aColor.SetAlpha(255);
607 }
608 return aColor;
609 }
610
611 // Shift alpha transparent pixels between cppcanvas/ implementations
612 // and vcl in a generally grotesque and under-performing fashion
613 bool BitmapEx::Create( const css::uno::Reference< css::rendering::XBitmapCanvas > &xBitmapCanvas,
614 const Size &rSize )
615 {
616 uno::Reference< beans::XFastPropertySet > xFastPropertySet( xBitmapCanvas, uno::UNO_QUERY );
617 if( xFastPropertySet )
618 {
619 // 0 means get BitmapEx
620 uno::Any aAny = xFastPropertySet->getFastPropertyValue( 0 );
621 std::unique_ptr<BitmapEx> xBitmapEx(reinterpret_cast<BitmapEx*>(*o3tl::doAccess<sal_Int64>(aAny)));
622 if( xBitmapEx )
623 {
624 *this = *xBitmapEx;
625 return true;
626 }
627 }
628
629 std::shared_ptr<SalBitmap> pSalBmp;
630 std::shared_ptr<SalBitmap> pSalMask;
631
632 pSalBmp = ImplGetSVData()->mpDefInst->CreateSalBitmap();
633
634 Size aLocalSize(rSize);
635 if( pSalBmp->Create( xBitmapCanvas, aLocalSize ) )
636 {
637 pSalMask = ImplGetSVData()->mpDefInst->CreateSalBitmap();
638 if ( pSalMask->Create( xBitmapCanvas, aLocalSize, true ) )
639 {
640 *this = BitmapEx(Bitmap(pSalBmp), Bitmap(pSalMask) );
641 return true;
642 }
643 else
644 {
645 *this = BitmapEx(Bitmap(pSalBmp));
646 return true;
647 }
648 }
649
650 return false;
651 }
652
653 namespace
654 {
655 Bitmap impTransformBitmap(
656 const Bitmap& rSource,
657 const Size& rDestinationSize,
658 const basegfx::B2DHomMatrix& rTransform,
659 bool bSmooth)
660 {
661 Bitmap aDestination(rDestinationSize, vcl::PixelFormat::N24_BPP);
662 BitmapScopedWriteAccess xWrite(aDestination);
663
664 if(xWrite)
665 {
666 Bitmap::ScopedReadAccess xRead(const_cast< Bitmap& >(rSource));
667
668 if (xRead)
669 {
670 const Size aDestinationSizePixel(aDestination.GetSizePixel());
671 const BitmapColor aOutside(BitmapColor(0xff, 0xff, 0xff));
672
673 for(tools::Long y(0); y < aDestinationSizePixel.getHeight(); y++)
674 {
675 Scanline pScanline = xWrite->GetScanline( y );
676 for(tools::Long x(0); x < aDestinationSizePixel.getWidth(); x++)
677 {
678 const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y));
679
680 if(bSmooth)
681 {
682 xWrite->SetPixelOnData(
683 pScanline,
684 x,
685 xRead->GetInterpolatedColorWithFallback(
686 aSourceCoor.getY(),
687 aSourceCoor.getX(),
688 aOutside));
689 }
690 else
691 {
692 // this version does the correct <= 0.0 checks, so no need
693 // to do the static_cast< sal_Int32 > self and make an error
694 xWrite->SetPixelOnData(
695 pScanline,
696 x,
697 xRead->GetColorWithFallback(
698 aSourceCoor.getY(),
699 aSourceCoor.getX(),
700 aOutside));
701 }
702 }
703 }
704 }
705 }
706 xWrite.reset();
707
708 rSource.AdaptBitCount(aDestination);
709
710 return aDestination;
711 }
712
713 /// Decides if rTransformation needs smoothing or not (e.g. 180 deg rotation doesn't need it).
714 bool implTransformNeedsSmooth(const basegfx::B2DHomMatrix& rTransformation)
715 {
716 basegfx::B2DVector aScale, aTranslate;
717 double fRotate, fShearX;
718 rTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
719 if (aScale != basegfx::B2DVector(1, 1))
720 {
721 return true;
722 }
723
724 fRotate = fmod( fRotate, 2 * M_PI );
725 if (fRotate < 0)
726 {
727 fRotate += 2 * M_PI;
728 }
729 if (!rtl::math::approxEqual(fRotate, 0)
730 && !rtl::math::approxEqual(fRotate, M_PI_2)
731 && !rtl::math::approxEqual(fRotate, M_PI)
732 && !rtl::math::approxEqual(fRotate, 3 * M_PI_2))
733 {
734 return true;
735 }
736
737 if (!rtl::math::approxEqual(fShearX, 0))
738 {
739 return true;
740 }
741
742 return false;
743 }
744 } // end of anonymous namespace
745
746 BitmapEx BitmapEx::TransformBitmapEx(
747 double fWidth,
748 double fHeight,
749 const basegfx::B2DHomMatrix& rTransformation) const
750 {
751 if(fWidth <= 1 || fHeight <= 1)
752 return BitmapEx();
753
754 // force destination to 24 bit, we want to smooth output
755 const Size aDestinationSize(basegfx::fround(fWidth), basegfx::fround(fHeight));
756 bool bSmooth = implTransformNeedsSmooth(rTransformation);
757 const Bitmap aDestination(impTransformBitmap(GetBitmap(), aDestinationSize, rTransformation, bSmooth));
758
759 // create mask
760 if(IsAlpha())
761 {
762 const Bitmap aAlpha(impTransformBitmap(GetAlphaMask().GetBitmap(), aDestinationSize, rTransformation, bSmooth));
763 return BitmapEx(aDestination, AlphaMask(aAlpha));
764 }
765
766 return BitmapEx(aDestination);
767 }
768
769 BitmapEx BitmapEx::getTransformed(
770 const basegfx::B2DHomMatrix& rTransformation,
771 const basegfx::B2DRange& rVisibleRange,
772 double fMaximumArea) const
773 {
774 BitmapEx aRetval;
775
776 if(IsEmpty())
777 return aRetval;
778
779 const sal_uInt32 nSourceWidth(GetSizePixel().Width());
780 const sal_uInt32 nSourceHeight(GetSizePixel().Height());
781
782 if(!nSourceWidth || !nSourceHeight)
783 return aRetval;
784
785 // Get aOutlineRange
786 basegfx::B2DRange aOutlineRange(0.0, 0.0, 1.0, 1.0);
787
788 aOutlineRange.transform(rTransformation);
789
790 // create visible range from it by moving from relative to absolute
791 basegfx::B2DRange aVisibleRange(rVisibleRange);
792
793 aVisibleRange.transform(
794 basegfx::utils::createScaleTranslateB2DHomMatrix(
795 aOutlineRange.getRange(),
796 aOutlineRange.getMinimum()));
797
798 // get target size (which is visible range's size)
799 double fWidth(aVisibleRange.getWidth());
800 double fHeight(aVisibleRange.getHeight());
801
802 if(fWidth < 1.0 || fHeight < 1.0)
803 {
804 return aRetval;
805 }
806
807 // test if discrete size (pixel) maybe too big and limit it
808 const double fArea(fWidth * fHeight);
809 const bool bNeedToReduce(basegfx::fTools::more(fArea, fMaximumArea));
810 double fReduceFactor(1.0);
811
812 if(bNeedToReduce)
813 {
814 fReduceFactor = sqrt(fMaximumArea / fArea);
815 fWidth *= fReduceFactor;
816 fHeight *= fReduceFactor;
817 }
818
819 // Build complete transform from source pixels to target pixels.
820 // Start by scaling from source pixel size to unit coordinates
821 basegfx::B2DHomMatrix aTransform(
822 basegfx::utils::createScaleB2DHomMatrix(
823 1.0 / nSourceWidth,
824 1.0 / nSourceHeight));
825
826 // multiply with given transform which leads from unit coordinates inside
827 // aOutlineRange
828 aTransform = rTransformation * aTransform;
829
830 // subtract top-left of absolute VisibleRange
831 aTransform.translate(
832 -aVisibleRange.getMinX(),
833 -aVisibleRange.getMinY());
834
835 // scale to target pixels (if needed)
836 if(bNeedToReduce)
837 {
838 aTransform.scale(fReduceFactor, fReduceFactor);
839 }
840
841 // invert to get transformation from target pixel coordinates to source pixels
842 aTransform.invert();
843
844 // create bitmap using source, destination and linear back-transformation
845 aRetval = TransformBitmapEx(fWidth, fHeight, aTransform);
846
847 return aRetval;
848 }
849
850 BitmapEx BitmapEx::ModifyBitmapEx(const basegfx::BColorModifierStack& rBColorModifierStack) const
851 {
852 Bitmap aChangedBitmap(GetBitmap());
853 bool bDone(false);
854
855 for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; )
856 {
857 const basegfx::BColorModifierSharedPtr& rModifier = rBColorModifierStack.getBColorModifier(--a);
858 const basegfx::BColorModifier_replace* pReplace = dynamic_cast< const basegfx::BColorModifier_replace* >(rModifier.get());
859
860 if(pReplace)
861 {
862 // complete replace
863 if(IsAlpha())
864 {
865 // clear bitmap with dest color
866 if (vcl::isPalettePixelFormat(aChangedBitmap.getPixelFormat()))
867 {
868 // For e.g. 8bit Bitmaps, the nearest color to the given erase color is
869 // determined and used -> this may be different from what is wanted here.
870 // Better create a new bitmap with the needed color explicitly.
871 Bitmap::ScopedReadAccess xReadAccess(aChangedBitmap);
872 OSL_ENSURE(xReadAccess, "Got no Bitmap ReadAccess ?!?");
873
874 if(xReadAccess)
875 {
876 BitmapPalette aNewPalette(xReadAccess->GetPalette());
877 aNewPalette[0] = BitmapColor(Color(pReplace->getBColor()));
878 aChangedBitmap = Bitmap(
879 aChangedBitmap.GetSizePixel(),
880 aChangedBitmap.getPixelFormat(),
881 &aNewPalette);
882 }
883 }
884 aChangedBitmap.Erase(Color(pReplace->getBColor()));
885 }
886 else
887 {
888 // erase bitmap, caller will know to paint direct
889 aChangedBitmap.SetEmpty();
890 }
891
892 bDone = true;
893 }
894 else
895 {
896 BitmapScopedWriteAccess xContent(aChangedBitmap);
897
898 if(xContent)
899 {
900 const double fConvertColor(1.0 / 255.0);
901
902 if(xContent->HasPalette())
903 {
904 const sal_uInt16 nCount(xContent->GetPaletteEntryCount());
905
906 for(sal_uInt16 b(0); b < nCount; b++)
907 {
908 const BitmapColor& rCol = xContent->GetPaletteColor(b);
909 const basegfx::BColor aBSource(
910 rCol.GetRed() * fConvertColor,
911 rCol.GetGreen() * fConvertColor,
912 rCol.GetBlue() * fConvertColor);
913 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
914 xContent->SetPaletteColor(b, BitmapColor(Color(aBDest)));
915 }
916 }
917 else if(ScanlineFormat::N24BitTcBgr == xContent->GetScanlineFormat())
918 {
919 for(tools::Long y(0); y < xContent->Height(); y++)
920 {
921 Scanline pScan = xContent->GetScanline(y);
922
923 for(tools::Long x(0); x < xContent->Width(); x++)
924 {
925 const basegfx::BColor aBSource(
926 *(pScan + 2)* fConvertColor,
927 *(pScan + 1) * fConvertColor,
928 *pScan * fConvertColor);
929 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
930 *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
931 *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
932 *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
933 }
934 }
935 }
936 else if(ScanlineFormat::N24BitTcRgb == xContent->GetScanlineFormat())
937 {
938 for(tools::Long y(0); y < xContent->Height(); y++)
939 {
940 Scanline pScan = xContent->GetScanline(y);
941
942 for(tools::Long x(0); x < xContent->Width(); x++)
943 {
944 const basegfx::BColor aBSource(
945 *pScan * fConvertColor,
946 *(pScan + 1) * fConvertColor,
947 *(pScan + 2) * fConvertColor);
948 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
949 *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
950 *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
951 *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
952 }
953 }
954 }
955 else
956 {
957 for(tools::Long y(0); y < xContent->Height(); y++)
958 {
959 Scanline pScanline = xContent->GetScanline( y );
960 for(tools::Long x(0); x < xContent->Width(); x++)
961 {
962 const BitmapColor aBMCol(xContent->GetColor(y, x));
963 const basegfx::BColor aBSource(
964 static_cast<double>(aBMCol.GetRed()) * fConvertColor,
965 static_cast<double>(aBMCol.GetGreen()) * fConvertColor,
966 static_cast<double>(aBMCol.GetBlue()) * fConvertColor);
967 const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
968
969 xContent->SetPixelOnData(pScanline, x, BitmapColor(Color(aBDest)));
970 }
971 }
972 }
973 }
974 }
975 }
976
977 if(aChangedBitmap.IsEmpty())
978 {
979 return BitmapEx();
980 }
981 else
982 {
983 if(IsAlpha())
984 {
985 return BitmapEx(aChangedBitmap, GetAlphaMask());
986 }
987 else
988 {
989 return BitmapEx(aChangedBitmap);
990 }
991 }
992 }
993
994 BitmapEx createBlendFrame(
995 const Size& rSize,
996 sal_uInt8 nAlpha,
997 Color aColorTopLeft,
998 Color aColorBottomRight)
999 {
1000 const sal_uInt32 nW(rSize.Width());
1001 const sal_uInt32 nH(rSize.Height());
1002
1003 if(nW || nH)
1004 {
1005 Color aColTopRight(aColorTopLeft);
1006 Color aColBottomLeft(aColorTopLeft);
1007 const sal_uInt32 nDE(nW + nH);
1008
1009 aColTopRight.Merge(aColorBottomRight, 255 - sal_uInt8((nW * 255) / nDE));
1010 aColBottomLeft.Merge(aColorBottomRight, 255 - sal_uInt8((nH * 255) / nDE));
1011
1012 return createBlendFrame(rSize, nAlpha, aColorTopLeft, aColTopRight, aColorBottomRight, aColBottomLeft);
1013 }
1014
1015 return BitmapEx();
1016 }
1017
1018 BitmapEx createBlendFrame(
1019 const Size& rSize,
1020 sal_uInt8 nAlpha,
1021 Color aColorTopLeft,
1022 Color aColorTopRight,
1023 Color aColorBottomRight,
1024 Color aColorBottomLeft)
1025 {
1026 BlendFrameCache* pBlendFrameCache = ImplGetBlendFrameCache();
1027
1028 if(pBlendFrameCache->m_aLastSize == rSize
1029 && pBlendFrameCache->m_nLastAlpha == nAlpha
1030 && pBlendFrameCache->m_aLastColorTopLeft == aColorTopLeft
1031 && pBlendFrameCache->m_aLastColorTopRight == aColorTopRight
1032 && pBlendFrameCache->m_aLastColorBottomRight == aColorBottomRight
1033 && pBlendFrameCache->m_aLastColorBottomLeft == aColorBottomLeft)
1034 {
1035 return pBlendFrameCache->m_aLastResult;
1036 }
1037
1038 pBlendFrameCache->m_aLastSize = rSize;
1039 pBlendFrameCache->m_nLastAlpha = nAlpha;
1040 pBlendFrameCache->m_aLastColorTopLeft = aColorTopLeft;
1041 pBlendFrameCache->m_aLastColorTopRight = aColorTopRight;
1042 pBlendFrameCache->m_aLastColorBottomRight = aColorBottomRight;
1043 pBlendFrameCache->m_aLastColorBottomLeft = aColorBottomLeft;
1044 pBlendFrameCache->m_aLastResult.Clear();
1045
1046 const tools::Long nW(rSize.Width());
1047 const tools::Long nH(rSize.Height());
1048
1049 if(nW > 1 && nH > 1)
1050 {
1051 sal_uInt8 aEraseTrans(0xff);
1052 Bitmap aContent(rSize, vcl::PixelFormat::N24_BPP);
1053 AlphaMask aAlpha(rSize, &aEraseTrans);
1054
1055 aContent.Erase(COL_BLACK);
1056
1057 BitmapScopedWriteAccess pContent(aContent);
1058 AlphaScopedWriteAccess pAlpha(aAlpha);
1059
1060 if(pContent && pAlpha)
1061 {
1062 tools::Long x(0);
1063 tools::Long y(0);
1064 Scanline pScanContent = pContent->GetScanline( 0 );
1065 Scanline pScanAlpha = pContent->GetScanline( 0 );
1066
1067 // x == 0, y == 0, top-left corner
1068 pContent->SetPixelOnData(pScanContent, 0, aColorTopLeft);
1069 pAlpha->SetPixelOnData(pScanAlpha, 0, BitmapColor(nAlpha));
1070
1071 // y == 0, top line left to right
1072 for(x = 1; x < nW - 1; x++)
1073 {
1074 Color aMix(aColorTopLeft);
1075
1076 aMix.Merge(aColorTopRight, 255 - sal_uInt8((x * 255) / nW));
1077 pContent->SetPixelOnData(pScanContent, x, aMix);
1078 pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
1079 }
1080
1081 // x == nW - 1, y == 0, top-right corner
1082 // #i123690# Caution! When nW is 1, x == nW is possible (!)
1083 if(x < nW)
1084 {
1085 pContent->SetPixelOnData(pScanContent, x, aColorTopRight);
1086 pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
1087 }
1088
1089 // x == 0 and nW - 1, left and right line top-down
1090 for(y = 1; y < nH - 1; y++)
1091 {
1092 pScanContent = pContent->GetScanline( y );
1093 pScanAlpha = pContent->GetScanline( y );
1094 Color aMixA(aColorTopLeft);
1095
1096 aMixA.Merge(aColorBottomLeft, 255 - sal_uInt8((y * 255) / nH));
1097 pContent->SetPixelOnData(pScanContent, 0, aMixA);
1098 pAlpha->SetPixelOnData(pScanAlpha, 0, BitmapColor(nAlpha));
1099
1100 // #i123690# Caution! When nW is 1, x == nW is possible (!)
1101 if(x < nW)
1102 {
1103 Color aMixB(aColorTopRight);
1104
1105 aMixB.Merge(aColorBottomRight, 255 - sal_uInt8((y * 255) / nH));
1106 pContent->SetPixelOnData(pScanContent, x, aMixB);
1107 pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
1108 }
1109 }
1110
1111 // #i123690# Caution! When nH is 1, y == nH is possible (!)
1112 if(y < nH)
1113 {
1114 // x == 0, y == nH - 1, bottom-left corner
1115 pContent->SetPixelOnData(pScanContent, 0, aColorBottomLeft);
1116 pAlpha->SetPixelOnData(pScanAlpha, 0, BitmapColor(nAlpha));
1117
1118 // y == nH - 1, bottom line left to right
1119 for(x = 1; x < nW - 1; x++)
1120 {
1121 Color aMix(aColorBottomLeft);
1122
1123 aMix.Merge(aColorBottomRight, 255 - sal_uInt8(((x - 0)* 255) / nW));
1124 pContent->SetPixelOnData(pScanContent, x, aMix);
1125 pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
1126 }
1127
1128 // x == nW - 1, y == nH - 1, bottom-right corner
1129 // #i123690# Caution! When nW is 1, x == nW is possible (!)
1130 if(x < nW)
1131 {
1132 pContent->SetPixelOnData(pScanContent, x, aColorBottomRight);
1133 pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
1134 }
1135 }
1136
1137 pContent.reset();
1138 pAlpha.reset();
1139
1140 pBlendFrameCache->m_aLastResult = BitmapEx(aContent, aAlpha);
1141 }
1142 }
1143
1144 return pBlendFrameCache->m_aLastResult;
1145 }
1146
1147 void BitmapEx::Replace(const Color& rSearchColor,
1148 const Color& rReplaceColor,
1149 sal_uInt8 nTolerance)
1150 {
1151 maBitmap.Replace(rSearchColor, rReplaceColor, nTolerance);
1152 }
1153
1154 void BitmapEx::Replace( const Color* pSearchColors,
1155 const Color* pReplaceColors,
1156 size_t nColorCount,
1157 sal_uInt8 const * pTols )
1158 {
1159 maBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, pTols );
1160 }
1161
1162 void BitmapEx::ReplaceTransparency(const Color& rColor)
1163 {
1164 if( IsAlpha() )
1165 {
1166 maBitmap.Replace( GetAlphaMask(), rColor );
1167 maAlphaMask = Bitmap();
1168 maBitmapSize = maBitmap.GetSizePixel();
1169 }
1170 }
1171
1172 static Bitmap DetectEdges( const Bitmap& rBmp )
1173 {
1174 constexpr sal_uInt8 cEdgeDetectThreshold = 128;
1175 const Size aSize( rBmp.GetSizePixel() );
1176
1177 if( ( aSize.Width() <= 2 ) || ( aSize.Height() <= 2 ) )
1178 return rBmp;
1179
1180 Bitmap aWorkBmp( rBmp );
1181
1182 if( !aWorkBmp.Convert( BmpConversion::N8BitGreys ) )
1183 return rBmp;
1184
1185 ScopedVclPtr<VirtualDevice> pVirDev(VclPtr<VirtualDevice>::Create());
1186 pVirDev->SetOutputSizePixel(aSize);
1187 Bitmap::ScopedReadAccess pReadAcc(aWorkBmp);
1188 if( !pReadAcc )
1189 return rBmp;
1190
1191 const tools::Long nWidth = aSize.Width();
1192 const tools::Long nWidth2 = nWidth - 2;
1193 const tools::Long nHeight = aSize.Height();
1194 const tools::Long nHeight2 = nHeight - 2;
1195 const tools::Long lThres2 = static_cast<tools::Long>(cEdgeDetectThreshold) * cEdgeDetectThreshold;
1196 tools::Long nSum1;
1197 tools::Long nSum2;
1198 tools::Long lGray;
1199
1200 // initialize border with white pixels
1201 pVirDev->SetLineColor( COL_WHITE );
1202 pVirDev->DrawLine( Point(), Point( nWidth - 1, 0L ) );
1203 pVirDev->DrawLine( Point( nWidth - 1, 0L ), Point( nWidth - 1, nHeight - 1 ) );
1204 pVirDev->DrawLine( Point( nWidth - 1, nHeight - 1 ), Point( 0L, nHeight - 1 ) );
1205 pVirDev->DrawLine( Point( 0, nHeight - 1 ), Point() );
1206
1207 for( tools::Long nY = 0, nY1 = 1, nY2 = 2; nY < nHeight2; nY++, nY1++, nY2++ )
1208 {
1209 Scanline pScanlineRead = pReadAcc->GetScanline( nY );
1210 Scanline pScanlineRead1 = pReadAcc->GetScanline( nY1 );
1211 Scanline pScanlineRead2 = pReadAcc->GetScanline( nY2 );
1212 for( tools::Long nX = 0, nXDst = 1, nXTmp; nX < nWidth2; nX++, nXDst++ )
1213 {
1214 nXTmp = nX;
1215
1216 nSum2 = pReadAcc->GetIndexFromData( pScanlineRead, nXTmp++ );
1217 nSum1 = -nSum2;
1218 nSum2 += static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead, nXTmp++ )) << 1;
1219 lGray = pReadAcc->GetIndexFromData( pScanlineRead, nXTmp );
1220 nSum1 += lGray;
1221 nSum2 += lGray;
1222
1223 nSum1 += static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead1, nXTmp )) << 1;
1224 nXTmp -= 2;
1225 nSum1 -= static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead1, nXTmp )) << 1;
1226
1227 lGray = -static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead2, nXTmp++ ));
1228 nSum1 += lGray;
1229 nSum2 += lGray;
1230 nSum2 -= static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead2, nXTmp++ )) << 1;
1231 lGray = static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead2, nXTmp ));
1232 nSum1 += lGray;
1233 nSum2 -= lGray;
1234
1235 if( ( nSum1 * nSum1 + nSum2 * nSum2 ) < lThres2 )
1236 pVirDev->DrawPixel( Point(nXDst, nY), COL_WHITE );
1237 else
1238 pVirDev->DrawPixel( Point(nXDst, nY), COL_BLACK );
1239 }
1240 }
1241
1242 pReadAcc.reset();
1243
1244 Bitmap aRetBmp = pVirDev->GetBitmap(Point(0,0), aSize);
1245
1246 if( aRetBmp.IsEmpty() )
1247 aRetBmp = rBmp;
1248 else
1249 {
1250 aRetBmp.SetPrefMapMode( rBmp.GetPrefMapMode() );
1251 aRetBmp.SetPrefSize( rBmp.GetPrefSize() );
1252 }
1253
1254 return aRetBmp;
1255 }
1256
1257 /** Get contours in image */
1258 tools::Polygon BitmapEx::GetContour( bool bContourEdgeDetect,
1259 const tools::Rectangle* pWorkRectPixel )
1260 {
1261 Bitmap aWorkBmp;
1262 tools::Polygon aRetPoly;
1263 tools::Rectangle aWorkRect( Point(), maBitmap.GetSizePixel() );
1264
1265 if( pWorkRectPixel )
1266 aWorkRect.Intersection( *pWorkRectPixel );
1267
1268 aWorkRect.Normalize();
1269
1270 if( ( aWorkRect.GetWidth() > 4 ) && ( aWorkRect.GetHeight() > 4 ) )
1271 {
1272 // if the flag is set, we need to detect edges
1273 if( bContourEdgeDetect )
1274 aWorkBmp = DetectEdges( maBitmap );
1275 else
1276 aWorkBmp = maBitmap;
1277
1278 BitmapReadAccess* pAcc = aWorkBmp.AcquireReadAccess();
1279
1280 const tools::Long nWidth = pAcc ? pAcc->Width() : 0;
1281 const tools::Long nHeight = pAcc ? pAcc->Height() : 0;
1282
1283 if (pAcc && nWidth && nHeight)
1284 {
1285 const Size& rPrefSize = aWorkBmp.GetPrefSize();
1286 const double fFactorX = static_cast<double>(rPrefSize.Width()) / nWidth;
1287 const double fFactorY = static_cast<double>(rPrefSize.Height()) / nHeight;
1288 const tools::Long nStartX1 = aWorkRect.Left() + 1;
1289 const tools::Long nEndX1 = aWorkRect.Right();
1290 const tools::Long nStartX2 = nEndX1 - 1;
1291 const tools::Long nStartY1 = aWorkRect.Top() + 1;
1292 const tools::Long nEndY1 = aWorkRect.Bottom();
1293 std::unique_ptr<Point[]> pPoints1;
1294 std::unique_ptr<Point[]> pPoints2;
1295 tools::Long nX, nY;
1296 sal_uInt16 nPolyPos = 0;
1297 const BitmapColor aBlack = pAcc->GetBestMatchingColor( COL_BLACK );
1298
1299 pPoints1.reset(new Point[ nHeight ]);
1300 pPoints2.reset(new Point[ nHeight ]);
1301
1302 for ( nY = nStartY1; nY < nEndY1; nY++ )
1303 {
1304 nX = nStartX1;
1305 Scanline pScanline = pAcc->GetScanline( nY );
1306
1307 // scan row from left to right
1308 while( nX < nEndX1 )
1309 {
1310 if( aBlack == pAcc->GetPixelFromData( pScanline, nX ) )
1311 {
1312 pPoints1[ nPolyPos ] = Point( nX, nY );
1313 nX = nStartX2;
1314
1315 // this loop always breaks eventually as there is at least one pixel
1316 while( true )
1317 {
1318 if( aBlack == pAcc->GetPixelFromData( pScanline, nX ) )
1319 {
1320 pPoints2[ nPolyPos ] = Point( nX, nY );
1321 break;
1322 }
1323
1324 nX--;
1325 }
1326
1327 nPolyPos++;
1328 break;
1329 }
1330
1331 nX++;
1332 }
1333 }
1334
1335 const sal_uInt16 nNewSize1 = nPolyPos << 1;
1336
1337 aRetPoly = tools::Polygon( nPolyPos, pPoints1.get() );
1338 aRetPoly.SetSize( nNewSize1 + 1 );
1339 aRetPoly[ nNewSize1 ] = aRetPoly[ 0 ];
1340
1341 for( sal_uInt16 j = nPolyPos; nPolyPos < nNewSize1; )
1342 aRetPoly[ nPolyPos++ ] = pPoints2[ --j ];
1343
1344 if( ( fFactorX != 0. ) && ( fFactorY != 0. ) )
1345 aRetPoly.Scale( fFactorX, fFactorY );
1346 }
1347
1348 Bitmap::ReleaseAccess(pAcc);
1349 }
1350
1351 return aRetPoly;
1352 }
1353
1354 void BitmapEx::ChangeColorAlpha( sal_uInt8 cIndexFrom, sal_Int8 nAlphaTo )
1355 {
1356 AlphaMask aAlphaMask(GetAlphaMask());
1357 BitmapScopedWriteAccess pAlphaWriteAccess(aAlphaMask);
1358 Bitmap::ScopedReadAccess pReadAccess(maBitmap);
1359 assert( pReadAccess.get() && pAlphaWriteAccess.get() );
1360 if ( !(pReadAccess.get() && pAlphaWriteAccess.get()) )
1361 return;
1362
1363 for ( tools::Long nY = 0; nY < pReadAccess->Height(); nY++ )
1364 {
1365 Scanline pScanline = pAlphaWriteAccess->GetScanline( nY );
1366 Scanline pScanlineRead = pReadAccess->GetScanline( nY );
1367 for ( tools::Long nX = 0; nX < pReadAccess->Width(); nX++ )
1368 {
1369 const sal_uInt8 cIndex = pReadAccess->GetPixelFromData( pScanlineRead, nX ).GetIndex();
1370 if ( cIndex == cIndexFrom )
1371 pAlphaWriteAccess->SetPixelOnData( pScanline, nX, BitmapColor(255 - nAlphaTo) );
1372 }
1373 }
1374 *this = BitmapEx( GetBitmap(), aAlphaMask );
1375 }
1376
1377 void BitmapEx::AdjustTransparency(sal_uInt8 cTrans)
1378 {
1379 AlphaMask aAlpha;
1380
1381 if (!IsAlpha())
1382 {
1383 aAlpha = AlphaMask(GetSizePixel(), &cTrans);
1384 }
1385 else
1386 {
1387 aAlpha = GetAlphaMask();
1388 BitmapScopedWriteAccess pA(aAlpha);
1389 assert(pA);
1390
1391 if( !pA )
1392 return;
1393
1394 sal_uLong nTrans = cTrans, nNewTrans;
1395 const tools::Long nWidth = pA->Width(), nHeight = pA->Height();
1396
1397 if( pA->GetScanlineFormat() == ScanlineFormat::N8BitPal )
1398 {
1399 for( tools::Long nY = 0; nY < nHeight; nY++ )
1400 {
1401 Scanline pAScan = pA->GetScanline( nY );
1402
1403 for( tools::Long nX = 0; nX < nWidth; nX++ )
1404 {
1405 nNewTrans = nTrans + *pAScan;
1406 *pAScan++ = static_cast<sal_uInt8>( ( nNewTrans & 0xffffff00 ) ? 255 : nNewTrans );
1407 }
1408 }
1409 }
1410 else
1411 {
1412 BitmapColor aAlphaValue( 0 );
1413
1414 for( tools::Long nY = 0; nY < nHeight; nY++ )
1415 {
1416 Scanline pScanline = pA->GetScanline( nY );
1417 for( tools::Long nX = 0; nX < nWidth; nX++ )
1418 {
1419 nNewTrans = nTrans + pA->GetIndexFromData( pScanline, nX );
1420 aAlphaValue.SetIndex( static_cast<sal_uInt8>( ( nNewTrans & 0xffffff00 ) ? 255 : nNewTrans ) );
1421 pA->SetPixelOnData( pScanline, nX, aAlphaValue );
1422 }
1423 }
1424 }
1425 }
1426 *this = BitmapEx( GetBitmap(), aAlpha );
1427 }
1428
1429 void BitmapEx::CombineMaskOr(Color maskColor, sal_uInt8 nTol)
1430 {
1431 Bitmap aNewMask = maBitmap.CreateMask( maskColor, nTol );
1432 if ( IsAlpha() )
1433 aNewMask.CombineOr( maAlphaMask );
1434 maAlphaMask = aNewMask;
1435 }
1436
1437 /**
1438 * Retrieves the color model data we need for the XImageConsumer stuff.
1439 */
1440 void BitmapEx::GetColorModel(css::uno::Sequence< sal_Int32 >& rRGBPalette,
1441 sal_uInt32& rnRedMask, sal_uInt32& rnGreenMask, sal_uInt32& rnBlueMask, sal_uInt32& rnAlphaMask, sal_uInt32& rnTransparencyIndex,
1442 sal_uInt32& rnWidth, sal_uInt32& rnHeight, sal_uInt8& rnBitCount)
1443 {
1444 Bitmap::ScopedReadAccess pReadAccess( maBitmap );
1445 assert( pReadAccess );
1446
1447 if( pReadAccess->HasPalette() )
1448 {
1449 sal_uInt16 nPalCount = pReadAccess->GetPaletteEntryCount();
1450
1451 if( nPalCount )
1452 {
1453 rRGBPalette = css::uno::Sequence< sal_Int32 >( nPalCount + 1 );
1454
1455 sal_Int32* pTmp = rRGBPalette.getArray();
1456
1457 for( sal_uInt32 i = 0; i < nPalCount; i++, pTmp++ )
1458 {
1459 const BitmapColor& rCol = pReadAccess->GetPaletteColor( static_cast<sal_uInt16>(i) );
1460
1461 *pTmp = static_cast<sal_Int32>(rCol.GetRed()) << sal_Int32(24);
1462 *pTmp |= static_cast<sal_Int32>(rCol.GetGreen()) << sal_Int32(16);
1463 *pTmp |= static_cast<sal_Int32>(rCol.GetBlue()) << sal_Int32(8);
1464 *pTmp |= sal_Int32(0x000000ffL);
1465 }
1466
1467 if( IsAlpha() )
1468 {
1469 // append transparent entry
1470 *pTmp = sal_Int32(0xffffff00L);
1471 rnTransparencyIndex = nPalCount;
1472 nPalCount++;
1473 }
1474 else
1475 rnTransparencyIndex = 0;
1476 }
1477 }
1478 else
1479 {
1480 rnRedMask = 0xff000000UL;
1481 rnGreenMask = 0x00ff0000UL;
1482 rnBlueMask = 0x0000ff00UL;
1483 rnAlphaMask = 0x000000ffUL;
1484 rnTransparencyIndex = 0;
1485 }
1486
1487 rnWidth = pReadAccess->Width();
1488 rnHeight = pReadAccess->Height();
1489 rnBitCount = pReadAccess->GetBitCount();
1490 }
1491
1492 void BitmapEx::DumpAsPng(const char* pFileName) const
1493 {
1494 OUString sPath;
1495 if (pFileName)
1496 {
1497 sPath = OUString::fromUtf8(pFileName);
1498 }
1499 else if (const char* pEnv = std::getenv("VCL_DUMP_BMP_PATH"))
1500 {
1501 sPath = OUString::fromUtf8(pEnv);
1502 }
1503 else
1504 {
1505 sPath = "file:///tmp/bitmap.png";
1506 }
1507 SvFileStream aStream(sPath, StreamMode::STD_READWRITE | StreamMode::TRUNC);
1508 assert(aStream.good());
1509 vcl::PngImageWriter aWriter(aStream);
1510 aWriter.write(*this);
1511 }
1512
1513 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE