drawinglayer/source/processor2d/vclhelperbitmaptransform.cxx

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