Line data Source code
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 <vclhelperbitmaptransform.hxx>
21 : #include <vcl/bmpacc.hxx>
22 : #include <basegfx/point/b2dpoint.hxx>
23 : #include <basegfx/color/bcolormodifier.hxx>
24 :
25 : //////////////////////////////////////////////////////////////////////////////
26 : // support for rendering Bitmap and BitmapEx contents
27 :
28 : namespace drawinglayer
29 : {
30 : namespace
31 : {
32 0 : void impSmoothPoint(BitmapColor& rValue, const basegfx::B2DPoint& rSource, sal_Int32 nIntX, sal_Int32 nIntY, BitmapReadAccess& rRead)
33 : {
34 0 : double fDeltaX(rSource.getX() - nIntX);
35 0 : double fDeltaY(rSource.getY() - nIntY);
36 0 : sal_Int32 nIndX(0L);
37 0 : sal_Int32 nIndY(0L);
38 :
39 0 : if(fDeltaX > 0.0 && nIntX + 1L < rRead.Width())
40 : {
41 0 : nIndX++;
42 : }
43 0 : else if(fDeltaX < 0.0 && nIntX >= 1L)
44 : {
45 0 : fDeltaX = -fDeltaX;
46 0 : nIndX--;
47 : }
48 :
49 0 : if(fDeltaY > 0.0 && nIntY + 1L < rRead.Height())
50 : {
51 0 : nIndY++;
52 : }
53 0 : else if(fDeltaY < 0.0 && nIntY >= 1L)
54 : {
55 0 : fDeltaY = -fDeltaY;
56 0 : nIndY--;
57 : }
58 :
59 0 : if(nIndX || nIndY)
60 : {
61 0 : const double fColorToReal(1.0 / 255.0);
62 0 : double fR(rValue.GetRed() * fColorToReal);
63 0 : double fG(rValue.GetGreen() * fColorToReal);
64 0 : double fB(rValue.GetBlue() * fColorToReal);
65 0 : double fRBottom(0.0), fGBottom(0.0), fBBottom(0.0);
66 :
67 0 : if(nIndX)
68 : {
69 0 : const double fMulA(fDeltaX * fColorToReal);
70 0 : double fMulB(1.0 - fDeltaX);
71 0 : const BitmapColor aTopPartner(rRead.GetColor(nIntY, nIntX + nIndX));
72 :
73 0 : fR = (fR * fMulB) + (aTopPartner.GetRed() * fMulA);
74 0 : fG = (fG * fMulB) + (aTopPartner.GetGreen() * fMulA);
75 0 : fB = (fB * fMulB) + (aTopPartner.GetBlue() * fMulA);
76 :
77 0 : if(nIndY)
78 : {
79 0 : fMulB *= fColorToReal;
80 0 : const BitmapColor aBottom(rRead.GetColor(nIntY + nIndY, nIntX));
81 0 : const BitmapColor aBottomPartner(rRead.GetColor(nIntY + nIndY, nIntX + nIndX));
82 :
83 0 : fRBottom = (aBottom.GetRed() * fMulB) + (aBottomPartner.GetRed() * fMulA);
84 0 : fGBottom = (aBottom.GetGreen() * fMulB) + (aBottomPartner.GetGreen() * fMulA);
85 0 : fBBottom = (aBottom.GetBlue() * fMulB) + (aBottomPartner.GetBlue() * fMulA);
86 0 : }
87 : }
88 :
89 0 : if(nIndY)
90 : {
91 0 : if(!nIndX)
92 : {
93 0 : const BitmapColor aBottom(rRead.GetColor(nIntY + nIndY, nIntX));
94 :
95 0 : fRBottom = aBottom.GetRed() * fColorToReal;
96 0 : fGBottom = aBottom.GetGreen() * fColorToReal;
97 0 : fBBottom = aBottom.GetBlue() * fColorToReal;
98 : }
99 :
100 0 : const double fMulB(1.0 - fDeltaY);
101 :
102 0 : fR = (fR * fMulB) + (fRBottom * fDeltaY);
103 0 : fG = (fG * fMulB) + (fGBottom * fDeltaY);
104 0 : fB = (fB * fMulB) + (fBBottom * fDeltaY);
105 : }
106 :
107 0 : rValue.SetRed((sal_uInt8)(fR * 255.0));
108 0 : rValue.SetGreen((sal_uInt8)(fG * 255.0));
109 0 : rValue.SetBlue((sal_uInt8)(fB * 255.0));
110 : }
111 0 : }
112 :
113 0 : void impSmoothIndex(BitmapColor& rValue, const basegfx::B2DPoint& rSource, sal_Int32 nIntX, sal_Int32 nIntY, BitmapReadAccess& rRead)
114 : {
115 0 : double fDeltaX(rSource.getX() - nIntX);
116 0 : double fDeltaY(rSource.getY() - nIntY);
117 0 : sal_Int32 nIndX(0L);
118 0 : sal_Int32 nIndY(0L);
119 :
120 0 : if(fDeltaX > 0.0 && nIntX + 1L < rRead.Width())
121 : {
122 0 : nIndX++;
123 : }
124 0 : else if(fDeltaX < 0.0 && nIntX >= 1L)
125 : {
126 0 : fDeltaX = -fDeltaX;
127 0 : nIndX--;
128 : }
129 :
130 0 : if(fDeltaY > 0.0 && nIntY + 1L < rRead.Height())
131 : {
132 0 : nIndY++;
133 : }
134 0 : else if(fDeltaY < 0.0 && nIntY >= 1L)
135 : {
136 0 : fDeltaY = -fDeltaY;
137 0 : nIndY--;
138 : }
139 :
140 0 : if(nIndX || nIndY)
141 : {
142 0 : const double fColorToReal(1.0 / 255.0);
143 0 : double fVal(rValue.GetIndex() * fColorToReal);
144 0 : double fValBottom(0.0);
145 :
146 0 : if(nIndX)
147 : {
148 0 : const double fMulA(fDeltaX * fColorToReal);
149 0 : double fMulB(1.0 - fDeltaX);
150 0 : const BitmapColor aTopPartner(rRead.GetPixel(nIntY, nIntX + nIndX));
151 :
152 0 : fVal = (fVal * fMulB) + (aTopPartner.GetIndex() * fMulA);
153 :
154 0 : if(nIndY)
155 : {
156 0 : fMulB *= fColorToReal;
157 0 : const BitmapColor aBottom(rRead.GetPixel(nIntY + nIndY, nIntX));
158 0 : const BitmapColor aBottomPartner(rRead.GetPixel(nIntY + nIndY, nIntX + nIndX));
159 :
160 0 : fValBottom = (aBottom.GetIndex() * fMulB) + (aBottomPartner.GetIndex() * fMulA);
161 0 : }
162 : }
163 :
164 0 : if(nIndY)
165 : {
166 0 : if(!nIndX)
167 : {
168 0 : const BitmapColor aBottom(rRead.GetPixel(nIntY + nIndY, nIntX));
169 :
170 0 : fValBottom = aBottom.GetIndex() * fColorToReal;
171 : }
172 :
173 0 : const double fMulB(1.0 - fDeltaY);
174 :
175 0 : fVal = (fVal * fMulB) + (fValBottom * fDeltaY);
176 : }
177 :
178 0 : rValue.SetIndex((sal_uInt8)(fVal * 255.0));
179 : }
180 0 : }
181 :
182 0 : void impTransformBitmap(const Bitmap& rSource, Bitmap& rDestination, const basegfx::B2DHomMatrix& rTransform, bool bSmooth)
183 : {
184 0 : BitmapWriteAccess* pWrite = rDestination.AcquireWriteAccess();
185 :
186 0 : if(pWrite)
187 : {
188 0 : const Size aContentSizePixel(rSource.GetSizePixel());
189 0 : BitmapReadAccess* pRead = (const_cast< Bitmap& >(rSource)).AcquireReadAccess();
190 :
191 0 : if(pRead)
192 : {
193 0 : const Size aDestinationSizePixel(rDestination.GetSizePixel());
194 0 : bool bWorkWithIndex(rDestination.GetBitCount() <= 8);
195 0 : BitmapColor aOutside(pRead->GetBestMatchingColor(BitmapColor(0xff, 0xff, 0xff)));
196 :
197 0 : for(sal_Int32 y(0L); y < aDestinationSizePixel.getHeight(); y++)
198 : {
199 0 : for(sal_Int32 x(0L); x < aDestinationSizePixel.getWidth(); x++)
200 : {
201 0 : const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y));
202 0 : const sal_Int32 nIntX(basegfx::fround(aSourceCoor.getX()));
203 :
204 0 : if(nIntX >= 0L && nIntX < aContentSizePixel.getWidth())
205 : {
206 0 : const sal_Int32 nIntY(basegfx::fround(aSourceCoor.getY()));
207 :
208 0 : if(nIntY >= 0L && nIntY < aContentSizePixel.getHeight())
209 : {
210 0 : if(bWorkWithIndex)
211 : {
212 0 : BitmapColor aValue(pRead->GetPixel(nIntY, nIntX));
213 :
214 0 : if(bSmooth)
215 : {
216 0 : impSmoothIndex(aValue, aSourceCoor, nIntX, nIntY, *pRead);
217 : }
218 :
219 0 : pWrite->SetPixel(y, x, aValue);
220 : }
221 : else
222 : {
223 0 : BitmapColor aValue(pRead->GetColor(nIntY, nIntX));
224 :
225 0 : if(bSmooth)
226 : {
227 0 : impSmoothPoint(aValue, aSourceCoor, nIntX, nIntY, *pRead);
228 : }
229 :
230 0 : pWrite->SetPixel(y, x, aValue.IsIndex() ? aValue : pWrite->GetBestMatchingColor(aValue));
231 : }
232 :
233 0 : continue;
234 : }
235 : }
236 :
237 : // here are outside pixels. Complete mask
238 0 : if(bWorkWithIndex)
239 : {
240 0 : pWrite->SetPixel(y, x, aOutside);
241 : }
242 0 : }
243 : }
244 :
245 0 : delete pRead;
246 : }
247 :
248 0 : delete pWrite;
249 : }
250 0 : }
251 :
252 0 : Bitmap impCreateEmptyBitmapWithPattern(const Bitmap& rSource, const Size& aTargetSizePixel)
253 : {
254 0 : Bitmap aRetval;
255 0 : BitmapReadAccess* pReadAccess = (const_cast< Bitmap& >(rSource)).AcquireReadAccess();
256 :
257 0 : if(pReadAccess)
258 : {
259 0 : if(rSource.GetBitCount() <= 8)
260 : {
261 0 : BitmapPalette aPalette(pReadAccess->GetPalette());
262 0 : aRetval = Bitmap(aTargetSizePixel, rSource.GetBitCount(), &aPalette);
263 : }
264 : else
265 : {
266 0 : aRetval = Bitmap(aTargetSizePixel, rSource.GetBitCount());
267 : }
268 :
269 0 : delete pReadAccess;
270 : }
271 :
272 0 : return aRetval;
273 : }
274 : } // end of anonymous namespace
275 : } // end of namespace drawinglayer
276 :
277 : namespace drawinglayer
278 : {
279 0 : BitmapEx impTransformBitmapEx(
280 : const BitmapEx& rSource,
281 : const Rectangle& rCroppedRectPixel,
282 : const basegfx::B2DHomMatrix& rTransform)
283 : {
284 : // force destination to 24 bit, we want to smooth output
285 0 : const Size aDestinationSize(rCroppedRectPixel.GetSize());
286 0 : Bitmap aDestination(impCreateEmptyBitmapWithPattern(rSource.GetBitmap(), aDestinationSize));
287 : static bool bDoSmoothAtAll(true);
288 0 : impTransformBitmap(rSource.GetBitmap(), aDestination, rTransform, bDoSmoothAtAll);
289 :
290 : // create mask
291 0 : if(rSource.IsTransparent())
292 : {
293 0 : if(rSource.IsAlpha())
294 : {
295 0 : Bitmap aAlpha(impCreateEmptyBitmapWithPattern(rSource.GetAlpha().GetBitmap(), aDestinationSize));
296 0 : impTransformBitmap(rSource.GetAlpha().GetBitmap(), aAlpha, rTransform, bDoSmoothAtAll);
297 0 : return BitmapEx(aDestination, AlphaMask(aAlpha));
298 : }
299 : else
300 : {
301 0 : Bitmap aMask(impCreateEmptyBitmapWithPattern(rSource.GetMask(), aDestinationSize));
302 0 : impTransformBitmap(rSource.GetMask(), aMask, rTransform, false);
303 0 : return BitmapEx(aDestination, aMask);
304 : }
305 : }
306 :
307 0 : return BitmapEx(aDestination);
308 : }
309 :
310 0 : BitmapEx impModifyBitmapEx(
311 : const basegfx::BColorModifierStack& rBColorModifierStack,
312 : const BitmapEx& rSource)
313 : {
314 0 : Bitmap aChangedBitmap(rSource.GetBitmap());
315 0 : bool bDone(false);
316 :
317 0 : for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; )
318 : {
319 0 : const basegfx::BColorModifier& rModifier = rBColorModifierStack.getBColorModifier(--a);
320 :
321 0 : switch(rModifier.getMode())
322 : {
323 : case basegfx::BCOLORMODIFYMODE_REPLACE :
324 : {
325 : // complete replace
326 0 : if(rSource.IsTransparent())
327 : {
328 : // clear bitmap with dest color
329 0 : if(aChangedBitmap.GetBitCount() <= 8)
330 : {
331 : // do NOT use erase; for e.g. 8bit Bitmaps, the nearest color to the given
332 : // erase color is determined and used -> this may be different from what is
333 : // wanted here. Better create a new bitmap with the needed color explicitly
334 0 : BitmapReadAccess* pReadAccess = aChangedBitmap.AcquireReadAccess();
335 : OSL_ENSURE(pReadAccess, "Got no Bitmap ReadAccess ?!?");
336 :
337 0 : if(pReadAccess)
338 : {
339 0 : BitmapPalette aNewPalette(pReadAccess->GetPalette());
340 0 : aNewPalette[0] = BitmapColor(Color(rModifier.getBColor()));
341 : aChangedBitmap = Bitmap(
342 : aChangedBitmap.GetSizePixel(),
343 0 : aChangedBitmap.GetBitCount(),
344 0 : &aNewPalette);
345 0 : delete pReadAccess;
346 : }
347 : }
348 : else
349 : {
350 0 : aChangedBitmap.Erase(Color(rModifier.getBColor()));
351 : }
352 : }
353 : else
354 : {
355 : // erase bitmap, caller will know to paint direct
356 0 : aChangedBitmap.SetEmpty();
357 : }
358 :
359 0 : bDone = true;
360 0 : break;
361 : }
362 :
363 : default : // BCOLORMODIFYMODE_INTERPOLATE, BCOLORMODIFYMODE_GRAY, BCOLORMODIFYMODE_BLACKANDWHITE
364 : {
365 0 : BitmapWriteAccess* pContent = aChangedBitmap.AcquireWriteAccess();
366 :
367 0 : if(pContent)
368 : {
369 0 : const double fConvertColor(1.0 / 255.0);
370 :
371 0 : for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++)
372 : {
373 0 : for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++)
374 : {
375 0 : const BitmapColor aBMCol(pContent->GetColor(y, x));
376 : const basegfx::BColor aBSource(
377 0 : (double)aBMCol.GetRed() * fConvertColor,
378 0 : (double)aBMCol.GetGreen() * fConvertColor,
379 0 : (double)aBMCol.GetBlue() * fConvertColor);
380 0 : const basegfx::BColor aBDest(rModifier.getModifiedColor(aBSource));
381 :
382 0 : pContent->SetPixel(y, x, BitmapColor(Color(aBDest)));
383 0 : }
384 : }
385 :
386 0 : delete pContent;
387 : }
388 :
389 0 : break;
390 : }
391 : }
392 : }
393 :
394 0 : if(aChangedBitmap.IsEmpty())
395 : {
396 0 : return BitmapEx();
397 : }
398 : else
399 : {
400 0 : if(rSource.IsTransparent())
401 : {
402 0 : if(rSource.IsAlpha())
403 : {
404 0 : return BitmapEx(aChangedBitmap, rSource.GetAlpha());
405 : }
406 : else
407 : {
408 0 : return BitmapEx(aChangedBitmap, rSource.GetMask());
409 : }
410 : }
411 : else
412 : {
413 0 : return BitmapEx(aChangedBitmap);
414 : }
415 0 : }
416 : }
417 : } // end of namespace drawinglayer
418 :
419 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
