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