drawinglayer/source/processor2d/vclhelperbitmaptransform.cxx

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