?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.4.3.2, tag libreoffice-5.4.3.2
[LibreOffice.git] / vcl / source / gdi / bitmap.cxx
blob71d5d73f15abc9aab609883775cc868a87253887
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 <algorithm>
21 #include <rtl/crc.h>
22 #include <tools/stream.hxx>
23 #include <tools/poly.hxx>
24 #include <vcl/salbtype.hxx>
25 #include <vcl/bitmapaccess.hxx>
26 #include <vcl/outdev.hxx>
27 #include <vcl/bitmap.hxx>
28 #include <vcl/bitmapex.hxx>
29 #include <vcl/svapp.hxx>
30 #include <vcl/image.hxx>
31
32 #include <impbmp.hxx>
33 #include <salbmp.hxx>
34 #include <memory>
35
36 Bitmap::Bitmap()
37 {
38 }
39
40 Bitmap::Bitmap(const Bitmap& rBitmap)
41 : mxImpBmp(rBitmap.mxImpBmp)
42 , maPrefMapMode(rBitmap.maPrefMapMode)
43 , maPrefSize(rBitmap.maPrefSize)
44 {
45 }
46
47 Bitmap::Bitmap(SalBitmap* pSalBitmap)
48 : mxImpBmp(new ImpBitmap(pSalBitmap))
49 , maPrefMapMode(MapMode(MapUnit::MapPixel))
50 , maPrefSize(mxImpBmp->ImplGetSize())
51 {
52 }
53
54 Bitmap::Bitmap( const Size& rSizePixel, sal_uInt16 nBitCount, const BitmapPalette* pPal )
55 {
56 if (rSizePixel.Width() && rSizePixel.Height())
57 {
58 BitmapPalette aPal;
59 BitmapPalette* pRealPal = nullptr;
60
61 if( nBitCount <= 8 )
62 {
63 if( !pPal )
64 {
65 if( 1 == nBitCount )
66 {
67 aPal.SetEntryCount( 2 );
68 aPal[ 0 ] = Color( COL_BLACK );
69 aPal[ 1 ] = Color( COL_WHITE );
70 }
71 else if( ( 4 == nBitCount ) || ( 8 == nBitCount ) )
72 {
73 aPal.SetEntryCount( 1 << nBitCount );
74 aPal[ 0 ] = Color( COL_BLACK );
75 aPal[ 1 ] = Color( COL_BLUE );
76 aPal[ 2 ] = Color( COL_GREEN );
77 aPal[ 3 ] = Color( COL_CYAN );
78 aPal[ 4 ] = Color( COL_RED );
79 aPal[ 5 ] = Color( COL_MAGENTA );
80 aPal[ 6 ] = Color( COL_BROWN );
81 aPal[ 7 ] = Color( COL_GRAY );
82 aPal[ 8 ] = Color( COL_LIGHTGRAY );
83 aPal[ 9 ] = Color( COL_LIGHTBLUE );
84 aPal[ 10 ] = Color( COL_LIGHTGREEN );
85 aPal[ 11 ] = Color( COL_LIGHTCYAN );
86 aPal[ 12 ] = Color( COL_LIGHTRED );
87 aPal[ 13 ] = Color( COL_LIGHTMAGENTA );
88 aPal[ 14 ] = Color( COL_YELLOW );
89 aPal[ 15 ] = Color( COL_WHITE );
90
91 // Create dither palette
92 if( 8 == nBitCount )
93 {
94 sal_uInt16 nActCol = 16;
95
96 for( sal_uInt16 nB = 0; nB < 256; nB += 51 )
97 for( sal_uInt16 nG = 0; nG < 256; nG += 51 )
98 for( sal_uInt16 nR = 0; nR < 256; nR += 51 )
99 aPal[ nActCol++ ] = BitmapColor( (sal_uInt8) nR, (sal_uInt8) nG, (sal_uInt8) nB );
100
101 // Set standard Office colors
102 aPal[ nActCol++ ] = BitmapColor( 0, 184, 255 );
103 }
104 }
105 }
106 else
107 pRealPal = const_cast<BitmapPalette*>(pPal);
108 }
109
110 mxImpBmp.reset(new ImpBitmap);
111 mxImpBmp->ImplCreate( rSizePixel, nBitCount, pRealPal ? *pRealPal : aPal );
112 }
113 }
114
115 Bitmap::~Bitmap()
116 {
117 }
118
119 const BitmapPalette& Bitmap::GetGreyPalette( int nEntries )
120 {
121 static BitmapPalette aGreyPalette2;
122 static BitmapPalette aGreyPalette4;
123 static BitmapPalette aGreyPalette16;
124 static BitmapPalette aGreyPalette256;
125
126 // Create greyscale palette with 2, 4, 16 or 256 entries
127 if( 2 == nEntries || 4 == nEntries || 16 == nEntries || 256 == nEntries )
128 {
129 if( 2 == nEntries )
130 {
131 if( !aGreyPalette2.GetEntryCount() )
132 {
133 aGreyPalette2.SetEntryCount( 2 );
134 aGreyPalette2[ 0 ] = BitmapColor( 0, 0, 0 );
135 aGreyPalette2[ 1 ] = BitmapColor( 255, 255, 255 );
136 }
137
138 return aGreyPalette2;
139 }
140 else if( 4 == nEntries )
141 {
142 if( !aGreyPalette4.GetEntryCount() )
143 {
144 aGreyPalette4.SetEntryCount( 4 );
145 aGreyPalette4[ 0 ] = BitmapColor( 0, 0, 0 );
146 aGreyPalette4[ 1 ] = BitmapColor( 85, 85, 85 );
147 aGreyPalette4[ 2 ] = BitmapColor( 170, 170, 170 );
148 aGreyPalette4[ 3 ] = BitmapColor( 255, 255, 255 );
149 }
150
151 return aGreyPalette4;
152 }
153 else if( 16 == nEntries )
154 {
155 if( !aGreyPalette16.GetEntryCount() )
156 {
157 sal_uInt8 cGrey = 0, cGreyInc = 17;
158
159 aGreyPalette16.SetEntryCount( 16 );
160
161 for( sal_uInt16 i = 0; i < 16; i++, cGrey = sal::static_int_cast<sal_uInt8>(cGrey + cGreyInc) )
162 aGreyPalette16[ i ] = BitmapColor( cGrey, cGrey, cGrey );
163 }
164
165 return aGreyPalette16;
166 }
167 else
168 {
169 if( !aGreyPalette256.GetEntryCount() )
170 {
171 aGreyPalette256.SetEntryCount( 256 );
172
173 for( sal_uInt16 i = 0; i < 256; i++ )
174 aGreyPalette256[ i ] = BitmapColor( (sal_uInt8) i, (sal_uInt8) i, (sal_uInt8) i );
175 }
176
177 return aGreyPalette256;
178 }
179 }
180 else
181 {
182 OSL_FAIL( "Bitmap::GetGreyPalette: invalid entry count (2/4/16/256 allowed)" );
183 return aGreyPalette2;
184 }
185 }
186
187 bool BitmapPalette::IsGreyPalette() const
188 {
189 const int nEntryCount = GetEntryCount();
190 if( !nEntryCount ) // NOTE: an empty palette means 1:1 mapping
191 return true;
192 // See above: only certain entry values will result in a valid call to GetGreyPalette
193 if( nEntryCount == 2 || nEntryCount == 4 || nEntryCount == 16 || nEntryCount == 256 )
194 {
195 const BitmapPalette& rGreyPalette = Bitmap::GetGreyPalette( nEntryCount );
196 if( rGreyPalette == *this )
197 return true;
198 }
199
200 bool bRet = false;
201 // TODO: is it worth to compare the entries for the general case?
202 if (nEntryCount == 2)
203 {
204 const BitmapColor& rCol0(maBitmapColor[0]);
205 const BitmapColor& rCol1(maBitmapColor[1]);
206 bRet = rCol0.GetRed() == rCol0.GetGreen() && rCol0.GetRed() == rCol0.GetBlue() &&
207 rCol1.GetRed() == rCol1.GetGreen() && rCol1.GetRed() == rCol1.GetBlue();
208 }
209 return bRet;
210 }
211
212 Bitmap& Bitmap::operator=( const Bitmap& rBitmap )
213 {
214 if (this == &rBitmap)
215 return *this;
216
217 maPrefSize = rBitmap.maPrefSize;
218 maPrefMapMode = rBitmap.maPrefMapMode;
219 mxImpBmp = rBitmap.mxImpBmp;
220
221 return *this;
222 }
223
224 Bitmap& Bitmap::operator=( Bitmap&& rBitmap )
225 {
226 maPrefSize = std::move(rBitmap.maPrefSize);
227 maPrefMapMode = std::move(rBitmap.maPrefMapMode);
228 mxImpBmp = std::move(rBitmap.mxImpBmp);
229
230 return *this;
231 }
232
233 bool Bitmap::IsEqual( const Bitmap& rBmp ) const
234 {
235 return rBmp.mxImpBmp == mxImpBmp || // Includes both are nullptr
236 (rBmp.mxImpBmp && mxImpBmp && mxImpBmp->ImplIsEqual(*rBmp.mxImpBmp));
237 }
238
239 void Bitmap::SetEmpty()
240 {
241 maPrefMapMode = MapMode();
242 maPrefSize = Size();
243 mxImpBmp.reset();
244 }
245
246 Size Bitmap::GetSizePixel() const
247 {
248 return( mxImpBmp ? mxImpBmp->ImplGetSize() : Size() );
249 }
250
251 sal_uInt16 Bitmap::GetBitCount() const
252 {
253 return( mxImpBmp ? mxImpBmp->ImplGetBitCount() : 0 );
254 }
255
256 bool Bitmap::HasGreyPalette() const
257 {
258 const sal_uInt16 nBitCount = GetBitCount();
259 bool bRet = nBitCount == 1;
260
261 ScopedInfoAccess pIAcc(const_cast<Bitmap&>(*this));
262
263 if( pIAcc )
264 {
265 bRet = pIAcc->HasPalette() && pIAcc->GetPalette().IsGreyPalette();
266 }
267
268 return bRet;
269 }
270
271 BitmapChecksum Bitmap::GetChecksum() const
272 {
273 BitmapChecksum nRet = 0;
274
275 if( mxImpBmp )
276 {
277 nRet = mxImpBmp->ImplGetChecksum();
278
279 if (!nRet)
280 {
281 // nRet == 0 => probably, we were not able to acquire
282 // the buffer in SalBitmap::updateChecksum;
283 // so, we need to update the imp bitmap for this bitmap instance
284 // as we do in BitmapInfoAccess::ImplCreate
285 std::shared_ptr<ImpBitmap> xNewImpBmp(new ImpBitmap);
286 if (xNewImpBmp->ImplCreate(*mxImpBmp, GetBitCount()))
287 {
288 Bitmap* pThis = const_cast<Bitmap*>(this);
289 pThis->mxImpBmp = xNewImpBmp;
290 nRet = mxImpBmp->ImplGetChecksum();
291 }
292 }
293 }
294
295 return nRet;
296 }
297
298 void Bitmap::ImplMakeUnique()
299 {
300 if (mxImpBmp && !mxImpBmp.unique())
301 {
302 std::shared_ptr<ImpBitmap> xOldImpBmp = mxImpBmp;
303 mxImpBmp.reset(new ImpBitmap);
304 mxImpBmp->ImplCreate(*xOldImpBmp);
305 }
306 }
307
308 void Bitmap::ImplAssignWithSize( const Bitmap& rBitmap )
309 {
310 const Size aOldSizePix( GetSizePixel() );
311 const Size aNewSizePix( rBitmap.GetSizePixel() );
312 const MapMode aOldMapMode( maPrefMapMode );
313 Size aNewPrefSize;
314
315 if( ( aOldSizePix != aNewSizePix ) && aOldSizePix.Width() && aOldSizePix.Height() )
316 {
317 aNewPrefSize.Width() = FRound( maPrefSize.Width() * aNewSizePix.Width() / aOldSizePix.Width() );
318 aNewPrefSize.Height() = FRound( maPrefSize.Height() * aNewSizePix.Height() / aOldSizePix.Height() );
319 }
320 else
321 aNewPrefSize = maPrefSize;
322
323 *this = rBitmap;
324
325 maPrefSize = aNewPrefSize;
326 maPrefMapMode = aOldMapMode;
327 }
328
329
330 void Bitmap::ImplSetImpBitmap(const std::shared_ptr<ImpBitmap>& xImpBmp)
331 {
332 mxImpBmp = xImpBmp;
333 }
334
335 BitmapInfoAccess* Bitmap::AcquireInfoAccess()
336 {
337 BitmapInfoAccess* pInfoAccess = new BitmapInfoAccess( *this );
338
339 if( !*pInfoAccess )
340 {
341 delete pInfoAccess;
342 pInfoAccess = nullptr;
343 }
344
345 return pInfoAccess;
346 }
347
348 BitmapReadAccess* Bitmap::AcquireReadAccess()
349 {
350 BitmapReadAccess* pReadAccess = new BitmapReadAccess( *this );
351
352 if( !*pReadAccess )
353 {
354 delete pReadAccess;
355 pReadAccess = nullptr;
356 }
357
358 return pReadAccess;
359 }
360
361 BitmapWriteAccess* Bitmap::AcquireWriteAccess()
362 {
363 BitmapWriteAccess* pWriteAccess = new BitmapWriteAccess( *this );
364
365 if( !*pWriteAccess )
366 {
367 delete pWriteAccess;
368 pWriteAccess = nullptr;
369 }
370
371 return pWriteAccess;
372 }
373
374 void Bitmap::ReleaseAccess( BitmapInfoAccess* pBitmapAccess )
375 {
376 delete pBitmapAccess;
377 }
378
379 bool Bitmap::Erase(const Color& rFillColor)
380 {
381 if (IsEmpty())
382 return true;
383
384 Bitmap::ScopedWriteAccess pWriteAcc(*this);
385 bool bRet = false;
386
387 if (pWriteAcc)
388 {
389 const ScanlineFormat nFormat = pWriteAcc->GetScanlineFormat();
390 sal_uInt8 cIndex = 0;
391 bool bFast = false;
392
393 switch (nFormat)
394 {
395 case ScanlineFormat::N1BitMsbPal:
396 case ScanlineFormat::N1BitLsbPal:
397 {
398 cIndex = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex(rFillColor));
399 cIndex = (cIndex ? 255 : 0);
400 bFast = true;
401 }
402 break;
403
404 case ScanlineFormat::N4BitMsnPal:
405 case ScanlineFormat::N4BitLsnPal:
406 {
407 cIndex = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex(rFillColor));
408 cIndex = cIndex | ( cIndex << 4 );
409 bFast = true;
410 }
411 break;
412
413 case ScanlineFormat::N8BitPal:
414 {
415 cIndex = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex(rFillColor));
416 bFast = true;
417 }
418 break;
419
420 case ScanlineFormat::N24BitTcBgr:
421 case ScanlineFormat::N24BitTcRgb:
422 {
423 if (rFillColor.GetRed() == rFillColor.GetGreen() &&
424 rFillColor.GetRed() == rFillColor.GetBlue())
425 {
426 cIndex = rFillColor.GetRed();
427 bFast = true;
428 }
429 else
430 bFast = false;
431 }
432 break;
433
434 default:
435 bFast = false;
436 break;
437 }
438
439 if( bFast )
440 {
441 const sal_uLong nBufSize = pWriteAcc->GetScanlineSize() * pWriteAcc->Height();
442 memset( pWriteAcc->GetBuffer(), cIndex, nBufSize );
443 }
444 else
445 {
446 Point aTmpPoint;
447 const tools::Rectangle aRect( aTmpPoint, Size( pWriteAcc->Width(), pWriteAcc->Height() ) );
448 pWriteAcc->SetFillColor( rFillColor );
449 pWriteAcc->FillRect( aRect );
450 }
451
452 bRet = true;
453 }
454
455 return bRet;
456 }
457
458 bool Bitmap::Invert()
459 {
460 ScopedWriteAccess pAcc(*this);
461 bool bRet = false;
462
463 if( pAcc )
464 {
465 if( pAcc->HasPalette() )
466 {
467 BitmapPalette aBmpPal( pAcc->GetPalette() );
468 const sal_uInt16 nCount = aBmpPal.GetEntryCount();
469
470 for( sal_uInt16 i = 0; i < nCount; i++ )
471 aBmpPal[ i ].Invert();
472
473 pAcc->SetPalette( aBmpPal );
474 }
475 else
476 {
477 const long nWidth = pAcc->Width();
478 const long nHeight = pAcc->Height();
479
480 for( long nX = 0L; nX < nWidth; nX++ )
481 for( long nY = 0L; nY < nHeight; nY++ )
482 pAcc->SetPixel( nY, nX, pAcc->GetPixel( nY, nX ).Invert() );
483 }
484
485 mxImpBmp->ImplInvalidateChecksum();
486 pAcc.reset();
487 bRet = true;
488 }
489
490 return bRet;
491 }
492
493 bool Bitmap::Mirror( BmpMirrorFlags nMirrorFlags )
494 {
495 bool bHorz( nMirrorFlags & BmpMirrorFlags::Horizontal );
496 bool bVert( nMirrorFlags & BmpMirrorFlags::Vertical );
497 bool bRet = false;
498
499 if( bHorz && !bVert )
500 {
501 ScopedWriteAccess pAcc(*this);
502
503 if( pAcc )
504 {
505 const long nWidth = pAcc->Width();
506 const long nHeight = pAcc->Height();
507 const long nWidth1 = nWidth - 1L;
508 const long nWidth_2 = nWidth >> 1L;
509
510 for( long nY = 0L; nY < nHeight; nY++ )
511 {
512 for( long nX = 0L, nOther = nWidth1; nX < nWidth_2; nX++, nOther-- )
513 {
514 const BitmapColor aTemp( pAcc->GetPixel( nY, nX ) );
515
516 pAcc->SetPixel( nY, nX, pAcc->GetPixel( nY, nOther ) );
517 pAcc->SetPixel( nY, nOther, aTemp );
518 }
519 }
520
521 pAcc.reset();
522 bRet = true;
523 }
524 }
525 else if( bVert && !bHorz )
526 {
527 ScopedWriteAccess pAcc(*this);
528
529 if( pAcc )
530 {
531 const long nScanSize = pAcc->GetScanlineSize();
532 std::unique_ptr<sal_uInt8[]> pBuffer(new sal_uInt8[ nScanSize ]);
533 const long nHeight = pAcc->Height();
534 const long nHeight1 = nHeight - 1L;
535 const long nHeight_2 = nHeight >> 1L;
536
537 for( long nY = 0L, nOther = nHeight1; nY < nHeight_2; nY++, nOther-- )
538 {
539 memcpy( pBuffer.get(), pAcc->GetScanline( nY ), nScanSize );
540 memcpy( pAcc->GetScanline( nY ), pAcc->GetScanline( nOther ), nScanSize );
541 memcpy( pAcc->GetScanline( nOther ), pBuffer.get(), nScanSize );
542 }
543
544 pAcc.reset();
545 bRet = true;
546 }
547 }
548 else if( bHorz && bVert )
549 {
550 ScopedWriteAccess pAcc(*this);
551
552 if( pAcc )
553 {
554 const long nWidth = pAcc->Width();
555 const long nWidth1 = nWidth - 1L;
556 const long nHeight = pAcc->Height();
557 long nHeight_2 = nHeight >> 1;
558
559 for( long nY = 0L, nOtherY = nHeight - 1L; nY < nHeight_2; nY++, nOtherY-- )
560 {
561 for( long nX = 0L, nOtherX = nWidth1; nX < nWidth; nX++, nOtherX-- )
562 {
563 const BitmapColor aTemp( pAcc->GetPixel( nY, nX ) );
564
565 pAcc->SetPixel( nY, nX, pAcc->GetPixel( nOtherY, nOtherX ) );
566 pAcc->SetPixel( nOtherY, nOtherX, aTemp );
567 }
568 }
569
570 // ggf. noch mittlere Zeile horizontal spiegeln
571 if( nHeight & 1 )
572 {
573 for( long nX = 0L, nOtherX = nWidth1, nWidth_2 = nWidth >> 1; nX < nWidth_2; nX++, nOtherX-- )
574 {
575 const BitmapColor aTemp( pAcc->GetPixel( nHeight_2, nX ) );
576 pAcc->SetPixel( nHeight_2, nX, pAcc->GetPixel( nHeight_2, nOtherX ) );
577 pAcc->SetPixel( nHeight_2, nOtherX, aTemp );
578 }
579 }
580
581 pAcc.reset();
582 bRet = true;
583 }
584 }
585 else
586 bRet = true;
587
588 return bRet;
589 }
590
591 bool Bitmap::Rotate( long nAngle10, const Color& rFillColor )
592 {
593 bool bRet = false;
594
595 nAngle10 %= 3600L;
596 nAngle10 = ( nAngle10 < 0L ) ? ( 3599L + nAngle10 ) : nAngle10;
597
598 if( !nAngle10 )
599 bRet = true;
600 else if( 1800L == nAngle10 )
601 bRet = Mirror( BmpMirrorFlags::Horizontal | BmpMirrorFlags::Vertical );
602 else
603 {
604 ScopedReadAccess pReadAcc(*this);
605 Bitmap aRotatedBmp;
606
607 if( pReadAcc )
608 {
609 const Size aSizePix( GetSizePixel() );
610
611 if( ( 900L == nAngle10 ) || ( 2700L == nAngle10 ) )
612 {
613 const Size aNewSizePix( aSizePix.Height(), aSizePix.Width() );
614 Bitmap aNewBmp( aNewSizePix, GetBitCount(), &pReadAcc->GetPalette() );
615 ScopedWriteAccess pWriteAcc(aNewBmp);
616
617 if( pWriteAcc )
618 {
619 const long nWidth = aSizePix.Width();
620 const long nWidth1 = nWidth - 1L;
621 const long nHeight = aSizePix.Height();
622 const long nHeight1 = nHeight - 1L;
623 const long nNewWidth = aNewSizePix.Width();
624 const long nNewHeight = aNewSizePix.Height();
625
626 if( 900L == nAngle10 )
627 {
628 for( long nY = 0L, nOtherX = nWidth1; nY < nNewHeight; nY++, nOtherX-- )
629 for( long nX = 0L, nOtherY = 0L; nX < nNewWidth; nX++ )
630 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nOtherY++, nOtherX ) );
631 }
632 else if( 2700L == nAngle10 )
633 {
634 for( long nY = 0L, nOtherX = 0L; nY < nNewHeight; nY++, nOtherX++ )
635 for( long nX = 0L, nOtherY = nHeight1; nX < nNewWidth; nX++ )
636 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nOtherY--, nOtherX ) );
637 }
638
639 pWriteAcc.reset();
640 }
641
642 aRotatedBmp = aNewBmp;
643 }
644 else
645 {
646 Point aTmpPoint;
647 tools::Rectangle aTmpRectangle( aTmpPoint, aSizePix );
648 tools::Polygon aPoly( aTmpRectangle );
649 aPoly.Rotate( aTmpPoint, (sal_uInt16) nAngle10 );
650
651 tools::Rectangle aNewBound( aPoly.GetBoundRect() );
652 const Size aNewSizePix( aNewBound.GetSize() );
653 Bitmap aNewBmp( aNewSizePix, GetBitCount(), &pReadAcc->GetPalette() );
654 ScopedWriteAccess pWriteAcc(aNewBmp);
655
656 if( pWriteAcc )
657 {
658 const BitmapColor aFillColor( pWriteAcc->GetBestMatchingColor( rFillColor ) );
659 const double fCosAngle = cos( nAngle10 * F_PI1800 );
660 const double fSinAngle = sin( nAngle10 * F_PI1800 );
661 const double fXMin = aNewBound.Left();
662 const double fYMin = aNewBound.Top();
663 const long nWidth = aSizePix.Width();
664 const long nHeight = aSizePix.Height();
665 const long nNewWidth = aNewSizePix.Width();
666 const long nNewHeight = aNewSizePix.Height();
667 long nX;
668 long nY;
669 long nRotX;
670 long nRotY;
671 std::unique_ptr<long[]> pCosX(new long[ nNewWidth ]);
672 std::unique_ptr<long[]> pSinX(new long[ nNewWidth ]);
673 std::unique_ptr<long[]> pCosY(new long[ nNewHeight ]);
674 std::unique_ptr<long[]> pSinY(new long[ nNewHeight ]);
675
676 for ( nX = 0; nX < nNewWidth; nX++ )
677 {
678 const double fTmp = ( fXMin + nX ) * 64.;
679
680 pCosX[ nX ] = FRound( fCosAngle * fTmp );
681 pSinX[ nX ] = FRound( fSinAngle * fTmp );
682 }
683
684 for ( nY = 0; nY < nNewHeight; nY++ )
685 {
686 const double fTmp = ( fYMin + nY ) * 64.;
687
688 pCosY[ nY ] = FRound( fCosAngle * fTmp );
689 pSinY[ nY ] = FRound( fSinAngle * fTmp );
690 }
691
692 for( nY = 0L; nY < nNewHeight; nY++ )
693 {
694 long nSinY = pSinY[ nY ];
695 long nCosY = pCosY[ nY ];
696
697 for( nX = 0L; nX < nNewWidth; nX++ )
698 {
699 nRotX = ( pCosX[ nX ] - nSinY ) >> 6;
700 nRotY = ( pSinX[ nX ] + nCosY ) >> 6;
701
702 if ( ( nRotX > -1L ) && ( nRotX < nWidth ) && ( nRotY > -1L ) && ( nRotY < nHeight ) )
703 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nRotY, nRotX ) );
704 else
705 pWriteAcc->SetPixel( nY, nX, aFillColor );
706 }
707 }
708
709 pWriteAcc.reset();
710 }
711
712 aRotatedBmp = aNewBmp;
713 }
714
715 pReadAcc.reset();
716 }
717
718 bRet = !!aRotatedBmp;
719 if( bRet )
720 ImplAssignWithSize( aRotatedBmp );
721 }
722
723 return bRet;
724 };
725
726 bool Bitmap::Crop( const tools::Rectangle& rRectPixel )
727 {
728 const Size aSizePix( GetSizePixel() );
729 tools::Rectangle aRect( rRectPixel );
730 bool bRet = false;
731
732 aRect.Intersection( tools::Rectangle( Point(), aSizePix ) );
733
734 if( !aRect.IsEmpty() && aSizePix != aRect.GetSize())
735 {
736 ScopedReadAccess pReadAcc(*this);
737
738 if( pReadAcc )
739 {
740 Point aTmpPoint;
741 const tools::Rectangle aNewRect( aTmpPoint, aRect.GetSize() );
742 Bitmap aNewBmp( aNewRect.GetSize(), GetBitCount(), &pReadAcc->GetPalette() );
743 ScopedWriteAccess pWriteAcc(aNewBmp);
744
745 if( pWriteAcc )
746 {
747 const long nOldX = aRect.Left();
748 const long nOldY = aRect.Top();
749 const long nNewWidth = aNewRect.GetWidth();
750 const long nNewHeight = aNewRect.GetHeight();
751
752 for( long nY = 0, nY2 = nOldY; nY < nNewHeight; nY++, nY2++ )
753 for( long nX = 0, nX2 = nOldX; nX < nNewWidth; nX++, nX2++ )
754 pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nY2, nX2 ) );
755
756 pWriteAcc.reset();
757 bRet = true;
758 }
759
760 pReadAcc.reset();
761
762 if( bRet )
763 ImplAssignWithSize( aNewBmp );
764 }
765 }
766
767 return bRet;
768 };
769
770 bool Bitmap::CopyPixel( const tools::Rectangle& rRectDst,
771 const tools::Rectangle& rRectSrc, const Bitmap* pBmpSrc )
772 {
773 const Size aSizePix( GetSizePixel() );
774 tools::Rectangle aRectDst( rRectDst );
775 bool bRet = false;
776
777 aRectDst.Intersection( tools::Rectangle( Point(), aSizePix ) );
778
779 if( !aRectDst.IsEmpty() )
780 {
781 if( pBmpSrc && ( *pBmpSrc != *this ) )
782 {
783 Bitmap* pSrc = const_cast<Bitmap*>(pBmpSrc);
784 const Size aCopySizePix( pSrc->GetSizePixel() );
785 tools::Rectangle aRectSrc( rRectSrc );
786 const sal_uInt16 nSrcBitCount = pBmpSrc->GetBitCount();
787 const sal_uInt16 nDstBitCount = GetBitCount();
788
789 if( nSrcBitCount > nDstBitCount )
790 {
791 int nNextIndex = 0;
792
793 if( ( nSrcBitCount == 24 ) && ( nDstBitCount < 24 ) )
794 Convert( BmpConversion::N24Bit );
795 else if( ( nSrcBitCount == 8 ) && ( nDstBitCount < 8 ) )
796 {
797 Convert( BmpConversion::N8BitColors );
798 nNextIndex = 16;
799 }
800 else if( ( nSrcBitCount == 4 ) && ( nDstBitCount < 4 ) )
801 {
802 Convert( BmpConversion::N4BitColors );
803 nNextIndex = 2;
804 }
805
806 if( nNextIndex )
807 {
808 ScopedReadAccess pSrcAcc(*pSrc);
809 ScopedWriteAccess pDstAcc(*this);
810
811 if( pSrcAcc && pDstAcc )
812 {
813 const int nSrcCount = pDstAcc->GetPaletteEntryCount();
814 const int nDstCount = 1 << nDstBitCount;
815
816 for (int i = 0; ( i < nSrcCount ) && ( nNextIndex < nSrcCount ); ++i)
817 {
818 const BitmapColor& rSrcCol = pSrcAcc->GetPaletteColor( (sal_uInt16) i );
819
820 bool bFound = false;
821
822 for (int j = 0; j < nDstCount; ++j)
823 {
824 if( rSrcCol == pDstAcc->GetPaletteColor( (sal_uInt16) j ) )
825 {
826 bFound = true;
827 break;
828 }
829 }
830
831 if( !bFound )
832 pDstAcc->SetPaletteColor( (sal_uInt16) nNextIndex++, rSrcCol );
833 }
834 }
835 }
836 }
837
838 aRectSrc.Intersection( tools::Rectangle( Point(), aCopySizePix ) );
839
840 if( !aRectSrc.IsEmpty() )
841 {
842 ScopedReadAccess pReadAcc(*pSrc);
843
844 if( pReadAcc )
845 {
846 ScopedWriteAccess pWriteAcc(*this);
847
848 if( pWriteAcc )
849 {
850 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
851 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
852 const long nSrcEndX = aRectSrc.Left() + nWidth;
853 const long nSrcEndY = aRectSrc.Top() + nHeight;
854 long nDstY = aRectDst.Top();
855
856 if( pReadAcc->HasPalette() && pWriteAcc->HasPalette() )
857 {
858 const sal_uInt16 nCount = pReadAcc->GetPaletteEntryCount();
859 std::unique_ptr<sal_uInt8[]> pMap(new sal_uInt8[ nCount ]);
860
861 // Create index map for the color table, as the bitmap should be copied
862 // retaining it's color information relatively well
863 for( sal_uInt16 i = 0; i < nCount; i++ )
864 pMap[ i ] = (sal_uInt8) pWriteAcc->GetBestPaletteIndex( pReadAcc->GetPaletteColor( i ) );
865
866 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
867 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
868 pWriteAcc->SetPixelIndex( nDstY, nDstX, pMap[ pReadAcc->GetPixelIndex( nSrcY, nSrcX ) ] );
869 }
870 else if( pReadAcc->HasPalette() )
871 {
872 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
873 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
874 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nSrcY, nSrcX ) ) );
875 }
876 else
877 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
878 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
879 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPixel( nSrcY, nSrcX ) );
880
881 pWriteAcc.reset();
882 bRet = ( nWidth > 0L ) && ( nHeight > 0L );
883 }
884
885 pReadAcc.reset();
886 }
887 }
888 }
889 else
890 {
891 tools::Rectangle aRectSrc( rRectSrc );
892
893 aRectSrc.Intersection( tools::Rectangle( Point(), aSizePix ) );
894
895 if( !aRectSrc.IsEmpty() && ( aRectSrc != aRectDst ) )
896 {
897 ScopedWriteAccess pWriteAcc(*this);
898
899 if( pWriteAcc )
900 {
901 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
902 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
903 const long nSrcX = aRectSrc.Left();
904 const long nSrcY = aRectSrc.Top();
905 const long nSrcEndX1 = nSrcX + nWidth - 1L;
906 const long nSrcEndY1 = nSrcY + nHeight - 1L;
907 const long nDstX = aRectDst.Left();
908 const long nDstY = aRectDst.Top();
909 const long nDstEndX1 = nDstX + nWidth - 1L;
910 const long nDstEndY1 = nDstY + nHeight - 1L;
911
912 if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
913 {
914 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
915 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
916 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
917 }
918 else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
919 {
920 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
921 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
922 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
923 }
924 else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
925 {
926 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
927 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
928 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
929 }
930 else
931 {
932 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
933 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
934 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
935 }
936
937 pWriteAcc.reset();
938 bRet = true;
939 }
940 }
941 }
942 }
943
944 return bRet;
945 }
946
947 bool Bitmap::CopyPixel_AlphaOptimized( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc,
948 const Bitmap* pBmpSrc )
949 {
950 // Note: this code is copied from Bitmap::CopyPixel but avoids any palette lookups
951 // This optimization is possible because the palettes of AlphaMasks are always identical (8bit GreyPalette, see ctor)
952 const Size aSizePix( GetSizePixel() );
953 tools::Rectangle aRectDst( rRectDst );
954 bool bRet = false;
955
956 aRectDst.Intersection( tools::Rectangle( Point(), aSizePix ) );
957
958 if( !aRectDst.IsEmpty() )
959 {
960 if( pBmpSrc && ( *pBmpSrc != *this ) )
961 {
962 Bitmap* pSrc = const_cast<Bitmap*>(pBmpSrc);
963 const Size aCopySizePix( pSrc->GetSizePixel() );
964 tools::Rectangle aRectSrc( rRectSrc );
965
966 aRectSrc.Intersection( tools::Rectangle( Point(), aCopySizePix ) );
967
968 if( !aRectSrc.IsEmpty() )
969 {
970 ScopedReadAccess pReadAcc(*pSrc);
971
972 if( pReadAcc )
973 {
974 ScopedWriteAccess pWriteAcc(*this);
975
976 if( pWriteAcc )
977 {
978 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
979 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
980 const long nSrcEndX = aRectSrc.Left() + nWidth;
981 const long nSrcEndY = aRectSrc.Top() + nHeight;
982 long nDstY = aRectDst.Top();
983
984 for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
985 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
986 pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPixel( nSrcY, nSrcX ) );
987
988 pWriteAcc.reset();
989 bRet = ( nWidth > 0L ) && ( nHeight > 0L );
990 }
991
992 pReadAcc.reset();
993 }
994 }
995 }
996 else
997 {
998 tools::Rectangle aRectSrc( rRectSrc );
999
1000 aRectSrc.Intersection( tools::Rectangle( Point(), aSizePix ) );
1001
1002 if( !aRectSrc.IsEmpty() && ( aRectSrc != aRectDst ) )
1003 {
1004 ScopedWriteAccess pWriteAcc(*this);
1005
1006 if( pWriteAcc )
1007 {
1008 const long nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
1009 const long nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
1010 const long nSrcX = aRectSrc.Left();
1011 const long nSrcY = aRectSrc.Top();
1012 const long nSrcEndX1 = nSrcX + nWidth - 1L;
1013 const long nSrcEndY1 = nSrcY + nHeight - 1L;
1014 const long nDstX = aRectDst.Left();
1015 const long nDstY = aRectDst.Top();
1016 const long nDstEndX1 = nDstX + nWidth - 1L;
1017 const long nDstEndY1 = nDstY + nHeight - 1L;
1018
1019 if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
1020 {
1021 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
1022 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
1023 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1024 }
1025 else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
1026 {
1027 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
1028 for( long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
1029 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1030 }
1031 else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
1032 {
1033 for( long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
1034 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
1035 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1036 }
1037 else
1038 {
1039 for( long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
1040 for( long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
1041 pWriteAcc->SetPixel( nYN, nXN, pWriteAcc->GetPixel( nY, nX ) );
1042 }
1043
1044 pWriteAcc.reset();
1045 bRet = true;
1046 }
1047 }
1048 }
1049 }
1050
1051 return bRet;
1052
1053 }
1054
1055 bool Bitmap::Expand( sal_uLong nDX, sal_uLong nDY, const Color* pInitColor )
1056 {
1057 bool bRet = false;
1058
1059 if( nDX || nDY )
1060 {
1061 const Size aSizePixel( GetSizePixel() );
1062 const long nWidth = aSizePixel.Width();
1063 const long nHeight = aSizePixel.Height();
1064 const Size aNewSize( nWidth + nDX, nHeight + nDY );
1065 ScopedReadAccess pReadAcc(*this);
1066
1067 if( pReadAcc )
1068 {
1069 BitmapPalette aBmpPal( pReadAcc->GetPalette() );
1070 Bitmap aNewBmp( aNewSize, GetBitCount(), &aBmpPal );
1071 ScopedWriteAccess pWriteAcc(aNewBmp);
1072
1073 if( pWriteAcc )
1074 {
1075 BitmapColor aColor;
1076 const long nNewX = nWidth;
1077 const long nNewY = nHeight;
1078 const long nNewWidth = pWriteAcc->Width();
1079 const long nNewHeight = pWriteAcc->Height();
1080 long nX;
1081 long nY;
1082
1083 if( pInitColor )
1084 aColor = pWriteAcc->GetBestMatchingColor( *pInitColor );
1085
1086 for( nY = 0L; nY < nHeight; nY++ )
1087 {
1088 pWriteAcc->CopyScanline( nY, *pReadAcc );
1089
1090 if( pInitColor && nDX )
1091 for( nX = nNewX; nX < nNewWidth; nX++ )
1092 pWriteAcc->SetPixel( nY, nX, aColor );
1093 }
1094
1095 if( pInitColor && nDY )
1096 for( nY = nNewY; nY < nNewHeight; nY++ )
1097 for( nX = 0; nX < nNewWidth; nX++ )
1098 pWriteAcc->SetPixel( nY, nX, aColor );
1099
1100 pWriteAcc.reset();
1101 bRet = true;
1102 }
1103
1104 pReadAcc.reset();
1105
1106 if( bRet )
1107 ImplAssignWithSize( aNewBmp );
1108 }
1109 }
1110
1111 return bRet;
1112 }
1113
1114 Bitmap Bitmap::CreateMask( const Color& rTransColor, sal_uLong nTol ) const
1115 {
1116 ScopedReadAccess pReadAcc(const_cast<Bitmap&>(*this));
1117
1118 if (!nTol && pReadAcc && (pReadAcc->GetScanlineFormat() == ScanlineFormat::N1BitLsbPal || pReadAcc->GetScanlineFormat() == ScanlineFormat::N1BitMsbPal)
1119 && pReadAcc->GetBestMatchingColor(Color(COL_WHITE)) == pReadAcc->GetBestMatchingColor(rTransColor))
1120 {
1121 //if we're a 1 bit pixel already, and the transcolor matches the color that would replace it already already, then just return a copy
1122 return *this;
1123 }
1124
1125 Bitmap aNewBmp(GetSizePixel(), 1);
1126 ScopedWriteAccess pWriteAcc(aNewBmp);
1127 bool bRet = false;
1128
1129 if (pWriteAcc && pReadAcc)
1130 {
1131 const long nWidth = pReadAcc->Width();
1132 const long nHeight = pReadAcc->Height();
1133 const BitmapColor aBlack( pWriteAcc->GetBestMatchingColor( Color( COL_BLACK ) ) );
1134 const BitmapColor aWhite( pWriteAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
1135
1136 if( !nTol )
1137 {
1138 const BitmapColor aTest( pReadAcc->GetBestMatchingColor( rTransColor ) );
1139 long nX, nY;
1140
1141 if( pReadAcc->GetScanlineFormat() == ScanlineFormat::N4BitMsnPal ||
1142 pReadAcc->GetScanlineFormat() == ScanlineFormat::N4BitLsnPal )
1143 {
1144 // optimized for 4Bit-MSN/LSN source palette
1145 const sal_uInt8 cTest = aTest.GetIndex();
1146 const long nShiftInit = ( ( pReadAcc->GetScanlineFormat() == ScanlineFormat::N4BitMsnPal ) ? 4 : 0 );
1147
1148 if( pWriteAcc->GetScanlineFormat() == ScanlineFormat::N1BitMsbPal &&
1149 aWhite.GetIndex() == 1 )
1150 {
1151 // optimized for 1Bit-MSB destination palette
1152 for( nY = 0L; nY < nHeight; nY++ )
1153 {
1154 Scanline pSrc = pReadAcc->GetScanline( nY );
1155 Scanline pDst = pWriteAcc->GetScanline( nY );
1156 long nShift = 0;
1157 for( nX = 0L, nShift = nShiftInit; nX < nWidth; nX++, nShift ^= 4 )
1158 {
1159 if( cTest == ( ( pSrc[ nX >> 1 ] >> nShift ) & 0x0f ) )
1160 pDst[ nX >> 3 ] |= 1 << ( 7 - ( nX & 7 ) );
1161 else
1162 pDst[ nX >> 3 ] &= ~( 1 << ( 7 - ( nX & 7 ) ) );
1163 }
1164 }
1165 }
1166 else
1167 {
1168 for( nY = 0L; nY < nHeight; nY++ )
1169 {
1170 Scanline pSrc = pReadAcc->GetScanline( nY );
1171 long nShift = 0;
1172 for( nX = 0L, nShift = nShiftInit; nX < nWidth; nX++, nShift ^= 4 )
1173 {
1174 if( cTest == ( ( pSrc[ nX >> 1 ] >> nShift ) & 0x0f ) )
1175 pWriteAcc->SetPixel( nY, nX, aWhite );
1176 else
1177 pWriteAcc->SetPixel( nY, nX, aBlack );
1178 }
1179 }
1180 }
1181 }
1182 else if( pReadAcc->GetScanlineFormat() == ScanlineFormat::N8BitPal )
1183 {
1184 // optimized for 8Bit source palette
1185 const sal_uInt8 cTest = aTest.GetIndex();
1186
1187 if( pWriteAcc->GetScanlineFormat() == ScanlineFormat::N1BitMsbPal &&
1188 aWhite.GetIndex() == 1 )
1189 {
1190 // optimized for 1Bit-MSB destination palette
1191 for( nY = 0L; nY < nHeight; nY++ )
1192 {
1193 Scanline pSrc = pReadAcc->GetScanline( nY );
1194 Scanline pDst = pWriteAcc->GetScanline( nY );
1195 for( nX = 0L; nX < nWidth; nX++ )
1196 {
1197 if( cTest == pSrc[ nX ] )
1198 pDst[ nX >> 3 ] |= 1 << ( 7 - ( nX & 7 ) );
1199 else
1200 pDst[ nX >> 3 ] &= ~( 1 << ( 7 - ( nX & 7 ) ) );
1201 }
1202 }
1203 }
1204 else
1205 {
1206 for( nY = 0L; nY < nHeight; nY++ )
1207 {
1208 Scanline pSrc = pReadAcc->GetScanline( nY );
1209 for( nX = 0L; nX < nWidth; nX++ )
1210 {
1211 if( cTest == pSrc[ nX ] )
1212 pWriteAcc->SetPixel( nY, nX, aWhite );
1213 else
1214 pWriteAcc->SetPixel( nY, nX, aBlack );
1215 }
1216 }
1217 }
1218 }
1219 else
1220 {
1221 // not optimized
1222 for( nY = 0L; nY < nHeight; nY++ )
1223 {
1224 for( nX = 0L; nX < nWidth; nX++ )
1225 {
1226 if( aTest == pReadAcc->GetPixel( nY, nX ) )
1227 pWriteAcc->SetPixel( nY, nX, aWhite );
1228 else
1229 pWriteAcc->SetPixel( nY, nX, aBlack );
1230 }
1231 }
1232 }
1233 }
1234 else
1235 {
1236 BitmapColor aCol;
1237 long nR, nG, nB;
1238 const long nMinR = MinMax<long>(rTransColor.GetRed() - nTol, 0, 255);
1239 const long nMaxR = MinMax<long>(rTransColor.GetRed() + nTol, 0, 255);
1240 const long nMinG = MinMax<long>(rTransColor.GetGreen() - nTol, 0, 255);
1241 const long nMaxG = MinMax<long>(rTransColor.GetGreen() + nTol, 0, 255);
1242 const long nMinB = MinMax<long>(rTransColor.GetBlue() - nTol, 0, 255);
1243 const long nMaxB = MinMax<long>(rTransColor.GetBlue() + nTol, 0, 255);
1244
1245 if( pReadAcc->HasPalette() )
1246 {
1247 for( long nY = 0L; nY < nHeight; nY++ )
1248 {
1249 for( long nX = 0L; nX < nWidth; nX++ )
1250 {
1251 aCol = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) );
1252 nR = aCol.GetRed();
1253 nG = aCol.GetGreen();
1254 nB = aCol.GetBlue();
1255
1256 if( nMinR <= nR && nMaxR >= nR &&
1257 nMinG <= nG && nMaxG >= nG &&
1258 nMinB <= nB && nMaxB >= nB )
1259 {
1260 pWriteAcc->SetPixel( nY, nX, aWhite );
1261 }
1262 else
1263 pWriteAcc->SetPixel( nY, nX, aBlack );
1264 }
1265 }
1266 }
1267 else
1268 {
1269 for( long nY = 0L; nY < nHeight; nY++ )
1270 {
1271 for( long nX = 0L; nX < nWidth; nX++ )
1272 {
1273 aCol = pReadAcc->GetPixel( nY, nX );
1274 nR = aCol.GetRed();
1275 nG = aCol.GetGreen();
1276 nB = aCol.GetBlue();
1277
1278 if( nMinR <= nR && nMaxR >= nR &&
1279 nMinG <= nG && nMaxG >= nG &&
1280 nMinB <= nB && nMaxB >= nB )
1281 {
1282 pWriteAcc->SetPixel( nY, nX, aWhite );
1283 }
1284 else
1285 pWriteAcc->SetPixel( nY, nX, aBlack );
1286 }
1287 }
1288 }
1289 }
1290
1291 bRet = true;
1292 }
1293
1294 pWriteAcc.reset();
1295 pReadAcc.reset();
1296
1297 if( bRet )
1298 {
1299 aNewBmp.maPrefSize = maPrefSize;
1300 aNewBmp.maPrefMapMode = maPrefMapMode;
1301 }
1302 else
1303 aNewBmp = Bitmap();
1304
1305 return aNewBmp;
1306 }
1307
1308 vcl::Region Bitmap::CreateRegion( const Color& rColor, const tools::Rectangle& rRect ) const
1309 {
1310 vcl::Region aRegion;
1311 tools::Rectangle aRect( rRect );
1312 ScopedReadAccess pReadAcc(const_cast<Bitmap&>(*this));
1313
1314 aRect.Intersection( tools::Rectangle( Point(), GetSizePixel() ) );
1315 aRect.Justify();
1316
1317 if( pReadAcc )
1318 {
1319 //Rectangle aSubRect;
1320 const long nLeft = aRect.Left();
1321 const long nTop = aRect.Top();
1322 const long nRight = aRect.Right();
1323 const long nBottom = aRect.Bottom();
1324 const BitmapColor aMatch( pReadAcc->GetBestMatchingColor( rColor ) );
1325
1326 //RectangleVector aRectangles;
1327 //aRegion.ImplBeginAddRect();
1328 std::vector< long > aLine;
1329 long nYStart(nTop);
1330 long nY(nTop);
1331
1332 for( ; nY <= nBottom; nY++ )
1333 {
1334 //aSubRect.Top() = aSubRect.Bottom() = nY;
1335 std::vector< long > aNewLine;
1336 long nX(nLeft);
1337
1338 for( ; nX <= nRight; )
1339 {
1340 while( ( nX <= nRight ) && ( aMatch != pReadAcc->GetPixel( nY, nX ) ) )
1341 nX++;
1342
1343 if( nX <= nRight )
1344 {
1345 aNewLine.push_back(nX);
1346 //aSubRect.Left() = nX;
1347
1348 while( ( nX <= nRight ) && ( aMatch == pReadAcc->GetPixel( nY, nX ) ) )
1349 nX++;
1350
1351 //aSubRect.Right() = nX - 1L;
1352 aNewLine.push_back(nX - 1);
1353
1354 //aRegion.ImplAddRect( aSubRect );
1355 //aRectangles.push_back(aSubRect);
1356 //aRegion.Union(aSubRect);
1357 }
1358 }
1359
1360 if(aNewLine != aLine)
1361 {
1362 // need to write aLine, it's different from the next line
1363 if(aLine.size())
1364 {
1365 tools::Rectangle aSubRect;
1366
1367 // enter y values and proceed ystart
1368 aSubRect.Top() = nYStart;
1369 aSubRect.Bottom() = nY ? nY - 1 : 0;
1370
1371 for(size_t a(0); a < aLine.size();)
1372 {
1373 aSubRect.Left() = aLine[a++];
1374 aSubRect.Right() = aLine[a++];
1375 aRegion.Union(aSubRect);
1376 }
1377 }
1378
1379 // copy line as new line
1380 aLine = aNewLine;
1381 nYStart = nY;
1382 }
1383 }
1384
1385 // write last line if used
1386 if(aLine.size())
1387 {
1388 tools::Rectangle aSubRect;
1389
1390 // enter y values
1391 aSubRect.Top() = nYStart;
1392 aSubRect.Bottom() = nY ? nY - 1 : 0;
1393
1394 for(size_t a(0); a < aLine.size();)
1395 {
1396 aSubRect.Left() = aLine[a++];
1397 aSubRect.Right() = aLine[a++];
1398 aRegion.Union(aSubRect);
1399 }
1400 }
1401
1402 //aRegion.ImplEndAddRect();
1403 //aRegion.SetRegionRectangles(aRectangles);
1404
1405 pReadAcc.reset();
1406 }
1407 else
1408 aRegion = aRect;
1409
1410 return aRegion;
1411 }
1412
1413 bool Bitmap::Replace( const Bitmap& rMask, const Color& rReplaceColor )
1414 {
1415 ScopedReadAccess pMaskAcc( const_cast<Bitmap&>(rMask) );
1416 ScopedWriteAccess pAcc(*this);
1417 bool bRet = false;
1418
1419 if( pMaskAcc && pAcc )
1420 {
1421 const long nWidth = std::min( pMaskAcc->Width(), pAcc->Width() );
1422 const long nHeight = std::min( pMaskAcc->Height(), pAcc->Height() );
1423 const BitmapColor aMaskWhite( pMaskAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
1424 BitmapColor aReplace;
1425
1426 if( pAcc->HasPalette() )
1427 {
1428 const sal_uInt16 nActColors = pAcc->GetPaletteEntryCount();
1429 const sal_uInt16 nMaxColors = 1 << pAcc->GetBitCount();
1430
1431 // default to the nearest color
1432 aReplace = pAcc->GetBestMatchingColor( rReplaceColor );
1433
1434 // for paletted images without a matching palette entry
1435 // look for an unused palette entry (NOTE: expensive!)
1436 if( pAcc->GetPaletteColor( aReplace.GetIndex() ) != BitmapColor( rReplaceColor ) )
1437 {
1438 // if the palette has empty entries use the last one
1439 if( nActColors < nMaxColors )
1440 {
1441 pAcc->SetPaletteEntryCount( nActColors + 1 );
1442 pAcc->SetPaletteColor( nActColors, rReplaceColor );
1443 aReplace = BitmapColor( (sal_uInt8) nActColors );
1444 }
1445 else
1446 {
1447 std::unique_ptr<bool[]> pFlags(new bool[ nMaxColors ]);
1448
1449 // Set all entries to false
1450 std::fill( pFlags.get(), pFlags.get()+nMaxColors, false );
1451
1452 for( long nY = 0L; nY < nHeight; nY++ )
1453 for( long nX = 0L; nX < nWidth; nX++ )
1454 pFlags[ pAcc->GetPixelIndex( nY, nX ) ] = true;
1455
1456 for( sal_uInt16 i = 0UL; i < nMaxColors; i++ )
1457 {
1458 // Hurray, we do have an unused entry
1459 if( !pFlags[ i ] )
1460 {
1461 pAcc->SetPaletteColor( i, rReplaceColor );
1462 aReplace = BitmapColor( (sal_uInt8) i );
1463 }
1464 }
1465 }
1466 }
1467 }
1468 else
1469 aReplace = rReplaceColor;
1470
1471 for( long nY = 0L; nY < nHeight; nY++ )
1472 for( long nX = 0L; nX < nWidth; nX++ )
1473 if( pMaskAcc->GetPixel( nY, nX ) == aMaskWhite )
1474 pAcc->SetPixel( nY, nX, aReplace );
1475
1476 bRet = true;
1477 }
1478
1479 return bRet;
1480 }
1481
1482 bool Bitmap::Replace( const AlphaMask& rAlpha, const Color& rMergeColor )
1483 {
1484 Bitmap aNewBmp( GetSizePixel(), 24 );
1485 ScopedReadAccess pAcc(*this);
1486 AlphaMask::ScopedReadAccess pAlphaAcc(const_cast<AlphaMask&>(rAlpha));
1487 ScopedWriteAccess pNewAcc(aNewBmp);
1488 bool bRet = false;
1489
1490 if( pAcc && pAlphaAcc && pNewAcc )
1491 {
1492 BitmapColor aCol;
1493 const long nWidth = std::min( pAlphaAcc->Width(), pAcc->Width() );
1494 const long nHeight = std::min( pAlphaAcc->Height(), pAcc->Height() );
1495
1496 for( long nY = 0L; nY < nHeight; nY++ )
1497 {
1498 for( long nX = 0L; nX < nWidth; nX++ )
1499 {
1500 aCol = pAcc->GetColor( nY, nX );
1501 pNewAcc->SetPixel( nY, nX, aCol.Merge( rMergeColor, 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) );
1502 }
1503 }
1504
1505 bRet = true;
1506 }
1507
1508 pAcc.reset();
1509 pAlphaAcc.reset();
1510 pNewAcc.reset();
1511
1512 if( bRet )
1513 {
1514 const MapMode aMap( maPrefMapMode );
1515 const Size aSize( maPrefSize );
1516
1517 *this = aNewBmp;
1518
1519 maPrefMapMode = aMap;
1520 maPrefSize = aSize;
1521 }
1522
1523 return bRet;
1524 }
1525
1526 bool Bitmap::Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uLong nTol )
1527 {
1528 if( mxImpBmp )
1529 {
1530 // implementation specific replace
1531 std::shared_ptr<ImpBitmap> xImpBmp(new ImpBitmap);
1532 if (xImpBmp->ImplCreate(*mxImpBmp) && xImpBmp->ImplReplace(rSearchColor, rReplaceColor, nTol))
1533 {
1534 ImplSetImpBitmap(xImpBmp);
1535 maPrefMapMode = MapMode( MapUnit::MapPixel );
1536 maPrefSize = xImpBmp->ImplGetSize();
1537 return true;
1538 }
1539 }
1540
1541 // Bitmaps with 1 bit color depth can cause problems
1542 // if they have other entries than black/white in their palette
1543 if( 1 == GetBitCount() )
1544 Convert( BmpConversion::N4BitColors );
1545
1546 ScopedWriteAccess pAcc(*this);
1547 bool bRet = false;
1548
1549 if( pAcc )
1550 {
1551 const long nMinR = MinMax<long>(rSearchColor.GetRed() - nTol, 0, 255);
1552 const long nMaxR = MinMax<long>(rSearchColor.GetRed() + nTol, 0, 255);
1553 const long nMinG = MinMax<long>(rSearchColor.GetGreen() - nTol, 0, 255);
1554 const long nMaxG = MinMax<long>(rSearchColor.GetGreen() + nTol, 0, 255);
1555 const long nMinB = MinMax<long>(rSearchColor.GetBlue() - nTol, 0, 255);
1556 const long nMaxB = MinMax<long>(rSearchColor.GetBlue() + nTol, 0, 255);
1557
1558 if( pAcc->HasPalette() )
1559 {
1560 for( sal_uInt16 i = 0, nPalCount = pAcc->GetPaletteEntryCount(); i < nPalCount; i++ )
1561 {
1562 const BitmapColor& rCol = pAcc->GetPaletteColor( i );
1563
1564 if( nMinR <= rCol.GetRed() && nMaxR >= rCol.GetRed() &&
1565 nMinG <= rCol.GetGreen() && nMaxG >= rCol.GetGreen() &&
1566 nMinB <= rCol.GetBlue() && nMaxB >= rCol.GetBlue() )
1567 {
1568 pAcc->SetPaletteColor( i, rReplaceColor );
1569 }
1570 }
1571 }
1572 else
1573 {
1574 BitmapColor aCol;
1575 const BitmapColor aReplace( pAcc->GetBestMatchingColor( rReplaceColor ) );
1576
1577 for( long nY = 0L, nHeight = pAcc->Height(); nY < nHeight; nY++ )
1578 {
1579 for( long nX = 0L, nWidth = pAcc->Width(); nX < nWidth; nX++ )
1580 {
1581 aCol = pAcc->GetPixel( nY, nX );
1582
1583 if( nMinR <= aCol.GetRed() && nMaxR >= aCol.GetRed() &&
1584 nMinG <= aCol.GetGreen() && nMaxG >= aCol.GetGreen() &&
1585 nMinB <= aCol.GetBlue() && nMaxB >= aCol.GetBlue() )
1586 {
1587 pAcc->SetPixel( nY, nX, aReplace );
1588 }
1589 }
1590 }
1591 }
1592
1593 pAcc.reset();
1594 bRet = true;
1595 }
1596
1597 return bRet;
1598 }
1599
1600 bool Bitmap::Replace( const Color* pSearchColors, const Color* pReplaceColors,
1601 sal_uLong nColorCount, sal_uLong* _pTols )
1602 {
1603 // Bitmaps with 1 bit color depth can cause problems
1604 // if they have other entries than black/white in their palette
1605 if( 1 == GetBitCount() )
1606 Convert( BmpConversion::N4BitColors );
1607
1608 ScopedWriteAccess pAcc(*this);
1609 bool bRet = false;
1610
1611 if( pAcc )
1612 {
1613 std::unique_ptr<long[]> pMinR(new long[ nColorCount ]);
1614 std::unique_ptr<long[]> pMaxR(new long[ nColorCount ]);
1615 std::unique_ptr<long[]> pMinG(new long[ nColorCount ]);
1616 std::unique_ptr<long[]> pMaxG(new long[ nColorCount ]);
1617 std::unique_ptr<long[]> pMinB(new long[ nColorCount ]);
1618 std::unique_ptr<long[]> pMaxB(new long[ nColorCount ]);
1619 long* pTols;
1620 sal_uLong i;
1621
1622 if( !_pTols )
1623 {
1624 pTols = new long[ nColorCount ];
1625 memset( pTols, 0, nColorCount * sizeof( long ) );
1626 }
1627 else
1628 pTols = reinterpret_cast<long*>(_pTols);
1629
1630 for( i = 0UL; i < nColorCount; i++ )
1631 {
1632 const Color& rCol = pSearchColors[ i ];
1633 const long nTol = pTols[ i ];
1634
1635 pMinR[ i ] = MinMax<long>(rCol.GetRed() - nTol, 0, 255);
1636 pMaxR[ i ] = MinMax<long>(rCol.GetRed() + nTol, 0, 255);
1637 pMinG[ i ] = MinMax<long>(rCol.GetGreen() - nTol, 0, 255);
1638 pMaxG[ i ] = MinMax<long>(rCol.GetGreen() + nTol, 0, 255);
1639 pMinB[ i ] = MinMax<long>(rCol.GetBlue() - nTol, 0, 255);
1640 pMaxB[ i ] = MinMax<long>(rCol.GetBlue() + nTol, 0, 255);
1641 }
1642
1643 if( pAcc->HasPalette() )
1644 {
1645 for( sal_uInt16 nEntry = 0, nPalCount = pAcc->GetPaletteEntryCount(); nEntry < nPalCount; nEntry++ )
1646 {
1647 const BitmapColor& rCol = pAcc->GetPaletteColor( nEntry );
1648
1649 for( i = 0UL; i < nColorCount; i++ )
1650 {
1651 if( pMinR[ i ] <= rCol.GetRed() && pMaxR[ i ] >= rCol.GetRed() &&
1652 pMinG[ i ] <= rCol.GetGreen() && pMaxG[ i ] >= rCol.GetGreen() &&
1653 pMinB[ i ] <= rCol.GetBlue() && pMaxB[ i ] >= rCol.GetBlue() )
1654 {
1655 pAcc->SetPaletteColor( nEntry, pReplaceColors[ i ] );
1656 break;
1657 }
1658 }
1659 }
1660 }
1661 else
1662 {
1663 BitmapColor aCol;
1664 std::unique_ptr<BitmapColor[]> pReplaces(new BitmapColor[ nColorCount ]);
1665
1666 for( i = 0UL; i < nColorCount; i++ )
1667 pReplaces[ i ] = pAcc->GetBestMatchingColor( pReplaceColors[ i ] );
1668
1669 for( long nY = 0L, nHeight = pAcc->Height(); nY < nHeight; nY++ )
1670 {
1671 for( long nX = 0L, nWidth = pAcc->Width(); nX < nWidth; nX++ )
1672 {
1673 aCol = pAcc->GetPixel( nY, nX );
1674
1675 for( i = 0UL; i < nColorCount; i++ )
1676 {
1677 if( pMinR[ i ] <= aCol.GetRed() && pMaxR[ i ] >= aCol.GetRed() &&
1678 pMinG[ i ] <= aCol.GetGreen() && pMaxG[ i ] >= aCol.GetGreen() &&
1679 pMinB[ i ] <= aCol.GetBlue() && pMaxB[ i ] >= aCol.GetBlue() )
1680 {
1681 pAcc->SetPixel( nY, nX, pReplaces[ i ] );
1682 break;
1683 }
1684 }
1685 }
1686 }
1687 }
1688
1689 if( !_pTols )
1690 delete[] pTols;
1691
1692 pAcc.reset();
1693 bRet = true;
1694 }
1695
1696 return bRet;
1697 }
1698
1699 Bitmap Bitmap::CreateDisplayBitmap( OutputDevice* pDisplay )
1700 {
1701 Bitmap aDispBmp( *this );
1702
1703 SalGraphics* pDispGraphics = pDisplay->GetGraphics();
1704
1705 if( mxImpBmp && pDispGraphics )
1706 {
1707 std::shared_ptr<ImpBitmap> xImpDispBmp(new ImpBitmap);
1708 if (xImpDispBmp->ImplCreate(*mxImpBmp, pDispGraphics))
1709 aDispBmp.ImplSetImpBitmap(xImpDispBmp);
1710 }
1711
1712 return aDispBmp;
1713 }
1714
1715 bool Bitmap::CombineSimple( const Bitmap& rMask, BmpCombine eCombine )
1716 {
1717 ScopedReadAccess pMaskAcc(const_cast<Bitmap&>(rMask));
1718 ScopedWriteAccess pAcc(*this);
1719 bool bRet = false;
1720
1721 if( pMaskAcc && pAcc )
1722 {
1723 const long nWidth = std::min( pMaskAcc->Width(), pAcc->Width() );
1724 const long nHeight = std::min( pMaskAcc->Height(), pAcc->Height() );
1725 const Color aColBlack( COL_BLACK );
1726 BitmapColor aPixel;
1727 BitmapColor aMaskPixel;
1728 const BitmapColor aWhite( pAcc->GetBestMatchingColor( Color( COL_WHITE ) ) );
1729 const BitmapColor aBlack( pAcc->GetBestMatchingColor( aColBlack ) );
1730 const BitmapColor aMaskBlack( pMaskAcc->GetBestMatchingColor( aColBlack ) );
1731
1732 switch( eCombine )
1733 {
1734 case BmpCombine::And:
1735 {
1736 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1737 {
1738 if( pMaskAcc->GetPixel( nY, nX ) != aMaskBlack && pAcc->GetPixel( nY, nX ) != aBlack )
1739 pAcc->SetPixel( nY, nX, aWhite );
1740 else
1741 pAcc->SetPixel( nY, nX, aBlack );
1742 }
1743 }
1744 break;
1745
1746 case BmpCombine::Or:
1747 {
1748 for( long nY = 0L; nY < nHeight; nY++ ) for( long nX = 0L; nX < nWidth; nX++ )
1749 {
1750 if( pMaskAcc->GetPixel( nY, nX ) != aMaskBlack || pAcc->GetPixel( nY, nX ) != aBlack )
1751 pAcc->SetPixel( nY, nX, aWhite );
1752 else
1753 pAcc->SetPixel( nY, nX, aBlack );
1754 }
1755 }
1756 break;
1757
1758 }
1759
1760 bRet = true;
1761 }
1762
1763 return bRet;
1764 }
1765
1766 // TODO: Have a look at OutputDevice::ImplDrawAlpha() for some
1767 // optimizations. Might even consolidate the code here and there.
1768 bool Bitmap::Blend( const AlphaMask& rAlpha, const Color& rBackgroundColor )
1769 {
1770 // Convert to a truecolor bitmap, if we're a paletted one. There's
1771 // room for tradeoff decision here, maybe later for an overload (or a flag)
1772 if( GetBitCount() <= 8 )
1773 Convert( BmpConversion::N24Bit );
1774
1775 AlphaMask::ScopedReadAccess pAlphaAcc(const_cast<AlphaMask&>(rAlpha));
1776
1777 ScopedWriteAccess pAcc(*this);
1778 bool bRet = false;
1779
1780 if( pAlphaAcc && pAcc )
1781 {
1782 const long nWidth = std::min( pAlphaAcc->Width(), pAcc->Width() );
1783 const long nHeight = std::min( pAlphaAcc->Height(), pAcc->Height() );
1784
1785 for( long nY = 0L; nY < nHeight; ++nY )
1786 for( long nX = 0L; nX < nWidth; ++nX )
1787 pAcc->SetPixel( nY, nX,
1788 pAcc->GetPixel( nY, nX ).Merge( rBackgroundColor,
1789 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) );
1790
1791 bRet = true;
1792 }
1793
1794 return bRet;
1795 }
1796
1797 bool Bitmap::MakeMono( sal_uInt8 cThreshold )
1798 {
1799 return ImplMakeMono( cThreshold );
1800 }
1801
1802 bool Bitmap::GetSystemData( BitmapSystemData& rData ) const
1803 {
1804 bool bRet = false;
1805 if (mxImpBmp)
1806 {
1807 SalBitmap* pSalBitmap = mxImpBmp->ImplGetSalBitmap();
1808 if( pSalBitmap )
1809 bRet = pSalBitmap->GetSystemData( rData );
1810 }
1811
1812 return bRet;
1813 }
1814
1815 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE