| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_vcl.hxx" |
| |
| #include <stdlib.h> |
| |
| #include <vcl/bmpacc.hxx> |
| #include <vcl/octree.hxx> |
| #include <vcl/bitmapex.hxx> |
| #include <vcl/bitmap.hxx> |
| |
| #include <impoct.hxx> |
| #include <impvect.hxx> |
| |
| // ----------- |
| // - Defines - |
| // ----------- |
| |
| #define RGB15( _def_cR, _def_cG, _def_cB ) (((sal_uLong)(_def_cR)<<10UL)|((sal_uLong)(_def_cG)<<5UL)|(sal_uLong)(_def_cB)) |
| #define GAMMA( _def_cVal, _def_InvGamma ) ((sal_uInt8)MinMax(FRound(pow( _def_cVal/255.0,_def_InvGamma)*255.0),0L,255L)) |
| #define MAP( cVal0, cVal1, nFrac ) ((sal_uInt8)((((long)(cVal0)<<7L)+nFrac*((long)(cVal1)-(cVal0)))>>7L)) |
| |
| #define CALC_ERRORS \ |
| nTemp = p1T[nX++] >> 12; \ |
| nBErr = MinMax( nTemp, 0, 255 ); \ |
| nBErr = nBErr - FloydIndexMap[ nBC = FloydMap[nBErr] ]; \ |
| nTemp = p1T[nX++] >> 12; \ |
| nGErr = MinMax( nTemp, 0, 255 ); \ |
| nGErr = nGErr - FloydIndexMap[ nGC = FloydMap[nGErr] ]; \ |
| nTemp = p1T[nX] >> 12; \ |
| nRErr = MinMax( nTemp, 0, 255 ); \ |
| nRErr = nRErr - FloydIndexMap[ nRC = FloydMap[nRErr] ]; |
| |
| #define CALC_TABLES3 \ |
| p2T[nX++] += FloydError3[nBErr]; \ |
| p2T[nX++] += FloydError3[nGErr]; \ |
| p2T[nX++] += FloydError3[nRErr]; |
| |
| #define CALC_TABLES5 \ |
| p2T[nX++] += FloydError5[nBErr]; \ |
| p2T[nX++] += FloydError5[nGErr]; \ |
| p2T[nX++] += FloydError5[nRErr]; |
| |
| #define CALC_TABLES7 \ |
| p1T[++nX] += FloydError7[nBErr]; \ |
| p2T[nX++] += FloydError1[nBErr]; \ |
| p1T[nX] += FloydError7[nGErr]; \ |
| p2T[nX++] += FloydError1[nGErr]; \ |
| p1T[nX] += FloydError7[nRErr]; \ |
| p2T[nX] += FloydError1[nRErr]; |
| |
| // ----------- |
| // - Statics - |
| // ----------- |
| |
| sal_uLong nVCLRLut[ 6 ] = { 16, 17, 18, 19, 20, 21 }; |
| sal_uLong nVCLGLut[ 6 ] = { 0, 6, 12, 18, 24, 30 }; |
| sal_uLong nVCLBLut[ 6 ] = { 0, 36, 72, 108, 144, 180 }; |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_uLong nVCLDitherLut[ 256 ] = |
| { |
| 0, 49152, 12288, 61440, 3072, 52224, 15360, 64512, 768, 49920, 13056, |
| 62208, 3840, 52992, 16128, 65280, 32768, 16384, 45056, 28672, 35840, 19456, |
| 48128, 31744, 33536, 17152, 45824, 29440, 36608, 20224, 48896, 32512, 8192, |
| 57344, 4096, 53248, 11264, 60416, 7168, 56320, 8960, 58112, 4864, 54016, |
| 12032, 61184, 7936, 57088, 40960, 24576, 36864, 20480, 44032, 27648, 39936, |
| 23552, 41728, 25344, 37632, 21248, 44800, 28416, 40704, 24320, 2048, 51200, |
| 14336, 63488, 1024, 50176, 13312, 62464, 2816, 51968, 15104, 64256, 1792, |
| 50944, 14080, 63232, 34816, 18432, 47104, 30720, 33792, 17408, 46080, 29696, |
| 35584, 19200, 47872, 31488, 34560, 18176, 46848, 30464, 10240, 59392, 6144, |
| 55296, 9216, 58368, 5120, 54272, 11008, 60160, 6912, 56064, 9984, 59136, |
| 5888, 55040, 43008, 26624, 38912, 22528, 41984, 25600, 37888, 21504, 43776, |
| 27392, 39680, 23296, 42752, 26368, 38656, 22272, 512, 49664, 12800, 61952, |
| 3584, 52736, 15872, 65024, 256, 49408, 12544, 61696, 3328, 52480, 15616, |
| 64768, 33280, 16896, 45568, 29184, 36352, 19968, 48640, 32256, 33024, 16640, |
| 45312, 28928, 36096, 19712, 48384, 32000, 8704, 57856, 4608, 53760, 11776, |
| 60928, 7680, 56832, 8448, 57600, 4352, 53504, 11520, 60672, 7424, 56576, |
| 41472, 25088, 37376, 20992, 44544, 28160, 40448, 24064, 41216, 24832, 37120, |
| 20736, 44288, 27904, 40192, 23808, 2560, 51712, 14848, 64000, 1536, 50688, |
| 13824, 62976, 2304, 51456, 14592, 63744, 1280, 50432, 13568, 62720, 35328, |
| 18944, 47616, 31232, 34304, 17920, 46592, 30208, 35072, 18688, 47360, 30976, |
| 34048, 17664, 46336, 29952, 10752, 59904, 6656, 55808, 9728, 58880, 5632, |
| 54784, 10496, 59648, 6400, 55552, 9472, 58624, 5376, 54528, 43520, 27136, |
| 39424, 23040, 42496, 26112, 38400, 22016, 43264, 26880, 39168, 22784, 42240, |
| 25856, 38144, 21760 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_uLong nVCLLut[ 256 ] = |
| { |
| 0, 1286, 2572, 3858, 5144, 6430, 7716, 9002, |
| 10288, 11574, 12860, 14146, 15432, 16718, 18004, 19290, |
| 20576, 21862, 23148, 24434, 25720, 27006, 28292, 29578, |
| 30864, 32150, 33436, 34722, 36008, 37294, 38580, 39866, |
| 41152, 42438, 43724, 45010, 46296, 47582, 48868, 50154, |
| 51440, 52726, 54012, 55298, 56584, 57870, 59156, 60442, |
| 61728, 63014, 64300, 65586, 66872, 68158, 69444, 70730, |
| 72016, 73302, 74588, 75874, 77160, 78446, 79732, 81018, |
| 82304, 83590, 84876, 86162, 87448, 88734, 90020, 91306, |
| 92592, 93878, 95164, 96450, 97736, 99022,100308,101594, |
| 102880,104166,105452,106738,108024,109310,110596,111882, |
| 113168,114454,115740,117026,118312,119598,120884,122170, |
| 123456,124742,126028,127314,128600,129886,131172,132458, |
| 133744,135030,136316,137602,138888,140174,141460,142746, |
| 144032,145318,146604,147890,149176,150462,151748,153034, |
| 154320,155606,156892,158178,159464,160750,162036,163322, |
| 164608,165894,167180,168466,169752,171038,172324,173610, |
| 174896,176182,177468,178754,180040,181326,182612,183898, |
| 185184,186470,187756,189042,190328,191614,192900,194186, |
| 195472,196758,198044,199330,200616,201902,203188,204474, |
| 205760,207046,208332,209618,210904,212190,213476,214762, |
| 216048,217334,218620,219906,221192,222478,223764,225050, |
| 226336,227622,228908,230194,231480,232766,234052,235338, |
| 236624,237910,239196,240482,241768,243054,244340,245626, |
| 246912,248198,249484,250770,252056,253342,254628,255914, |
| 257200,258486,259772,261058,262344,263630,264916,266202, |
| 267488,268774,270060,271346,272632,273918,275204,276490, |
| 277776,279062,280348,281634,282920,284206,285492,286778, |
| 288064,289350,290636,291922,293208,294494,295780,297066, |
| 298352,299638,300924,302210,303496,304782,306068,307354, |
| 308640,309926,311212,312498,313784,315070,316356,317642, |
| 318928,320214,321500,322786,324072,325358,326644,327930 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| long FloydMap[256] = |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
| 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
| 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
| 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, |
| 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, |
| 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, |
| 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, |
| 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| long FloydError1[61] = |
| { |
| -7680, -7424, -7168, -6912, -6656, -6400, -6144, |
| -5888, -5632, -5376, -5120, -4864, -4608, -4352, |
| -4096, -3840, -3584, -3328, -3072, -2816, -2560, |
| -2304, -2048, -1792, -1536, -1280, -1024, -768, |
| -512, -256, 0, 256, 512, 768, 1024, 1280, 1536, |
| 1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584, |
| 3840, 4096, 4352, 4608, 4864, 5120, 5376, 5632, |
| 5888, 6144, 6400, 6656, 6912, 7168, 7424, 7680 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| long FloydError3[61] = |
| { |
| -23040, -22272, -21504, -20736, -19968, -19200, |
| -18432, -17664, -16896, -16128, -15360, -14592, |
| -13824, -13056, -12288, -11520, -10752, -9984, |
| -9216, -8448, -7680, -6912, -6144, -5376, -4608, |
| -3840, -3072, -2304, -1536, -768, 0, 768, 1536, |
| 2304, 3072, 3840, 4608, 5376, 6144, 6912, 7680, |
| 8448, 9216, 9984, 10752, 11520, 12288, 13056, |
| 13824, 14592, 15360, 16128, 16896, 17664, 18432, |
| 19200, 19968, 20736, 21504, 22272, 23040 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| long FloydError5[61] = |
| { |
| -38400, -37120, -35840, -34560, -33280, -32000, |
| -30720, -29440, -28160, -26880, -25600, -24320, |
| -23040, -21760, -20480, -19200, -17920, -16640, |
| -15360, -14080, -12800, -11520, -10240, -8960, |
| -7680, -6400, -5120, -3840, -2560, -1280, 0, |
| 1280, 2560, 3840, 5120, 6400, 7680, 8960, 10240, |
| 11520, 12800, 14080, 15360, 16640, 17920, 19200, |
| 20480, 21760, 23040, 24320, 25600, 26880, 28160, |
| 29440, 30720, 32000, 33280, 34560, 35840, 37120, |
| 38400 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| long FloydError7[61] = |
| { |
| -53760, -51968, -50176, -48384, -46592, -44800, |
| -43008, -41216, -39424, -37632, -35840, -34048, |
| -32256, -30464, -28672, -26880, -25088, -23296, |
| -21504, -19712, -17920, -16128, -14336, -12544, |
| -10752, -8960, -7168, -5376, -3584, -1792, 0, |
| 1792, 3584, 5376, 7168, 8960, 10752, 12544, 14336, |
| 16128, 17920, 19712, 21504, 23296, 25088, 26880, |
| 28672, 30464, 32256, 34048, 35840, 37632, 39424, |
| 41216, 43008, 44800, 46592, 48384, 50176, 51968, |
| 53760 |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| long FloydIndexMap[6] = |
| { |
| -30, 21, 72, 123, 174, 225 |
| }; |
| |
| // -------------------------- |
| // - ImplCreateDitherMatrix - |
| // -------------------------- |
| |
| void ImplCreateDitherMatrix( sal_uInt8 (*pDitherMatrix)[16][16] ) |
| { |
| double fVal = 3.125; |
| const double fVal16 = fVal / 16.; |
| long i, j, k, l; |
| sal_uInt16 pMtx[ 16 ][ 16 ]; |
| sal_uInt16 nMax = 0; |
| static sal_uInt8 pMagic[4][4] = { { 0, 14, 3, 13, }, |
| {11, 5, 8, 6, }, |
| {12, 2, 15, 1, }, |
| {7, 9, 4, 10 } }; |
| |
| // MagicSquare aufbauen |
| for ( i = 0; i < 4; i++ ) |
| for ( j = 0; j < 4; j++ ) |
| for ( k = 0; k < 4; k++ ) |
| for ( l = 0; l < 4; l++ ) |
| nMax = Max ( pMtx[ (k<<2) + i][(l<<2 ) + j] = |
| (sal_uInt16) ( 0.5 + pMagic[i][j]*fVal + pMagic[k][l]*fVal16 ), nMax ); |
| |
| // auf Intervall [0;254] skalieren |
| for ( i = 0, fVal = 254. / nMax; i < 16; i++ ) |
| for( j = 0; j < 16; j++ ) |
| (*pDitherMatrix)[i][j] = (sal_uInt8) ( fVal * pMtx[i][j] ); |
| } |
| |
| // ---------- |
| // - Bitmap - |
| // ---------- |
| |
| sal_Bool Bitmap::Convert( BmpConversion eConversion ) |
| { |
| const sal_uInt16 nBitCount = GetBitCount(); |
| sal_Bool bRet = sal_False; |
| |
| switch( eConversion ) |
| { |
| case( BMP_CONVERSION_1BIT_THRESHOLD ): |
| bRet = ImplMakeMono( 128 ); |
| break; |
| |
| case( BMP_CONVERSION_1BIT_MATRIX ): |
| bRet = ImplMakeMonoDither(); |
| break; |
| |
| case( BMP_CONVERSION_4BIT_GREYS ): |
| bRet = ImplMakeGreyscales( 16 ); |
| break; |
| |
| case( BMP_CONVERSION_4BIT_COLORS ): |
| { |
| if( nBitCount < 4 ) |
| bRet = ImplConvertUp( 4, NULL ); |
| else if( nBitCount > 4 ) |
| bRet = ImplConvertDown( 4, NULL ); |
| else |
| bRet = sal_True; |
| } |
| break; |
| |
| case( BMP_CONVERSION_4BIT_TRANS ): |
| { |
| Color aTrans( BMP_COL_TRANS ); |
| |
| if( nBitCount < 4 ) |
| bRet = ImplConvertUp( 4, &aTrans ); |
| else |
| bRet = ImplConvertDown( 4, &aTrans ); |
| } |
| break; |
| |
| case( BMP_CONVERSION_8BIT_GREYS ): |
| bRet = ImplMakeGreyscales( 256 ); |
| break; |
| |
| case( BMP_CONVERSION_8BIT_COLORS ): |
| { |
| if( nBitCount < 8 ) |
| bRet = ImplConvertUp( 8 ); |
| else if( nBitCount > 8 ) |
| bRet = ImplConvertDown( 8 ); |
| else |
| bRet = sal_True; |
| } |
| break; |
| |
| case( BMP_CONVERSION_8BIT_TRANS ): |
| { |
| Color aTrans( BMP_COL_TRANS ); |
| |
| if( nBitCount < 8 ) |
| bRet = ImplConvertUp( 8, &aTrans ); |
| else |
| bRet = ImplConvertDown( 8, &aTrans ); |
| } |
| break; |
| |
| case( BMP_CONVERSION_24BIT ): |
| { |
| if( nBitCount < 24 ) |
| bRet = ImplConvertUp( 24, NULL ); |
| else |
| bRet = sal_True; |
| } |
| break; |
| |
| case( BMP_CONVERSION_GHOSTED ): |
| bRet = ImplConvertGhosted(); |
| break; |
| |
| default: |
| DBG_ERROR( "Bitmap::Convert(): Unsupported conversion" ); |
| break; |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplMakeMono( sal_uInt8 cThreshold ) |
| { |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc ) |
| { |
| Bitmap aNewBmp( GetSizePixel(), 1 ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWriteAcc ) |
| { |
| const BitmapColor aBlack( pWriteAcc->GetBestMatchingColor( Color( COL_BLACK ) ) ); |
| const BitmapColor aWhite( pWriteAcc->GetBestMatchingColor( Color( COL_WHITE ) ) ); |
| const long nWidth = pWriteAcc->Width(); |
| const long nHeight = pWriteAcc->Height(); |
| |
| if( pReadAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const sal_uInt8 cIndex = pReadAcc->GetPixelIndex( nY, nX ); |
| if( pReadAcc->GetPaletteColor( cIndex ).GetLuminance() >= |
| cThreshold ) |
| { |
| pWriteAcc->SetPixel( nY, nX, aWhite ); |
| } |
| else |
| pWriteAcc->SetPixel( nY, nX, aBlack ); |
| } |
| } |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| if( pReadAcc->GetPixel( nY, nX ).GetLuminance() >= |
| cThreshold ) |
| { |
| pWriteAcc->SetPixel( nY, nX, aWhite ); |
| } |
| else |
| pWriteAcc->SetPixel( nY, nX, aBlack ); |
| } |
| } |
| } |
| |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplMakeMonoDither() |
| { |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc ) |
| { |
| Bitmap aNewBmp( GetSizePixel(), 1 ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWriteAcc ) |
| { |
| const BitmapColor aBlack( pWriteAcc->GetBestMatchingColor( Color( COL_BLACK ) ) ); |
| const BitmapColor aWhite( pWriteAcc->GetBestMatchingColor( Color( COL_WHITE ) ) ); |
| const long nWidth = pWriteAcc->Width(); |
| const long nHeight = pWriteAcc->Height(); |
| sal_uInt8 pDitherMatrix[ 16 ][ 16 ]; |
| |
| ImplCreateDitherMatrix( &pDitherMatrix ); |
| |
| if( pReadAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L, nModY = nY % 16; nX < nWidth; nX++ ) |
| { |
| const sal_uInt8 cIndex = pReadAcc->GetPixelIndex( nY, nX ); |
| if( pReadAcc->GetPaletteColor( cIndex ).GetLuminance() > |
| pDitherMatrix[ nModY ][ nX % 16 ] ) |
| { |
| pWriteAcc->SetPixel( nY, nX, aWhite ); |
| } |
| else |
| pWriteAcc->SetPixel( nY, nX, aBlack ); |
| } |
| } |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L, nModY = nY % 16; nX < nWidth; nX++ ) |
| { |
| if( pReadAcc->GetPixel( nY, nX ).GetLuminance() > |
| pDitherMatrix[ nModY ][ nX % 16 ] ) |
| { |
| pWriteAcc->SetPixel( nY, nX, aWhite ); |
| } |
| else |
| pWriteAcc->SetPixel( nY, nX, aBlack ); |
| } |
| } |
| } |
| |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys ) |
| { |
| DBG_ASSERT( nGreys == 16 || nGreys == 256, "Only 16 or 256 greyscales are supported!" ); |
| |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc ) |
| { |
| const BitmapPalette& rPal = GetGreyPalette( nGreys ); |
| sal_uLong nShift = ( ( nGreys == 16 ) ? 4UL : 0UL ); |
| sal_Bool bPalDiffers = !pReadAcc->HasPalette() || ( rPal.GetEntryCount() != pReadAcc->GetPaletteEntryCount() ); |
| |
| if( !bPalDiffers ) |
| bPalDiffers = ( (BitmapPalette&) rPal != pReadAcc->GetPalette() ); |
| |
| if( bPalDiffers ) |
| { |
| Bitmap aNewBmp( GetSizePixel(), ( nGreys == 16 ) ? 4 : 8, &rPal ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWriteAcc ) |
| { |
| const long nWidth = pWriteAcc->Width(); |
| const long nHeight = pWriteAcc->Height(); |
| |
| if( pReadAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const sal_uInt8 cIndex = pReadAcc->GetPixelIndex( nY, nX ); |
| pWriteAcc->SetPixelIndex( nY, nX, |
| (pReadAcc->GetPaletteColor( cIndex ).GetLuminance() >> nShift) ); |
| } |
| } |
| } |
| else if( pReadAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_BGR && |
| pWriteAcc->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL ) |
| { |
| nShift += 8; |
| |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| Scanline pReadScan = pReadAcc->GetScanline( nY ); |
| Scanline pWriteScan = pWriteAcc->GetScanline( nY ); |
| |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const sal_uLong nB = *pReadScan++; |
| const sal_uLong nG = *pReadScan++; |
| const sal_uLong nR = *pReadScan++; |
| |
| *pWriteScan++ = (sal_uInt8) ( ( nB * 28UL + nG * 151UL + nR * 77UL ) >> nShift ); |
| } |
| } |
| } |
| else if( pReadAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_RGB && |
| pWriteAcc->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL ) |
| { |
| nShift += 8; |
| |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| Scanline pReadScan = pReadAcc->GetScanline( nY ); |
| Scanline pWriteScan = pWriteAcc->GetScanline( nY ); |
| |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const sal_uLong nR = *pReadScan++; |
| const sal_uLong nG = *pReadScan++; |
| const sal_uLong nB = *pReadScan++; |
| |
| *pWriteScan++ = (sal_uInt8) ( ( nB * 28UL + nG * 151UL + nR * 77UL ) >> nShift ); |
| } |
| } |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| pWriteAcc->SetPixelIndex( nY, nX, (pReadAcc->GetPixel( nY, nX ) ).GetLuminance() >> nShift ); |
| } |
| |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| else |
| { |
| ReleaseAccess( pReadAcc ); |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplConvertUp( sal_uInt16 nBitCount, Color* pExtColor ) |
| { |
| DBG_ASSERT( nBitCount > GetBitCount(), "New BitCount must be greater!" ); |
| |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc ) |
| { |
| BitmapPalette aPal; |
| Bitmap aNewBmp( GetSizePixel(), nBitCount, pReadAcc->HasPalette() ? &pReadAcc->GetPalette() : &aPal ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWriteAcc ) |
| { |
| const long nWidth = pWriteAcc->Width(); |
| const long nHeight = pWriteAcc->Height(); |
| |
| if( pWriteAcc->HasPalette() ) |
| { |
| const sal_uInt16 nOldCount = 1 << GetBitCount(); |
| const BitmapPalette& rOldPal = pReadAcc->GetPalette(); |
| |
| aPal.SetEntryCount( 1 << nBitCount ); |
| |
| for( sal_uInt16 i = 0; i < nOldCount; i++ ) |
| aPal[ i ] = rOldPal[ i ]; |
| |
| if( pExtColor ) |
| aPal[ aPal.GetEntryCount() - 1 ] = *pExtColor; |
| |
| pWriteAcc->SetPalette( aPal ); |
| |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nY, nX ) ); |
| } |
| else |
| { |
| if( pReadAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) ) ); |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPixel( nY, nX ) ); |
| } |
| } |
| |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor ) |
| { |
| DBG_ASSERT( nBitCount <= GetBitCount(), "New BitCount must be lower ( or equal when pExtColor is set )!" ); |
| |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc ) |
| { |
| BitmapPalette aPal; |
| Bitmap aNewBmp( GetSizePixel(), nBitCount, &aPal ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWriteAcc ) |
| { |
| const sal_uInt16 nCount = 1 << nBitCount; |
| const long nWidth = pWriteAcc->Width(); |
| const long nWidth1 = nWidth - 1L; |
| const long nHeight = pWriteAcc->Height(); |
| Octree aOctree( *pReadAcc, pExtColor ? ( nCount - 1 ) : nCount ); |
| InverseColorMap aColorMap( aPal = aOctree.GetPalette() ); |
| BitmapColor aColor; |
| ImpErrorQuad aErrQuad; |
| ImpErrorQuad* pErrQuad1 = new ImpErrorQuad[ nWidth ]; |
| ImpErrorQuad* pErrQuad2 = new ImpErrorQuad[ nWidth ]; |
| ImpErrorQuad* pQLine1 = pErrQuad1; |
| ImpErrorQuad* pQLine2 = 0; |
| long nX, nY; |
| long nYTmp = 0L; |
| sal_uInt8 cIndex; |
| sal_Bool bQ1 = sal_True; |
| |
| if( pExtColor ) |
| { |
| aPal.SetEntryCount( aPal.GetEntryCount() + 1 ); |
| aPal[ aPal.GetEntryCount() - 1 ] = *pExtColor; |
| } |
| |
| // set Black/White always, if we have enough space |
| if( aPal.GetEntryCount() < ( nCount - 1 ) ) |
| { |
| aPal.SetEntryCount( aPal.GetEntryCount() + 2 ); |
| aPal[ aPal.GetEntryCount() - 2 ] = Color( COL_BLACK ); |
| aPal[ aPal.GetEntryCount() - 1 ] = Color( COL_WHITE ); |
| } |
| |
| pWriteAcc->SetPalette( aPal ); |
| |
| for( nY = 0L; nY < Min( nHeight, 2L ); nY++, nYTmp++ ) |
| { |
| for( nX = 0L, pQLine2 = !nY ? pErrQuad1 : pErrQuad2; nX < nWidth; nX++ ) |
| { |
| if( pReadAcc->HasPalette() ) |
| pQLine2[ nX ] = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nYTmp, nX ) ); |
| else |
| pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX ); |
| } |
| } |
| |
| for( nY = 0L; nY < nHeight; nY++, nYTmp++ ) |
| { |
| // first pixel in the line |
| cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ 0 ].ImplGetColor() ); |
| pWriteAcc->SetPixelIndex( nY, 0, cIndex ); |
| |
| for( nX = 1L; nX < nWidth1; nX++ ) |
| { |
| cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( aColor = pQLine1[ nX ].ImplGetColor() ); |
| aErrQuad = ( ImpErrorQuad( aColor ) -= pWriteAcc->GetPaletteColor( cIndex ) ); |
| pQLine1[ ++nX ].ImplAddColorError7( aErrQuad ); |
| pQLine2[ nX-- ].ImplAddColorError1( aErrQuad ); |
| pQLine2[ nX-- ].ImplAddColorError5( aErrQuad ); |
| pQLine2[ nX++ ].ImplAddColorError3( aErrQuad ); |
| pWriteAcc->SetPixelIndex( nY, nX, cIndex ); |
| } |
| |
| // letztes ZeilenPixel |
| if( nX < nWidth ) |
| { |
| cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ nWidth1 ].ImplGetColor() ); |
| pWriteAcc->SetPixelIndex( nY, nX, cIndex ); |
| } |
| |
| // Zeilenpuffer neu fuellen/kopieren |
| pQLine1 = pQLine2; |
| pQLine2 = ( bQ1 = !bQ1 ) != sal_False ? pErrQuad2 : pErrQuad1; |
| |
| if( nYTmp < nHeight ) |
| { |
| for( nX = 0L; nX < nWidth; nX++ ) |
| { |
| if( pReadAcc->HasPalette() ) |
| pQLine2[ nX ] = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nYTmp, nX ) ); |
| else |
| pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX ); |
| } |
| } |
| } |
| |
| // Zeilenpuffer zerstoeren |
| delete[] pErrQuad1; |
| delete[] pErrQuad2; |
| |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplConvertGhosted() |
| { |
| Bitmap aNewBmp; |
| BitmapReadAccess* pR = AcquireReadAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pR ) |
| { |
| if( pR->HasPalette() ) |
| { |
| BitmapPalette aNewPal( pR->GetPaletteEntryCount() ); |
| |
| for( long i = 0, nCount = aNewPal.GetEntryCount(); i < nCount; i++ ) |
| { |
| const BitmapColor& rOld = pR->GetPaletteColor( (sal_uInt16) i ); |
| aNewPal[ (sal_uInt16) i ] = BitmapColor( ( rOld.GetRed() >> 1 ) | 0x80, |
| ( rOld.GetGreen() >> 1 ) | 0x80, |
| ( rOld.GetBlue() >> 1 ) | 0x80 ); |
| } |
| |
| aNewBmp = Bitmap( GetSizePixel(), GetBitCount(), &aNewPal ); |
| BitmapWriteAccess* pW = aNewBmp.AcquireWriteAccess(); |
| |
| if( pW ) |
| { |
| pW->CopyBuffer( *pR ); |
| aNewBmp.ReleaseAccess( pW ); |
| bRet = sal_True; |
| } |
| } |
| else |
| { |
| aNewBmp = Bitmap( GetSizePixel(), 24 ); |
| |
| BitmapWriteAccess* pW = aNewBmp.AcquireWriteAccess(); |
| |
| if( pW ) |
| { |
| const long nWidth = pR->Width(), nHeight = pR->Height(); |
| |
| for( long nY = 0; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aOld( pR->GetPixel( nY, nX ) ); |
| pW->SetPixel( nY, nX, BitmapColor( ( aOld.GetRed() >> 1 ) | 0x80, |
| ( aOld.GetGreen() >> 1 ) | 0x80, |
| ( aOld.GetBlue() >> 1 ) | 0x80 ) ); |
| |
| } |
| } |
| |
| aNewBmp.ReleaseAccess( pW ); |
| bRet = sal_True; |
| } |
| } |
| |
| ReleaseAccess( pR ); |
| } |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::Scale( const double& rScaleX, const double& rScaleY, sal_uInt32 nScaleFlag ) |
| { |
| if(basegfx::fTools::equalZero(rScaleX) || basegfx::fTools::equalZero(rScaleY)) |
| { |
| // no scale |
| return true; |
| } |
| |
| if(basegfx::fTools::equal(rScaleX, 1.0) && basegfx::fTools::equal(rScaleY, 1.0)) |
| { |
| // no scale |
| return true; |
| } |
| |
| #ifdef DBG_UTIL |
| // #121233# allow to test the different scalers in debug build with source |
| // level debugger (change nNumber to desired action) |
| static sal_uInt16 nNumber(0); |
| const sal_uInt16 nStartCount(GetBitCount()); |
| |
| switch(nNumber) |
| { |
| case 0 : break; |
| case 1: nScaleFlag = BMP_SCALE_FAST; break; |
| case 2: nScaleFlag = BMP_SCALE_INTERPOLATE; break; |
| case 3: nScaleFlag = BMP_SCALE_SUPER; break; |
| case 4: nScaleFlag = BMP_SCALE_LANCZOS; break; |
| case 5: nScaleFlag = BMP_SCALE_BICUBIC; break; |
| case 6: nScaleFlag = BMP_SCALE_BILINEAR; break; |
| case 7: nScaleFlag = BMP_SCALE_BOX; break; |
| case 8: nScaleFlag = BMP_SCALE_BESTQUALITY; break; |
| case 9: nScaleFlag = BMP_SCALE_FASTESTINTERPOLATE; break; |
| } |
| #endif // DBG_UTIL |
| |
| bool bRetval(false); |
| |
| if(BMP_SCALE_BESTQUALITY == nScaleFlag) |
| { |
| // Use LANCZOS when best quality is requested |
| nScaleFlag = BMP_SCALE_LANCZOS; |
| } |
| else if(BMP_SCALE_FASTESTINTERPOLATE == nScaleFlag) |
| { |
| // Use BMP_SCALE_SUPER when speed is requested, but not worst quality |
| nScaleFlag = BMP_SCALE_SUPER; |
| } |
| |
| switch(nScaleFlag) |
| { |
| default: |
| case BMP_SCALE_NONE : |
| { |
| bRetval = false; |
| break; |
| } |
| case BMP_SCALE_FAST : |
| { |
| bRetval = ImplScaleFast( rScaleX, rScaleY ); |
| break; |
| } |
| case BMP_SCALE_INTERPOLATE : |
| { |
| bRetval = ImplScaleInterpolate( rScaleX, rScaleY ); |
| break; |
| } |
| case BMP_SCALE_SUPER : |
| { |
| if(GetSizePixel().Width() < 2 || GetSizePixel().Height() < 2) |
| { |
| // fallback to ImplScaleFast |
| bRetval = ImplScaleFast( rScaleX, rScaleY ); |
| } |
| else |
| { |
| // #121233# use method from symphony |
| bRetval = ImplScaleSuper( rScaleX, rScaleY ); |
| } |
| break; |
| } |
| case BMP_SCALE_LANCZOS : |
| { |
| const Lanczos3Kernel kernel; |
| |
| bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel); |
| break; |
| } |
| case BMP_SCALE_BICUBIC : |
| { |
| const BicubicKernel kernel; |
| |
| bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); |
| break; |
| } |
| case BMP_SCALE_BILINEAR : |
| { |
| const BilinearKernel kernel; |
| |
| bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); |
| break; |
| } |
| case BMP_SCALE_BOX : |
| { |
| const BoxKernel kernel; |
| |
| bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); |
| break; |
| } |
| } |
| |
| #ifdef DBG_UTIL |
| if(bRetval && nStartCount != GetBitCount()) |
| { |
| OSL_ENSURE(false, "Bitmap::Scale has changed the ColorDepth, this should *not* happen (!)"); |
| } |
| #endif |
| |
| return bRetval; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::Scale( const Size& rNewSize, sal_uInt32 nScaleFlag ) |
| { |
| const Size aSize( GetSizePixel() ); |
| sal_Bool bRet; |
| |
| if( aSize.Width() && aSize.Height() ) |
| { |
| bRet = Scale( (double) rNewSize.Width() / aSize.Width(), |
| (double) rNewSize.Height() / aSize.Height(), |
| nScaleFlag ); |
| } |
| else |
| bRet = sal_True; |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void Bitmap::AdaptBitCount(Bitmap& rNew) const |
| { |
| ImplAdaptBitCount(rNew); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void Bitmap::ImplAdaptBitCount(Bitmap& rNew) const |
| { |
| // aNew is the result of some operation; adapt it's BitCount to the original (this) |
| if(GetBitCount() != rNew.GetBitCount()) |
| { |
| switch(GetBitCount()) |
| { |
| case 1: |
| { |
| rNew.Convert(BMP_CONVERSION_1BIT_THRESHOLD); |
| break; |
| } |
| case 4: |
| { |
| if(HasGreyPalette()) |
| { |
| rNew.Convert(BMP_CONVERSION_4BIT_GREYS); |
| } |
| else |
| { |
| rNew.Convert(BMP_CONVERSION_4BIT_COLORS); |
| } |
| break; |
| } |
| case 8: |
| { |
| if(HasGreyPalette()) |
| { |
| rNew.Convert(BMP_CONVERSION_8BIT_GREYS); |
| } |
| else |
| { |
| rNew.Convert(BMP_CONVERSION_8BIT_COLORS); |
| } |
| break; |
| } |
| case 24: |
| { |
| rNew.Convert(BMP_CONVERSION_24BIT); |
| break; |
| } |
| default: |
| { |
| OSL_ENSURE(false, "BitDepth adaption failed (!)"); |
| break; |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplScaleFast( const double& rScaleX, const double& rScaleY ) |
| { |
| const Size aSizePix( GetSizePixel() ); |
| const long nNewWidth = FRound( aSizePix.Width() * rScaleX ); |
| const long nNewHeight = FRound( aSizePix.Height() * rScaleY ); |
| sal_Bool bRet = sal_False; |
| |
| if( nNewWidth && nNewHeight ) |
| { |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| if ( !pReadAcc ) |
| return sal_False; |
| |
| Bitmap aNewBmp( Size( nNewWidth, nNewHeight ), GetBitCount(), &pReadAcc->GetPalette() ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWriteAcc ) |
| { |
| const long nScanlineSize = pWriteAcc->GetScanlineSize(); |
| const long nNewWidth1 = nNewWidth - 1L; |
| const long nNewHeight1 = nNewHeight - 1L; |
| const long nWidth = pReadAcc->Width(); |
| const long nHeight = pReadAcc->Height(); |
| long* pLutX = new long[ nNewWidth ]; |
| long* pLutY = new long[ nNewHeight ]; |
| long nX, nY, nMapY, nActY = 0L; |
| |
| if( nNewWidth1 && nNewHeight1 ) |
| { |
| for( nX = 0L; nX < nNewWidth; nX++ ) |
| pLutX[ nX ] = nX * nWidth / nNewWidth; |
| |
| for( nY = 0L; nY < nNewHeight; nY++ ) |
| pLutY[ nY ] = nY * nHeight / nNewHeight; |
| |
| while( nActY < nNewHeight ) |
| { |
| nMapY = pLutY[ nActY ]; |
| |
| for( nX = 0L; nX < nNewWidth; nX++ ) |
| pWriteAcc->SetPixel( nActY, nX, pReadAcc->GetPixel( nMapY , pLutX[ nX ] ) ); |
| |
| while( ( nActY < nNewHeight1 ) && ( pLutY[ nActY + 1 ] == nMapY ) ) |
| { |
| memcpy( pWriteAcc->GetScanline( nActY + 1L ), |
| pWriteAcc->GetScanline( nActY ), nScanlineSize ); |
| nActY++; |
| } |
| |
| nActY++; |
| } |
| |
| bRet = sal_True; |
| } |
| |
| delete[] pLutX; |
| delete[] pLutY; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| |
| if( bRet ) |
| ImplAssignWithSize( aNewBmp ); |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rScaleY ) |
| { |
| const Size aSizePix( GetSizePixel() ); |
| const long nNewWidth = FRound( aSizePix.Width() * rScaleX ); |
| const long nNewHeight = FRound( aSizePix.Height() * rScaleY ); |
| sal_Bool bRet = sal_False; |
| |
| if( ( nNewWidth > 1L ) && ( nNewHeight > 1L ) ) |
| { |
| BitmapColor aCol0; |
| BitmapColor aCol1; |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| long nWidth = pReadAcc->Width(); |
| long nHeight = pReadAcc->Height(); |
| Bitmap aNewBmp( Size( nNewWidth, nHeight ), 24 ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| long* pLutInt; |
| long* pLutFrac; |
| long nX, nY; |
| long lXB0, lXB1, lXG0, lXG1, lXR0, lXR1; |
| double fTemp; |
| long nTemp; |
| |
| if( pReadAcc && pWriteAcc ) |
| { |
| const long nNewWidth1 = nNewWidth - 1L; |
| const long nWidth1 = pReadAcc->Width() - 1L; |
| const double fRevScaleX = (double) nWidth1 / nNewWidth1; |
| |
| pLutInt = new long[ nNewWidth ]; |
| pLutFrac = new long[ nNewWidth ]; |
| |
| for( nX = 0L, nTemp = nWidth - 2L; nX < nNewWidth; nX++ ) |
| { |
| fTemp = nX * fRevScaleX; |
| pLutInt[ nX ] = MinMax( (long) fTemp, 0, nTemp ); |
| fTemp -= pLutInt[ nX ]; |
| pLutFrac[ nX ] = (long) ( fTemp * 1024. ); |
| } |
| |
| for( nY = 0L; nY < nHeight; nY++ ) |
| { |
| if( 1 == nWidth ) |
| { |
| if( pReadAcc->HasPalette() ) |
| { |
| aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, 0 ) ); |
| } |
| else |
| { |
| aCol0 = pReadAcc->GetPixel( nY, 0 ); |
| } |
| |
| for( nX = 0L; nX < nNewWidth; nX++ ) |
| { |
| pWriteAcc->SetPixel( nY, nX, aCol0 ); |
| } |
| } |
| else |
| { |
| for( nX = 0L; nX < nNewWidth; nX++ ) |
| { |
| nTemp = pLutInt[ nX ]; |
| |
| if( pReadAcc->HasPalette() ) |
| { |
| aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp++ ) ); |
| aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp ) ); |
| } |
| else |
| { |
| aCol0 = pReadAcc->GetPixel( nY, nTemp++ ); |
| aCol1 = pReadAcc->GetPixel( nY, nTemp ); |
| } |
| |
| nTemp = pLutFrac[ nX ]; |
| |
| lXR1 = aCol1.GetRed() - ( lXR0 = aCol0.GetRed() ); |
| lXG1 = aCol1.GetGreen() - ( lXG0 = aCol0.GetGreen() ); |
| lXB1 = aCol1.GetBlue() - ( lXB0 = aCol0.GetBlue() ); |
| |
| aCol0.SetRed( (sal_uInt8) ( ( lXR1 * nTemp + ( lXR0 << 10 ) ) >> 10 ) ); |
| aCol0.SetGreen( (sal_uInt8) ( ( lXG1 * nTemp + ( lXG0 << 10 ) ) >> 10 ) ); |
| aCol0.SetBlue( (sal_uInt8) ( ( lXB1 * nTemp + ( lXB0 << 10 ) ) >> 10 ) ); |
| |
| pWriteAcc->SetPixel( nY, nX, aCol0 ); |
| } |
| } |
| } |
| |
| delete[] pLutInt; |
| delete[] pLutFrac; |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| |
| if( bRet ) |
| { |
| bRet = sal_False; |
| const Bitmap aOriginal(*this); |
| *this = aNewBmp; |
| aNewBmp = Bitmap( Size( nNewWidth, nNewHeight ), 24 ); |
| pReadAcc = AcquireReadAccess(); |
| pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pReadAcc && pWriteAcc ) |
| { |
| const long nNewHeight1 = nNewHeight - 1L; |
| const long nHeight1 = pReadAcc->Height() - 1L; |
| const double fRevScaleY = (double) nHeight1 / nNewHeight1; |
| |
| pLutInt = new long[ nNewHeight ]; |
| pLutFrac = new long[ nNewHeight ]; |
| |
| for( nY = 0L, nTemp = nHeight - 2L; nY < nNewHeight; nY++ ) |
| { |
| fTemp = nY * fRevScaleY; |
| pLutInt[ nY ] = MinMax( (long) fTemp, 0, nTemp ); |
| fTemp -= pLutInt[ nY ]; |
| pLutFrac[ nY ] = (long) ( fTemp * 1024. ); |
| } |
| |
| // after 1st step, bitmap *is* 24bit format (see above) |
| OSL_ENSURE(!pReadAcc->HasPalette(), "OOps, somehow ImplScaleInterpolate in-between format has palette, should not happen (!)"); |
| |
| for( nX = 0L; nX < nNewWidth; nX++ ) |
| { |
| if( 1 == nHeight ) |
| { |
| aCol0 = pReadAcc->GetPixel( 0, nX ); |
| |
| for( nY = 0L; nY < nNewHeight; nY++ ) |
| { |
| pWriteAcc->SetPixel( nY, nX, aCol0 ); |
| } |
| } |
| else |
| { |
| for( nY = 0L; nY < nNewHeight; nY++ ) |
| { |
| nTemp = pLutInt[ nY ]; |
| |
| aCol0 = pReadAcc->GetPixel( nTemp++, nX ); |
| aCol1 = pReadAcc->GetPixel( nTemp, nX ); |
| |
| nTemp = pLutFrac[ nY ]; |
| |
| lXR1 = aCol1.GetRed() - ( lXR0 = aCol0.GetRed() ); |
| lXG1 = aCol1.GetGreen() - ( lXG0 = aCol0.GetGreen() ); |
| lXB1 = aCol1.GetBlue() - ( lXB0 = aCol0.GetBlue() ); |
| |
| aCol0.SetRed( (sal_uInt8) ( ( lXR1 * nTemp + ( lXR0 << 10 ) ) >> 10 ) ); |
| aCol0.SetGreen( (sal_uInt8) ( ( lXG1 * nTemp + ( lXG0 << 10 ) ) >> 10 ) ); |
| aCol0.SetBlue( (sal_uInt8) ( ( lXB1 * nTemp + ( lXB0 << 10 ) ) >> 10 ) ); |
| |
| pWriteAcc->SetPixel( nY, nX, aCol0 ); |
| } |
| } |
| } |
| |
| delete[] pLutInt; |
| delete[] pLutFrac; |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| |
| if( bRet ) |
| { |
| aOriginal.ImplAdaptBitCount(aNewBmp); |
| *this = aNewBmp; |
| } |
| } |
| } |
| |
| if( !bRet ) |
| { |
| bRet = ImplScaleFast( rScaleX, rScaleY ); |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| // #121233# Added BMP_SCALE_SUPER from symphony code |
| |
| sal_Bool Bitmap::ImplScaleSuper( |
| const double& rScaleX, |
| const double& rScaleY ) |
| { |
| const Size aSizePix( GetSizePixel() ); |
| bool bHMirr = ( rScaleX < 0 ); |
| bool bVMirr = ( rScaleY < 0 ); |
| double scaleX = bHMirr ? -rScaleX : rScaleX; |
| double scaleY = bVMirr ? -rScaleY : rScaleY; |
| const long nDstW = FRound( aSizePix.Width() * scaleX ); |
| const long nDstH = FRound( aSizePix.Height() * scaleY ); |
| const double fScaleThresh = 0.6; |
| bool bRet = false; |
| |
| if( ( nDstW > 1L ) && ( nDstH > 1L ) ) |
| { |
| BitmapColor aCol0, aCol1, aColRes; |
| BitmapReadAccess* pAcc = AcquireReadAccess(); |
| long nW = pAcc->Width() ; |
| long nH = pAcc->Height() ; |
| Bitmap aOutBmp( Size( nDstW, nDstH ), 24 ); |
| BitmapWriteAccess* pWAcc = aOutBmp.AcquireWriteAccess(); |
| long* pMapIX = new long[ nDstW ]; |
| long* pMapIY = new long[ nDstH ]; |
| long* pMapFX = new long[ nDstW ]; |
| long* pMapFY = new long[ nDstH ]; |
| long nX, nY, nXDst, nYDst;; |
| double fTemp; |
| long nTemp , nTempX, nTempY, nTempFX, nTempFY; |
| sal_uInt8 cR0, cG0, cB0, cR1, cG1, cB1; |
| long nStartX = 0 , nStartY = 0; |
| long nEndX = nDstW - 1L; |
| long nEndY = nDstH - 1L; |
| long nMax = 1 << 7L; |
| |
| if( pAcc && pWAcc ) |
| { |
| const double fRevScaleX = ( nDstW > 1L ) ? ( (double) ( nW - 1 ) / ( nDstW - 1 ) ) : 0.0; |
| const double fRevScaleY = ( nDstH > 1L ) ? ( (double) ( nH - 1 ) / ( nDstH - 1 ) ) : 0.0; |
| |
| // create horizontal mapping table |
| for( nX = 0L, nTempX = nW - 1L, nTemp = nW - 2L; nX < nDstW; nX++ ) |
| { |
| fTemp = nX * fRevScaleX; |
| |
| if( bHMirr ) |
| fTemp = nTempX - fTemp; |
| |
| pMapFX[ nX ] = (long) ( ( fTemp - ( pMapIX[ nX ] = MinMax( (long) fTemp, 0, nTemp ) ) ) * 128. ); |
| } |
| |
| // create vertical mapping table |
| for( nY = 0L, nTempY = nH - 1L, nTemp = nH - 2L; nY < nDstH; nY++ ) |
| { |
| fTemp = nY * fRevScaleY; |
| |
| if( bVMirr ) |
| fTemp = nTempY - fTemp; |
| |
| pMapFY[ nY ] = (long) ( ( fTemp - ( pMapIY[ nY ] = MinMax( (long) fTemp, 0, nTemp ) ) ) * 128. ); |
| } |
| |
| if( pAcc->HasPalette() ) |
| { |
| if( pAcc->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL ) |
| { |
| if( scaleX >= fScaleThresh && scaleY >= fScaleThresh ) |
| { |
| Scanline pLine0, pLine1; |
| |
| for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; |
| pLine0 = pAcc->GetScanline( nTempY ); |
| pLine1 = pAcc->GetScanline( ++nTempY ); |
| |
| for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nTempX = pMapIX[ nX ]; nTempFX = pMapFX[ nX ]; |
| |
| const BitmapColor& rCol0 = pAcc->GetPaletteColor( pLine0[ nTempX ] ); |
| const BitmapColor& rCol2 = pAcc->GetPaletteColor( pLine1[ nTempX ] ); |
| const BitmapColor& rCol1 = pAcc->GetPaletteColor( pLine0[ ++nTempX ] ); |
| const BitmapColor& rCol3 = pAcc->GetPaletteColor( pLine1[ nTempX ] ); |
| |
| cR0 = MAP( rCol0.GetRed(), rCol1.GetRed(), nTempFX ); |
| cG0 = MAP( rCol0.GetGreen(), rCol1.GetGreen(), nTempFX ); |
| cB0 = MAP( rCol0.GetBlue(), rCol1.GetBlue(), nTempFX ); |
| |
| cR1 = MAP( rCol2.GetRed(), rCol3.GetRed(), nTempFX ); |
| cG1 = MAP( rCol2.GetGreen(), rCol3.GetGreen(), nTempFX ); |
| cB1 = MAP( rCol2.GetBlue(), rCol3.GetBlue(), nTempFX ); |
| |
| aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); |
| aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); |
| aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| } |
| } |
| } |
| else |
| { |
| Scanline pTmpY; |
| long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; |
| long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; |
| long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; |
| |
| for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTop = bVMirr ? ( nY + 1 ) : nY; |
| nBottom = bVMirr ? nY : ( nY + 1 ) ; |
| |
| if( nY ==nEndY ) |
| { |
| nLineStart = pMapIY[ nY ]; |
| nLineRange = 0; |
| } |
| else |
| { |
| nLineStart = pMapIY[ nTop ] ; |
| nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); |
| } |
| |
| for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nLeft = bHMirr ? ( nX + 1 ) : nX; |
| nRight = bHMirr ? nX : ( nX + 1 ) ; |
| |
| if( nX == nEndX ) |
| { |
| nRowStart = pMapIX[ nX ]; |
| nRowRange = 0; |
| } |
| else |
| { |
| nRowStart = pMapIX[ nLeft ]; |
| nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); |
| } |
| |
| nSumR = nSumG = nSumB = 0; |
| nTotalWeightY = 0; |
| |
| for(int i = 0; i<= nLineRange; i++) |
| { |
| pTmpY = pAcc->GetScanline( nLineStart + i ); |
| nSumRowR = nSumRowG = nSumRowB = 0; |
| nTotalWeightX = 0; |
| |
| for(int j = 0; j <= nRowRange; j++) |
| { |
| const BitmapColor& rCol = pAcc->GetPaletteColor( pTmpY[ nRowStart + j ] ); |
| |
| if(nX == nEndX ) |
| { |
| nSumRowB += rCol.GetBlue() << 7L; |
| nSumRowG += rCol.GetGreen() << 7L; |
| nSumRowR += rCol.GetRed() << 7L; |
| nTotalWeightX += 1 << 7L; |
| } |
| else if( j == 0 ) |
| { |
| nWeightX = (nMax- pMapFX[ nLeft ]) ; |
| nSumRowB += ( nWeightX *rCol.GetBlue()) ; |
| nSumRowG += ( nWeightX *rCol.GetGreen()) ; |
| nSumRowR += ( nWeightX *rCol.GetRed()) ; |
| nTotalWeightX += nWeightX; |
| } |
| else if ( nRowRange == j ) |
| { |
| nWeightX = pMapFX[ nRight ] ; |
| nSumRowB += ( nWeightX *rCol.GetBlue() ); |
| nSumRowG += ( nWeightX *rCol.GetGreen() ); |
| nSumRowR += ( nWeightX *rCol.GetRed() ); |
| nTotalWeightX += nWeightX; |
| } |
| else |
| { |
| nSumRowB += rCol.GetBlue() << 7L; |
| nSumRowG += rCol.GetGreen() << 7L; |
| nSumRowR += rCol.GetRed() << 7L; |
| nTotalWeightX += 1 << 7L; |
| } |
| } |
| |
| if( nY == nEndY ) |
| nWeightY = nMax; |
| else if( i == 0 ) |
| nWeightY = nMax - pMapFY[ nTop ]; |
| else if( nLineRange == 1 ) |
| nWeightY = pMapFY[ nTop ]; |
| else if ( nLineRange == i ) |
| nWeightY = pMapFY[ nBottom ]; |
| else |
| nWeightY = nMax; |
| |
| nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); |
| nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); |
| nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); |
| nTotalWeightY += nWeightY; |
| } |
| |
| aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); |
| aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); |
| aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| |
| } |
| } |
| } |
| } |
| else |
| { |
| if( scaleX >= fScaleThresh && scaleY >= fScaleThresh ) |
| { |
| for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTempY = pMapIY[ nY ], nTempFY = pMapFY[ nY ]; |
| |
| for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nTempX = pMapIX[ nX ]; nTempFX = pMapFX[ nX ]; |
| |
| aCol0 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nTempY, nTempX ) ); |
| aCol1 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nTempY, ++nTempX ) ); |
| cR0 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); |
| cG0 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); |
| cB0 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); |
| |
| aCol1 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( ++nTempY, nTempX ) ); |
| aCol0 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nTempY--, --nTempX ) ); |
| cR1 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); |
| cG1 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); |
| cB1 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); |
| |
| aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); |
| aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); |
| aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| } |
| } |
| |
| } |
| else |
| { |
| long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; |
| long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; |
| long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; |
| |
| for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTop = bVMirr ? ( nY + 1 ) : nY; |
| nBottom = bVMirr ? nY : ( nY + 1 ) ; |
| |
| if( nY ==nEndY ) |
| { |
| nLineStart = pMapIY[ nY ]; |
| nLineRange = 0; |
| } |
| else |
| { |
| nLineStart = pMapIY[ nTop ] ; |
| nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); |
| } |
| |
| for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nLeft = bHMirr ? ( nX + 1 ) : nX; |
| nRight = bHMirr ? nX : ( nX + 1 ) ; |
| |
| if( nX == nEndX ) |
| { |
| nRowStart = pMapIX[ nX ]; |
| nRowRange = 0; |
| } |
| else |
| { |
| nRowStart = pMapIX[ nLeft ]; |
| nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); |
| } |
| |
| nSumR = nSumG = nSumB = 0; |
| nTotalWeightY = 0; |
| |
| for(int i = 0; i<= nLineRange; i++) |
| { |
| nSumRowR = nSumRowG = nSumRowB = 0; |
| nTotalWeightX = 0; |
| |
| for(int j = 0; j <= nRowRange; j++) |
| { |
| aCol0 = pAcc->GetPaletteColor ( pAcc->GetPixelIndex( nLineStart + i, nRowStart + j ) ); |
| |
| if(nX == nEndX ) |
| { |
| |
| nSumRowB += aCol0.GetBlue() << 7L; |
| nSumRowG += aCol0.GetGreen() << 7L; |
| nSumRowR += aCol0.GetRed() << 7L; |
| nTotalWeightX += 1 << 7L; |
| } |
| else if( j == 0 ) |
| { |
| |
| nWeightX = (nMax- pMapFX[ nLeft ]) ; |
| nSumRowB += ( nWeightX *aCol0.GetBlue()) ; |
| nSumRowG += ( nWeightX *aCol0.GetGreen()) ; |
| nSumRowR += ( nWeightX *aCol0.GetRed()) ; |
| nTotalWeightX += nWeightX; |
| } |
| else if ( nRowRange == j ) |
| { |
| |
| nWeightX = pMapFX[ nRight ] ; |
| nSumRowB += ( nWeightX *aCol0.GetBlue() ); |
| nSumRowG += ( nWeightX *aCol0.GetGreen() ); |
| nSumRowR += ( nWeightX *aCol0.GetRed() ); |
| nTotalWeightX += nWeightX; |
| } |
| else |
| { |
| |
| nSumRowB += aCol0.GetBlue() << 7L; |
| nSumRowG += aCol0.GetGreen() << 7L; |
| nSumRowR += aCol0.GetRed() << 7L; |
| nTotalWeightX += 1 << 7L; |
| } |
| } |
| |
| if( nY == nEndY ) |
| nWeightY = nMax; |
| else if( i == 0 ) |
| nWeightY = nMax - pMapFY[ nTop ]; |
| else if( nLineRange == 1 ) |
| nWeightY = pMapFY[ nTop ]; |
| else if ( nLineRange == i ) |
| nWeightY = pMapFY[ nBottom ]; |
| else |
| nWeightY = nMax; |
| |
| nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); |
| nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); |
| nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); |
| nTotalWeightY += nWeightY; |
| } |
| |
| aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); |
| aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); |
| aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_BGR ) |
| { |
| if( scaleX >= fScaleThresh && scaleY >= fScaleThresh ) |
| { |
| Scanline pLine0, pLine1, pTmp0, pTmp1; |
| long nOff; |
| |
| for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; |
| pLine0 = pAcc->GetScanline( nTempY ); |
| pLine1 = pAcc->GetScanline( ++nTempY ); |
| |
| for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nOff = 3L * ( nTempX = pMapIX[ nX ] ); |
| nTempFX = pMapFX[ nX ]; |
| |
| pTmp1 = ( pTmp0 = pLine0 + nOff ) + 3L; |
| cB0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cG0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cR0 = MAP( *pTmp0, *pTmp1, nTempFX ); |
| |
| pTmp1 = ( pTmp0 = pLine1 + nOff ) + 3L; |
| cB1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cG1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cR1 = MAP( *pTmp0, *pTmp1, nTempFX ); |
| |
| aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); |
| aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); |
| aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| } |
| } |
| } |
| else |
| { |
| Scanline pTmpY, pTmpX; |
| long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; |
| long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; |
| long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; |
| |
| for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTop = bVMirr ? ( nY + 1 ) : nY; |
| nBottom = bVMirr ? nY : ( nY + 1 ) ; |
| |
| if( nY ==nEndY ) |
| { |
| nLineStart = pMapIY[ nY ]; |
| nLineRange = 0; |
| } |
| else |
| { |
| nLineStart = pMapIY[ nTop ] ; |
| nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); |
| } |
| |
| for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nLeft = bHMirr ? ( nX + 1 ) : nX; |
| nRight = bHMirr ? nX : ( nX + 1 ) ; |
| |
| if( nX == nEndX ) |
| { |
| nRowStart = pMapIX[ nX ]; |
| nRowRange = 0; |
| } |
| else |
| { |
| nRowStart = pMapIX[ nLeft ]; |
| nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); |
| } |
| |
| nSumR = nSumG = nSumB = 0; |
| nTotalWeightY = 0; |
| |
| for(int i = 0; i<= nLineRange; i++) |
| { |
| pTmpY = pAcc->GetScanline( nLineStart + i ); |
| pTmpX = pTmpY + 3L * nRowStart; |
| nSumRowR = nSumRowG = nSumRowB = 0; |
| nTotalWeightX = 0; |
| |
| for(int j = 0; j <= nRowRange; j++) |
| { |
| if(nX == nEndX ) |
| { |
| nSumRowB += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowG += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowR += ( *pTmpX ) << 7L;pTmpX++; |
| nTotalWeightX += 1 << 7L; |
| } |
| else if( j == 0 ) |
| { |
| nWeightX = (nMax- pMapFX[ nLeft ]) ; |
| nSumRowB += ( nWeightX *( *pTmpX )) ;pTmpX++; |
| nSumRowG += ( nWeightX *( *pTmpX )) ;pTmpX++; |
| nSumRowR += ( nWeightX *( *pTmpX )) ;pTmpX++; |
| nTotalWeightX += nWeightX; |
| } |
| else if ( nRowRange == j ) |
| { |
| nWeightX = pMapFX[ nRight ] ; |
| nSumRowB += ( nWeightX *( *pTmpX ) );pTmpX++; |
| nSumRowG += ( nWeightX *( *pTmpX ) );pTmpX++; |
| nSumRowR += ( nWeightX *( *pTmpX ) );pTmpX++; |
| nTotalWeightX += nWeightX; |
| } |
| else |
| { |
| nSumRowB += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowG += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowR += ( *pTmpX ) << 7L;pTmpX++; |
| nTotalWeightX += 1 << 7L; |
| } |
| } |
| |
| if( nY == nEndY ) |
| nWeightY = nMax; |
| else if( i == 0 ) |
| nWeightY = nMax - pMapFY[ nTop ]; |
| else if( nLineRange == 1 ) |
| nWeightY = pMapFY[ nTop ]; |
| else if ( nLineRange == i ) |
| nWeightY = pMapFY[ nBottom ]; |
| else |
| nWeightY = nMax; |
| |
| nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); |
| nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); |
| nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); |
| nTotalWeightY += nWeightY; |
| } |
| |
| aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); |
| aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); |
| aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| |
| } |
| } |
| } |
| } |
| else if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_RGB ) |
| { |
| if( scaleX >= fScaleThresh && scaleY >= fScaleThresh ) |
| { |
| Scanline pLine0, pLine1, pTmp0, pTmp1; |
| long nOff; |
| |
| for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; |
| pLine0 = pAcc->GetScanline( nTempY ); |
| pLine1 = pAcc->GetScanline( ++nTempY ); |
| |
| for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nOff = 3L * ( nTempX = pMapIX[ nX ] ); |
| nTempFX = pMapFX[ nX ]; |
| |
| pTmp1 = ( pTmp0 = pLine0 + nOff ) + 3L; |
| cR0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cG0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cB0 = MAP( *pTmp0, *pTmp1, nTempFX ); |
| |
| pTmp1 = ( pTmp0 = pLine1 + nOff ) + 3L; |
| cR1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cG1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; |
| cB1 = MAP( *pTmp0, *pTmp1, nTempFX ); |
| |
| aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); |
| aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); |
| aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| } |
| } |
| } |
| else |
| { |
| Scanline pTmpY, pTmpX; |
| long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; |
| long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; |
| long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; |
| |
| for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTop = bVMirr ? ( nY + 1 ) : nY; |
| nBottom = bVMirr ? nY : ( nY + 1 ) ; |
| |
| if( nY ==nEndY ) |
| { |
| nLineStart = pMapIY[ nY ]; |
| nLineRange = 0; |
| } |
| else |
| { |
| nLineStart = pMapIY[ nTop ] ; |
| nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); |
| } |
| |
| for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nLeft = bHMirr ? ( nX + 1 ) : nX; |
| nRight = bHMirr ? nX : ( nX + 1 ) ; |
| |
| if( nX == nEndX ) |
| { |
| nRowStart = pMapIX[ nX ]; |
| nRowRange = 0; |
| } |
| else |
| { |
| nRowStart = pMapIX[ nLeft ]; |
| nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); |
| } |
| |
| nSumR = nSumG = nSumB = 0; |
| nTotalWeightY = 0; |
| |
| for(int i = 0; i<= nLineRange; i++) |
| { |
| pTmpY = pAcc->GetScanline( nLineStart + i ); |
| pTmpX = pTmpY + 3L * nRowStart; |
| nSumRowR = nSumRowG = nSumRowB = 0; |
| nTotalWeightX = 0; |
| |
| for(int j = 0; j <= nRowRange; j++) |
| { |
| if(nX == nEndX ) |
| { |
| nSumRowR += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowG += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowB += ( *pTmpX ) << 7L;pTmpX++; |
| nTotalWeightX += 1 << 7L; |
| } |
| else if( j == 0 ) |
| { |
| nWeightX = (nMax- pMapFX[ nLeft ]) ; |
| nSumRowR += ( nWeightX *( *pTmpX )) ;pTmpX++; |
| nSumRowG += ( nWeightX *( *pTmpX )) ;pTmpX++; |
| nSumRowB += ( nWeightX *( *pTmpX )) ;pTmpX++; |
| nTotalWeightX += nWeightX; |
| } |
| else if ( nRowRange == j ) |
| { |
| nWeightX = pMapFX[ nRight ] ; |
| nSumRowR += ( nWeightX *( *pTmpX ) );pTmpX++; |
| nSumRowG += ( nWeightX *( *pTmpX ) );pTmpX++; |
| nSumRowB += ( nWeightX *( *pTmpX ) );pTmpX++; |
| nTotalWeightX += nWeightX; |
| } |
| else |
| { |
| nSumRowR += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowG += ( *pTmpX ) << 7L;pTmpX++; |
| nSumRowB += ( *pTmpX ) << 7L;pTmpX++; |
| nTotalWeightX += 1 << 7L; |
| } |
| } |
| |
| if( nY == nEndY ) |
| nWeightY = nMax; |
| else if( i == 0 ) |
| nWeightY = nMax - pMapFY[ nTop ]; |
| else if( nLineRange == 1 ) |
| nWeightY = pMapFY[ nTop ]; |
| else if ( nLineRange == i ) |
| nWeightY = pMapFY[ nBottom ]; |
| else |
| nWeightY = nMax; |
| |
| nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); |
| nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); |
| nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); |
| nTotalWeightY += nWeightY; |
| } |
| |
| aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); |
| aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); |
| aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| |
| } |
| } |
| } |
| } |
| else |
| { |
| if( scaleX >= fScaleThresh && scaleY >= fScaleThresh ) |
| { |
| for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; |
| |
| for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nTempX = pMapIX[ nX ]; nTempFX = pMapFX[ nX ]; |
| |
| aCol0 = pAcc->GetPixel( nTempY, nTempX ); |
| aCol1 = pAcc->GetPixel( nTempY, ++nTempX ); |
| cR0 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); |
| cG0 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); |
| cB0 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); |
| |
| aCol1 = pAcc->GetPixel( ++nTempY, nTempX ); |
| aCol0 = pAcc->GetPixel( nTempY--, --nTempX ); |
| cR1 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); |
| cG1 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); |
| cB1 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); |
| |
| aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); |
| aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); |
| aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| } |
| } |
| } |
| else |
| { |
| long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; |
| long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; |
| long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; |
| |
| for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) |
| { |
| nTop = bVMirr ? ( nY + 1 ) : nY; |
| nBottom = bVMirr ? nY : ( nY + 1 ) ; |
| |
| if( nY ==nEndY ) |
| { |
| nLineStart = pMapIY[ nY ]; |
| nLineRange = 0; |
| } |
| else |
| { |
| nLineStart = pMapIY[ nTop ] ; |
| nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); |
| } |
| |
| for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) |
| { |
| nLeft = bHMirr ? ( nX + 1 ) : nX; |
| nRight = bHMirr ? nX : ( nX + 1 ) ; |
| |
| if( nX == nEndX ) |
| { |
| nRowStart = pMapIX[ nX ]; |
| nRowRange = 0; |
| } |
| else |
| { |
| nRowStart = pMapIX[ nLeft ]; |
| nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); |
| } |
| |
| nSumR = nSumG = nSumB = 0; |
| nTotalWeightY = 0; |
| |
| for(int i = 0; i<= nLineRange; i++) |
| { |
| nSumRowR = nSumRowG = nSumRowB = 0; |
| nTotalWeightX = 0; |
| |
| for(int j = 0; j <= nRowRange; j++) |
| { |
| aCol0 = pAcc->GetPixel( nLineStart + i, nRowStart + j ); |
| |
| if(nX == nEndX ) |
| { |
| |
| nSumRowB += aCol0.GetBlue() << 7L; |
| nSumRowG += aCol0.GetGreen() << 7L; |
| nSumRowR += aCol0.GetRed() << 7L; |
| nTotalWeightX += 1 << 7L; |
| } |
| else if( j == 0 ) |
| { |
| |
| nWeightX = (nMax- pMapFX[ nLeft ]) ; |
| nSumRowB += ( nWeightX *aCol0.GetBlue()) ; |
| nSumRowG += ( nWeightX *aCol0.GetGreen()) ; |
| nSumRowR += ( nWeightX *aCol0.GetRed()) ; |
| nTotalWeightX += nWeightX; |
| } |
| else if ( nRowRange == j ) |
| { |
| |
| nWeightX = pMapFX[ nRight ] ; |
| nSumRowB += ( nWeightX *aCol0.GetBlue() ); |
| nSumRowG += ( nWeightX *aCol0.GetGreen() ); |
| nSumRowR += ( nWeightX *aCol0.GetRed() ); |
| nTotalWeightX += nWeightX; |
| } |
| else |
| { |
| nSumRowB += aCol0.GetBlue() << 7L; |
| nSumRowG += aCol0.GetGreen() << 7L; |
| nSumRowR += aCol0.GetRed() << 7L; |
| nTotalWeightX += 1 << 7L; |
| } |
| } |
| |
| if( nY == nEndY ) |
| nWeightY = nMax; |
| else if( i == 0 ) |
| nWeightY = nMax - pMapFY[ nTop ]; |
| else if( nLineRange == 1 ) |
| nWeightY = pMapFY[ nTop ]; |
| else if ( nLineRange == i ) |
| nWeightY = pMapFY[ nBottom ]; |
| else |
| nWeightY = nMax; |
| |
| nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); |
| nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); |
| nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); |
| nTotalWeightY += nWeightY; |
| } |
| |
| aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); |
| aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); |
| aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); |
| pWAcc->SetPixel( nYDst, nXDst++, aColRes ); |
| |
| } |
| } |
| } |
| } |
| } |
| |
| bRet = true; |
| } |
| |
| delete[] pMapIX; |
| delete[] pMapIY; |
| delete[] pMapFX; |
| delete[] pMapFY; |
| |
| ReleaseAccess( pAcc ); |
| aOutBmp.ReleaseAccess( pWAcc ); |
| |
| if( bRet ) |
| { |
| ImplAdaptBitCount(aOutBmp); |
| ImplAssignWithSize(aOutBmp); |
| } |
| |
| if( !bRet ) |
| bRet = ImplScaleFast( scaleX, scaleY ); |
| } |
| |
| return bRet; |
| } |
| |
| //----------------------------------------------------------------------------------- |
| |
| namespace |
| { |
| void ImplCalculateContributions( |
| const sal_uInt32 aSourceSize, |
| const sal_uInt32 aDestinationSize, |
| sal_uInt32& aNumberOfContributions, |
| double*& pWeights, |
| sal_uInt32*& pPixels, |
| sal_uInt32*& pCount, |
| const Kernel& aKernel) |
| { |
| const double fSamplingRadius(aKernel.GetWidth()); |
| const double fScale(aDestinationSize / static_cast< double >(aSourceSize)); |
| const double fScaledRadius((fScale < 1.0) ? fSamplingRadius / fScale : fSamplingRadius); |
| const double fFilterFactor((fScale < 1.0) ? fScale : 1.0); |
| |
| aNumberOfContributions = (static_cast< sal_uInt32 >(fabs(ceil(fScaledRadius))) * 2) + 1; |
| const sal_uInt32 nAllocSize(aDestinationSize * aNumberOfContributions); |
| pWeights = new double[nAllocSize]; |
| pPixels = new sal_uInt32[nAllocSize]; |
| pCount = new sal_uInt32[aDestinationSize]; |
| |
| for(sal_uInt32 i(0); i < aDestinationSize; i++) |
| { |
| const sal_uInt32 aIndex(i * aNumberOfContributions); |
| const double aCenter(i / fScale); |
| const sal_Int32 aLeft(static_cast< sal_Int32 >(floor(aCenter - fScaledRadius))); |
| const sal_Int32 aRight(static_cast< sal_Int32 >(ceil(aCenter + fScaledRadius))); |
| sal_uInt32 aCurrentCount(0); |
| |
| for(sal_Int32 j(aLeft); j <= aRight; j++) |
| { |
| const double aWeight(aKernel.Calculate(fFilterFactor * (aCenter - static_cast< double>(j)))); |
| |
| // Reduce calculations with ignoring weights of 0.0 |
| if(fabs(aWeight) < 0.0001) |
| { |
| continue; |
| } |
| |
| // Handling on edges |
| const sal_uInt32 aPixelIndex(MinMax(j, 0, aSourceSize - 1)); |
| const sal_uInt32 nIndex(aIndex + aCurrentCount); |
| |
| pWeights[nIndex] = aWeight; |
| pPixels[nIndex] = aPixelIndex; |
| |
| aCurrentCount++; |
| } |
| |
| pCount[i] = aCurrentCount; |
| } |
| } |
| |
| sal_Bool ImplScaleConvolutionHor( |
| Bitmap& rSource, |
| Bitmap& rTarget, |
| const double& rScaleX, |
| const Kernel& aKernel) |
| { |
| // Do horizontal filtering |
| OSL_ENSURE(rScaleX > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)"); |
| const sal_uInt32 nWidth(rSource.GetSizePixel().Width()); |
| const sal_uInt32 nNewWidth(FRound(nWidth * rScaleX)); |
| |
| if(nWidth == nNewWidth) |
| { |
| return true; |
| } |
| |
| BitmapReadAccess* pReadAcc = rSource.AcquireReadAccess(); |
| |
| if(pReadAcc) |
| { |
| double* pWeights = 0; |
| sal_uInt32* pPixels = 0; |
| sal_uInt32* pCount = 0; |
| sal_uInt32 aNumberOfContributions(0); |
| |
| const sal_uInt32 nHeight(rSource.GetSizePixel().Height()); |
| ImplCalculateContributions(nWidth, nNewWidth, aNumberOfContributions, pWeights, pPixels, pCount, aKernel); |
| rTarget = Bitmap(Size(nNewWidth, nHeight), 24); |
| BitmapWriteAccess* pWriteAcc = rTarget.AcquireWriteAccess(); |
| bool bResult(0 != pWriteAcc); |
| |
| if(bResult) |
| { |
| for(sal_uInt32 y(0); y < nHeight; y++) |
| { |
| for(sal_uInt32 x(0); x < nNewWidth; x++) |
| { |
| const sal_uInt32 aBaseIndex(x * aNumberOfContributions); |
| double aSum(0.0); |
| double aValueRed(0.0); |
| double aValueGreen(0.0); |
| double aValueBlue(0.0); |
| |
| for(sal_uInt32 j(0); j < pCount[x]; j++) |
| { |
| const sal_uInt32 aIndex(aBaseIndex + j); |
| const double aWeight(pWeights[aIndex]); |
| BitmapColor aColor; |
| |
| aSum += aWeight; |
| |
| if(pReadAcc->HasPalette()) |
| { |
| aColor = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(y, pPixels[aIndex])); |
| } |
| else |
| { |
| aColor = pReadAcc->GetPixel(y, pPixels[aIndex]); |
| } |
| |
| aValueRed += aWeight * aColor.GetRed(); |
| aValueGreen += aWeight * aColor.GetGreen(); |
| aValueBlue += aWeight * aColor.GetBlue(); |
| } |
| |
| const BitmapColor aResultColor( |
| static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueRed / aSum), 0, 255)), |
| static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueGreen / aSum), 0, 255)), |
| static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueBlue / aSum), 0, 255))); |
| |
| pWriteAcc->SetPixel(y, x, aResultColor); |
| } |
| } |
| |
| rTarget.ReleaseAccess(pWriteAcc); |
| } |
| |
| rSource.ReleaseAccess(pReadAcc); |
| delete[] pWeights; |
| delete[] pCount; |
| delete[] pPixels; |
| |
| if(bResult) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool ImplScaleConvolutionVer( |
| Bitmap& rSource, |
| Bitmap& rTarget, |
| const double& rScaleY, |
| const Kernel& aKernel) |
| { |
| // Do vertical filtering |
| OSL_ENSURE(rScaleY > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)"); |
| const sal_uInt32 nHeight(rSource.GetSizePixel().Height()); |
| const sal_uInt32 nNewHeight(FRound(nHeight * rScaleY)); |
| |
| if(nHeight == nNewHeight) |
| { |
| return true; |
| } |
| |
| BitmapReadAccess* pReadAcc = rSource.AcquireReadAccess(); |
| |
| if(pReadAcc) |
| { |
| double* pWeights = 0; |
| sal_uInt32* pPixels = 0; |
| sal_uInt32* pCount = 0; |
| sal_uInt32 aNumberOfContributions(0); |
| |
| const sal_uInt32 nWidth(rSource.GetSizePixel().Width()); |
| ImplCalculateContributions(nHeight, nNewHeight, aNumberOfContributions, pWeights, pPixels, pCount, aKernel); |
| rTarget = Bitmap(Size(nWidth, nNewHeight), 24); |
| BitmapWriteAccess* pWriteAcc = rTarget.AcquireWriteAccess(); |
| bool bResult(0 != pWriteAcc); |
| |
| if(pWriteAcc) |
| { |
| for(sal_uInt32 x(0); x < nWidth; x++) |
| { |
| for(sal_uInt32 y(0); y < nNewHeight; y++) |
| { |
| const sal_uInt32 aBaseIndex(y * aNumberOfContributions); |
| double aSum(0.0); |
| double aValueRed(0.0); |
| double aValueGreen(0.0); |
| double aValueBlue(0.0); |
| |
| for(sal_uInt32 j(0); j < pCount[y]; j++) |
| { |
| const sal_uInt32 aIndex(aBaseIndex + j); |
| const double aWeight(pWeights[aIndex]); |
| BitmapColor aColor; |
| |
| aSum += aWeight; |
| |
| if(pReadAcc->HasPalette()) |
| { |
| aColor = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(pPixels[aIndex], x)); |
| } |
| else |
| { |
| aColor = pReadAcc->GetPixel(pPixels[aIndex], x); |
| } |
| |
| aValueRed += aWeight * aColor.GetRed(); |
| aValueGreen += aWeight * aColor.GetGreen(); |
| aValueBlue += aWeight * aColor.GetBlue(); |
| } |
| |
| const BitmapColor aResultColor( |
| static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueRed / aSum), 0, 255)), |
| static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueGreen / aSum), 0, 255)), |
| static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueBlue / aSum), 0, 255))); |
| |
| if(pWriteAcc->HasPalette()) |
| { |
| pWriteAcc->SetPixelIndex(y, x, static_cast< sal_uInt8 >(pWriteAcc->GetBestPaletteIndex(aResultColor))); |
| } |
| else |
| { |
| pWriteAcc->SetPixel(y, x, aResultColor); |
| } |
| } |
| } |
| } |
| |
| rTarget.ReleaseAccess(pWriteAcc); |
| rSource.ReleaseAccess(pReadAcc); |
| |
| delete[] pWeights; |
| delete[] pCount; |
| delete[] pPixels; |
| |
| if(bResult) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| } |
| |
| // #121233# Added BMP_SCALE_LANCZOS, BMP_SCALE_BICUBIC, BMP_SCALE_BILINEAR and |
| // BMP_SCALE_BOX derived from the original commit from Tomaž Vajngerl (see |
| // bugzilla task for deitails) Thanks! |
| sal_Bool Bitmap::ImplScaleConvolution( |
| const double& rScaleX, |
| const double& rScaleY, |
| const Kernel& aKernel) |
| { |
| const bool bMirrorHor(rScaleX < 0.0); |
| const bool bMirrorVer(rScaleY < 0.0); |
| const double fScaleX(bMirrorHor ? -rScaleX : rScaleX); |
| const double fScaleY(bMirrorVer ? -rScaleY : rScaleY); |
| const sal_uInt32 nWidth(GetSizePixel().Width()); |
| const sal_uInt32 nHeight(GetSizePixel().Height()); |
| const sal_uInt32 nNewWidth(FRound(nWidth * fScaleX)); |
| const sal_uInt32 nNewHeight(FRound(nHeight * fScaleY)); |
| const bool bScaleHor(nWidth != nNewWidth); |
| const bool bScaleVer(nHeight != nNewHeight); |
| const bool bMirror(bMirrorHor || bMirrorVer); |
| |
| if(!bMirror && !bScaleHor && !bScaleVer) |
| { |
| return true; |
| } |
| |
| bool bResult(true); |
| sal_uInt32 nMirrorFlags(BMP_MIRROR_NONE); |
| bool bMirrorAfter(false); |
| |
| if(bMirror) |
| { |
| if(bMirrorHor) |
| { |
| nMirrorFlags |= BMP_MIRROR_HORZ; |
| } |
| |
| if(bMirrorVer) |
| { |
| nMirrorFlags |= BMP_MIRROR_VERT; |
| } |
| |
| const sal_uInt32 nStartSize(nWidth * nHeight); |
| const sal_uInt32 nEndSize(nNewWidth * nNewHeight); |
| |
| bMirrorAfter = nStartSize > nEndSize; |
| |
| if(!bMirrorAfter) |
| { |
| bResult = Mirror(nMirrorFlags); |
| } |
| } |
| |
| Bitmap aResult; |
| |
| if(bResult) |
| { |
| const sal_uInt32 nInBetweenSizeHorFirst(nHeight * nNewWidth); |
| const sal_uInt32 nInBetweenSizeVerFirst(nNewHeight * nWidth); |
| Bitmap aSource(*this); |
| |
| if(nInBetweenSizeHorFirst < nInBetweenSizeVerFirst) |
| { |
| if(bScaleHor) |
| { |
| bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel); |
| } |
| |
| if(bResult && bScaleVer) |
| { |
| if(bScaleHor) |
| { |
| // copy partial result, independent of color depth |
| aSource = aResult; |
| } |
| |
| bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel); |
| } |
| } |
| else |
| { |
| if(bScaleVer) |
| { |
| bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel); |
| } |
| |
| if(bResult && bScaleHor) |
| { |
| if(bScaleVer) |
| { |
| // copy partial result, independent of color depth |
| aSource = aResult; |
| } |
| |
| bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel); |
| } |
| } |
| } |
| |
| if(bResult && bMirrorAfter) |
| { |
| bResult = aResult.Mirror(nMirrorFlags); |
| } |
| |
| if(bResult) |
| { |
| ImplAdaptBitCount(aResult); |
| *this = aResult; |
| } |
| |
| return bResult; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::Dither( sal_uLong nDitherFlags ) |
| { |
| sal_Bool bRet = sal_False; |
| |
| const Size aSizePix( GetSizePixel() ); |
| |
| if( aSizePix.Width() == 1 || aSizePix.Height() == 1 ) |
| bRet = sal_True; |
| else if( nDitherFlags & BMP_DITHER_MATRIX ) |
| bRet = ImplDitherMatrix(); |
| else if( nDitherFlags & BMP_DITHER_FLOYD ) |
| bRet = ImplDitherFloyd(); |
| else if( ( nDitherFlags & BMP_DITHER_FLOYD_16 ) && ( GetBitCount() == 24 ) ) |
| bRet = ImplDitherFloyd16(); |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplDitherMatrix() |
| { |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| Bitmap aNewBmp( GetSizePixel(), 8 ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc && pWriteAcc ) |
| { |
| const sal_uLong nWidth = pReadAcc->Width(); |
| const sal_uLong nHeight = pReadAcc->Height(); |
| BitmapColor aIndex( (sal_uInt8) 0 ); |
| |
| if( pReadAcc->HasPalette() ) |
| { |
| for( sal_uLong nY = 0UL; nY < nHeight; nY++ ) |
| { |
| for( sal_uLong nX = 0UL, nModY = ( nY & 0x0FUL ) << 4UL; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aCol( pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) ) ); |
| const sal_uLong nD = nVCLDitherLut[ nModY + ( nX & 0x0FUL ) ]; |
| const sal_uLong nR = ( nVCLLut[ aCol.GetRed() ] + nD ) >> 16UL; |
| const sal_uLong nG = ( nVCLLut[ aCol.GetGreen() ] + nD ) >> 16UL; |
| const sal_uLong nB = ( nVCLLut[ aCol.GetBlue() ] + nD ) >> 16UL; |
| |
| aIndex.SetIndex( (sal_uInt8) ( nVCLRLut[ nR ] + nVCLGLut[ nG ] + nVCLBLut[ nB ] ) ); |
| pWriteAcc->SetPixel( nY, nX, aIndex ); |
| } |
| } |
| } |
| else |
| { |
| for( sal_uLong nY = 0UL; nY < nHeight; nY++ ) |
| { |
| for( sal_uLong nX = 0UL, nModY = ( nY & 0x0FUL ) << 4UL; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aCol( pReadAcc->GetPixel( nY, nX ) ); |
| const sal_uLong nD = nVCLDitherLut[ nModY + ( nX & 0x0FUL ) ]; |
| const sal_uLong nR = ( nVCLLut[ aCol.GetRed() ] + nD ) >> 16UL; |
| const sal_uLong nG = ( nVCLLut[ aCol.GetGreen() ] + nD ) >> 16UL; |
| const sal_uLong nB = ( nVCLLut[ aCol.GetBlue() ] + nD ) >> 16UL; |
| |
| aIndex.SetIndex( (sal_uInt8) ( nVCLRLut[ nR ] + nVCLGLut[ nG ] + nVCLBLut[ nB ] ) ); |
| pWriteAcc->SetPixel( nY, nX, aIndex ); |
| } |
| } |
| } |
| |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplDitherFloyd() |
| { |
| const Size aSize( GetSizePixel() ); |
| sal_Bool bRet = sal_False; |
| |
| if( ( aSize.Width() > 3 ) && ( aSize.Height() > 2 ) ) |
| { |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| Bitmap aNewBmp( GetSizePixel(), 8 ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pReadAcc && pWriteAcc ) |
| { |
| BitmapColor aColor; |
| long nWidth = pReadAcc->Width(); |
| long nWidth1 = nWidth - 1L; |
| long nHeight = pReadAcc->Height(); |
| long nX; |
| long nW = nWidth * 3L; |
| long nW2 = nW - 3L; |
| long nRErr, nGErr, nBErr; |
| long nRC, nGC, nBC; |
| long nTemp; |
| long nZ; |
| long* p1 = new long[ nW ]; |
| long* p2 = new long[ nW ]; |
| long* p1T = p1; |
| long* p2T = p2; |
| long* pTmp; |
| sal_Bool bPal = pReadAcc->HasPalette(); |
| |
| pTmp = p2T; |
| |
| if( bPal ) |
| { |
| for( nZ = 0; nZ < nWidth; nZ++ ) |
| { |
| aColor = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( 0, nZ ) ); |
| |
| *pTmp++ = (long) aColor.GetBlue() << 12; |
| *pTmp++ = (long) aColor.GetGreen() << 12; |
| *pTmp++ = (long) aColor.GetRed() << 12; |
| } |
| } |
| else |
| { |
| for( nZ = 0; nZ < nWidth; nZ++ ) |
| { |
| aColor = pReadAcc->GetPixel( 0, nZ ); |
| |
| *pTmp++ = (long) aColor.GetBlue() << 12; |
| *pTmp++ = (long) aColor.GetGreen() << 12; |
| *pTmp++ = (long) aColor.GetRed() << 12; |
| } |
| } |
| |
| for( long nY = 1, nYAcc = 0L; nY <= nHeight; nY++, nYAcc++ ) |
| { |
| pTmp = p1T; |
| p1T = p2T; |
| p2T = pTmp; |
| |
| if( nY < nHeight ) |
| { |
| if( bPal ) |
| { |
| for( nZ = 0; nZ < nWidth; nZ++ ) |
| { |
| aColor = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nZ ) ); |
| |
| *pTmp++ = (long) aColor.GetBlue() << 12; |
| *pTmp++ = (long) aColor.GetGreen() << 12; |
| *pTmp++ = (long) aColor.GetRed() << 12; |
| } |
| } |
| else |
| { |
| for( nZ = 0; nZ < nWidth; nZ++ ) |
| { |
| aColor = pReadAcc->GetPixel( nY, nZ ); |
| |
| *pTmp++ = (long) aColor.GetBlue() << 12; |
| *pTmp++ = (long) aColor.GetGreen() << 12; |
| *pTmp++ = (long) aColor.GetRed() << 12; |
| } |
| } |
| } |
| |
| // erstes Pixel gesondert betrachten |
| nX = 0; |
| CALC_ERRORS; |
| CALC_TABLES7; |
| nX -= 5; |
| CALC_TABLES5; |
| pWriteAcc->SetPixelIndex( nYAcc, 0, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) ); |
| |
| // mittlere Pixel ueber Schleife |
| long nXAcc; |
| for ( nX = 3L, nXAcc = 1L; nX < nW2; nXAcc++ ) |
| { |
| CALC_ERRORS; |
| CALC_TABLES7; |
| nX -= 8; |
| CALC_TABLES3; |
| CALC_TABLES5; |
| pWriteAcc->SetPixelIndex( nYAcc, nXAcc, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) ); |
| } |
| |
| // letztes Pixel gesondert betrachten |
| CALC_ERRORS; |
| nX -= 5; |
| CALC_TABLES3; |
| CALC_TABLES5; |
| pWriteAcc->SetPixelIndex( nYAcc, nWidth1, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) ); |
| } |
| |
| delete[] p1; |
| delete[] p2; |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aPrefSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aPrefSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplDitherFloyd16() |
| { |
| BitmapReadAccess* pReadAcc = AcquireReadAccess(); |
| Bitmap aNewBmp( GetSizePixel(), 24 ); |
| BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); |
| sal_Bool bRet = sal_False; |
| |
| if( pReadAcc && pWriteAcc ) |
| { |
| const long nWidth = pWriteAcc->Width(); |
| const long nWidth1 = nWidth - 1L; |
| const long nHeight = pWriteAcc->Height(); |
| BitmapColor aColor; |
| BitmapColor aBestCol; |
| ImpErrorQuad aErrQuad; |
| ImpErrorQuad* pErrQuad1 = new ImpErrorQuad[ nWidth ]; |
| ImpErrorQuad* pErrQuad2 = new ImpErrorQuad[ nWidth ]; |
| ImpErrorQuad* pQLine1 = pErrQuad1; |
| ImpErrorQuad* pQLine2 = 0; |
| long nX, nY; |
| long nYTmp = 0L; |
| sal_Bool bQ1 = sal_True; |
| |
| for( nY = 0L; nY < Min( nHeight, 2L ); nY++, nYTmp++ ) |
| for( nX = 0L, pQLine2 = !nY ? pErrQuad1 : pErrQuad2; nX < nWidth; nX++ ) |
| pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX ); |
| |
| for( nY = 0L; nY < nHeight; nY++, nYTmp++ ) |
| { |
| // erstes ZeilenPixel |
| aBestCol = pQLine1[ 0 ].ImplGetColor(); |
| aBestCol.SetRed( ( aBestCol.GetRed() & 248 ) | 7 ); |
| aBestCol.SetGreen( ( aBestCol.GetGreen() & 248 ) | 7 ); |
| aBestCol.SetBlue( ( aBestCol.GetBlue() & 248 ) | 7 ); |
| pWriteAcc->SetPixel( nY, 0, aBestCol ); |
| |
| for( nX = 1L; nX < nWidth1; nX++ ) |
| { |
| aColor = pQLine1[ nX ].ImplGetColor(); |
| aBestCol.SetRed( ( aColor.GetRed() & 248 ) | 7 ); |
| aBestCol.SetGreen( ( aColor.GetGreen() & 248 ) | 7 ); |
| aBestCol.SetBlue( ( aColor.GetBlue() & 248 ) | 7 ); |
| aErrQuad = ( ImpErrorQuad( aColor ) -= aBestCol ); |
| pQLine1[ ++nX ].ImplAddColorError7( aErrQuad ); |
| pQLine2[ nX-- ].ImplAddColorError1( aErrQuad ); |
| pQLine2[ nX-- ].ImplAddColorError5( aErrQuad ); |
| pQLine2[ nX++ ].ImplAddColorError3( aErrQuad ); |
| pWriteAcc->SetPixel( nY, nX, aBestCol ); |
| } |
| |
| // letztes ZeilenPixel |
| aBestCol = pQLine1[ nWidth1 ].ImplGetColor(); |
| aBestCol.SetRed( ( aBestCol.GetRed() & 248 ) | 7 ); |
| aBestCol.SetGreen( ( aBestCol.GetGreen() & 248 ) | 7 ); |
| aBestCol.SetBlue( ( aBestCol.GetBlue() & 248 ) | 7 ); |
| pWriteAcc->SetPixel( nY, nX, aBestCol ); |
| |
| // Zeilenpuffer neu fuellen/kopieren |
| pQLine1 = pQLine2; |
| pQLine2 = ( bQ1 = !bQ1 ) != sal_False ? pErrQuad2 : pErrQuad1; |
| |
| if( nYTmp < nHeight ) |
| for( nX = 0L; nX < nWidth; nX++ ) |
| pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX ); |
| } |
| |
| // Zeilenpuffer zerstoeren |
| delete[] pErrQuad1; |
| delete[] pErrQuad2; |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pReadAcc ); |
| aNewBmp.ReleaseAccess( pWriteAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ReduceColors( sal_uInt16 nColorCount, BmpReduce eReduce ) |
| { |
| sal_Bool bRet; |
| |
| if( GetColorCount() <= (sal_uLong) nColorCount ) |
| bRet = sal_True; |
| else if( nColorCount ) |
| { |
| if( BMP_REDUCE_SIMPLE == eReduce ) |
| bRet = ImplReduceSimple( nColorCount ); |
| else if( BMP_REDUCE_POPULAR == eReduce ) |
| bRet = ImplReducePopular( nColorCount ); |
| else |
| bRet = ImplReduceMedian( nColorCount ); |
| } |
| else |
| bRet = sal_False; |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplReduceSimple( sal_uInt16 nColorCount ) |
| { |
| Bitmap aNewBmp; |
| BitmapReadAccess* pRAcc = AcquireReadAccess(); |
| const sal_uInt16 nColCount = Min( nColorCount, (sal_uInt16) 256 ); |
| sal_uInt16 nBitCount; |
| sal_Bool bRet = sal_False; |
| |
| if( nColCount <= 2 ) |
| nBitCount = 1; |
| else if( nColCount <= 16 ) |
| nBitCount = 4; |
| else |
| nBitCount = 8; |
| |
| if( pRAcc ) |
| { |
| Octree aOct( *pRAcc, nColCount ); |
| const BitmapPalette& rPal = aOct.GetPalette(); |
| BitmapWriteAccess* pWAcc; |
| |
| aNewBmp = Bitmap( GetSizePixel(), nBitCount, &rPal ); |
| pWAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWAcc ) |
| { |
| const long nWidth = pRAcc->Width(); |
| const long nHeight = pRAcc->Height(); |
| |
| if( pRAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX =0L; nX < nWidth; nX++ ) |
| pWAcc->SetPixelIndex( nY, nX, static_cast<sal_uInt8>(aOct.GetBestPaletteIndex( pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ))) ); |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX =0L; nX < nWidth; nX++ ) |
| pWAcc->SetPixelIndex( nY, nX, static_cast<sal_uInt8>(aOct.GetBestPaletteIndex( pRAcc->GetPixel( nY, nX ) )) ); |
| } |
| |
| aNewBmp.ReleaseAccess( pWAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pRAcc ); |
| } |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| struct PopularColorCount |
| { |
| sal_uInt32 mnIndex; |
| sal_uInt32 mnCount; |
| }; |
| |
| // ------------------------------------------------------------------------ |
| |
| extern "C" int __LOADONCALLAPI ImplPopularCmpFnc( const void* p1, const void* p2 ) |
| { |
| int nRet; |
| |
| if( ( (PopularColorCount*) p1 )->mnCount < ( (PopularColorCount*) p2 )->mnCount ) |
| nRet = 1; |
| else if( ( (PopularColorCount*) p1 )->mnCount == ( (PopularColorCount*) p2 )->mnCount ) |
| nRet = 0; |
| else |
| nRet = -1; |
| |
| return nRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) |
| { |
| BitmapReadAccess* pRAcc = AcquireReadAccess(); |
| sal_uInt16 nBitCount; |
| sal_Bool bRet = sal_False; |
| |
| if( nColCount > 256 ) |
| nColCount = 256; |
| |
| if( nColCount < 17 ) |
| nBitCount = 4; |
| else |
| nBitCount = 8; |
| |
| if( pRAcc ) |
| { |
| const sal_uInt32 nValidBits = 4; |
| const sal_uInt32 nRightShiftBits = 8 - nValidBits; |
| const sal_uInt32 nLeftShiftBits1 = nValidBits; |
| const sal_uInt32 nLeftShiftBits2 = nValidBits << 1; |
| const sal_uInt32 nColorsPerComponent = 1 << nValidBits; |
| const sal_uInt32 nColorOffset = 256 / nColorsPerComponent; |
| const sal_uInt32 nTotalColors = nColorsPerComponent * nColorsPerComponent * nColorsPerComponent; |
| const long nWidth = pRAcc->Width(); |
| const long nHeight = pRAcc->Height(); |
| PopularColorCount* pCountTable = new PopularColorCount[ nTotalColors ]; |
| long nX, nY, nR, nG, nB, nIndex; |
| |
| rtl_zeroMemory( pCountTable, nTotalColors * sizeof( PopularColorCount ) ); |
| |
| for( nR = 0, nIndex = 0; nR < 256; nR += nColorOffset ) |
| { |
| for( nG = 0; nG < 256; nG += nColorOffset ) |
| { |
| for( nB = 0; nB < 256; nB += nColorOffset ) |
| { |
| pCountTable[ nIndex ].mnIndex = nIndex; |
| nIndex++; |
| } |
| } |
| } |
| |
| if( pRAcc->HasPalette() ) |
| { |
| for( nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ); |
| pCountTable[ ( ( ( (sal_uInt32) rCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | |
| ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | |
| ( ( (sal_uInt32) rCol.GetBlue() ) >> nRightShiftBits ) ].mnCount++; |
| } |
| } |
| } |
| else |
| { |
| for( nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aCol( pRAcc->GetPixel( nY, nX ) ); |
| pCountTable[ ( ( ( (sal_uInt32) aCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | |
| ( ( ( (sal_uInt32) aCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | |
| ( ( (sal_uInt32) aCol.GetBlue() ) >> nRightShiftBits ) ].mnCount++; |
| } |
| } |
| } |
| |
| BitmapPalette aNewPal( nColCount ); |
| |
| qsort( pCountTable, nTotalColors, sizeof( PopularColorCount ), ImplPopularCmpFnc ); |
| |
| for( sal_uInt16 n = 0; n < nColCount; n++ ) |
| { |
| const PopularColorCount& rPop = pCountTable[ n ]; |
| aNewPal[ n ] = BitmapColor( (sal_uInt8) ( ( rPop.mnIndex >> nLeftShiftBits2 ) << nRightShiftBits ), |
| (sal_uInt8) ( ( ( rPop.mnIndex >> nLeftShiftBits1 ) & ( nColorsPerComponent - 1 ) ) << nRightShiftBits ), |
| (sal_uInt8) ( ( rPop.mnIndex & ( nColorsPerComponent - 1 ) ) << nRightShiftBits ) ); |
| } |
| |
| Bitmap aNewBmp( GetSizePixel(), nBitCount, &aNewPal ); |
| BitmapWriteAccess* pWAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWAcc ) |
| { |
| BitmapColor aDstCol( (sal_uInt8) 0 ); |
| sal_uInt8* pIndexMap = new sal_uInt8[ nTotalColors ]; |
| |
| for( nR = 0, nIndex = 0; nR < 256; nR += nColorOffset ) |
| for( nG = 0; nG < 256; nG += nColorOffset ) |
| for( nB = 0; nB < 256; nB += nColorOffset ) |
| pIndexMap[ nIndex++ ] = (sal_uInt8) aNewPal.GetBestIndex( BitmapColor( (sal_uInt8) nR, (sal_uInt8) nG, (sal_uInt8) nB ) ); |
| |
| if( pRAcc->HasPalette() ) |
| { |
| for( nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ); |
| aDstCol.SetIndex( pIndexMap[ ( ( ( (sal_uInt32) rCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | |
| ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | |
| ( ( (sal_uInt32) rCol.GetBlue() ) >> nRightShiftBits ) ] ); |
| pWAcc->SetPixel( nY, nX, aDstCol ); |
| } |
| } |
| } |
| else |
| { |
| for( nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aCol( pRAcc->GetPixel( nY, nX ) ); |
| aDstCol.SetIndex( pIndexMap[ ( ( ( (sal_uInt32) aCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | |
| ( ( ( (sal_uInt32) aCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | |
| ( ( (sal_uInt32) aCol.GetBlue() ) >> nRightShiftBits ) ] ); |
| pWAcc->SetPixel( nY, nX, aDstCol ); |
| } |
| } |
| } |
| |
| delete[] pIndexMap; |
| aNewBmp.ReleaseAccess( pWAcc ); |
| bRet = sal_True; |
| } |
| |
| delete[] pCountTable; |
| ReleaseAccess( pRAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount ) |
| { |
| BitmapReadAccess* pRAcc = AcquireReadAccess(); |
| sal_uInt16 nBitCount; |
| sal_Bool bRet = sal_False; |
| |
| if( nColCount < 17 ) |
| nBitCount = 4; |
| else if( nColCount < 257 ) |
| nBitCount = 8; |
| else |
| { |
| DBG_ERROR( "Bitmap::ImplReduceMedian(): invalid color count!" ); |
| nBitCount = 8; |
| nColCount = 256; |
| } |
| |
| if( pRAcc ) |
| { |
| Bitmap aNewBmp( GetSizePixel(), nBitCount ); |
| BitmapWriteAccess* pWAcc = aNewBmp.AcquireWriteAccess(); |
| |
| if( pWAcc ) |
| { |
| const sal_uLong nSize = 32768UL * sizeof( sal_uLong ); |
| sal_uLong* pColBuf = (sal_uLong*) rtl_allocateMemory( nSize ); |
| const long nWidth = pWAcc->Width(); |
| const long nHeight = pWAcc->Height(); |
| long nIndex = 0L; |
| |
| memset( (HPBYTE) pColBuf, 0, nSize ); |
| |
| // create Buffer |
| if( pRAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ); |
| pColBuf[ RGB15( rCol.GetRed() >> 3, rCol.GetGreen() >> 3, rCol.GetBlue() >> 3 ) ]++; |
| } |
| } |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aCol( pRAcc->GetPixel( nY, nX ) ); |
| pColBuf[ RGB15( aCol.GetRed() >> 3, aCol.GetGreen() >> 3, aCol.GetBlue() >> 3 ) ]++; |
| } |
| } |
| } |
| |
| // create palette via median cut |
| BitmapPalette aPal( pWAcc->GetPaletteEntryCount() ); |
| ImplMedianCut( pColBuf, aPal, 0, 31, 0, 31, 0, 31, |
| nColCount, nWidth * nHeight, nIndex ); |
| |
| // do mapping of colors to palette |
| InverseColorMap aMap( aPal ); |
| pWAcc->SetPalette( aPal ); |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| pWAcc->SetPixelIndex( nY, nX, static_cast<sal_uInt8>( aMap.GetBestPaletteIndex( pRAcc->GetColor( nY, nX ) )) ); |
| |
| rtl_freeMemory( pColBuf ); |
| aNewBmp.ReleaseAccess( pWAcc ); |
| bRet = sal_True; |
| } |
| |
| ReleaseAccess( pRAcc ); |
| |
| if( bRet ) |
| { |
| const MapMode aMap( maPrefMapMode ); |
| const Size aSize( maPrefSize ); |
| |
| *this = aNewBmp; |
| maPrefMapMode = aMap; |
| maPrefSize = aSize; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void Bitmap::ImplMedianCut( sal_uLong* pColBuf, BitmapPalette& rPal, |
| long nR1, long nR2, long nG1, long nG2, long nB1, long nB2, |
| long nColors, long nPixels, long& rIndex ) |
| { |
| if( !nPixels ) |
| return; |
| |
| BitmapColor aCol; |
| const long nRLen = nR2 - nR1; |
| const long nGLen = nG2 - nG1; |
| const long nBLen = nB2 - nB1; |
| long nR, nG, nB; |
| sal_uLong* pBuf = pColBuf; |
| |
| if( !nRLen && !nGLen && !nBLen ) |
| { |
| if( pBuf[ RGB15( nR1, nG1, nB1 ) ] ) |
| { |
| aCol.SetRed( (sal_uInt8) ( nR1 << 3 ) ); |
| aCol.SetGreen( (sal_uInt8) ( nG1 << 3 ) ); |
| aCol.SetBlue( (sal_uInt8) ( nB1 << 3 ) ); |
| rPal[ (sal_uInt16) rIndex++ ] = aCol; |
| } |
| } |
| else |
| { |
| if( 1 == nColors || 1 == nPixels ) |
| { |
| long nPixSum = 0, nRSum = 0, nGSum = 0, nBSum = 0; |
| |
| for( nR = nR1; nR <= nR2; nR++ ) |
| { |
| for( nG = nG1; nG <= nG2; nG++ ) |
| { |
| for( nB = nB1; nB <= nB2; nB++ ) |
| { |
| nPixSum = pBuf[ RGB15( nR, nG, nB ) ]; |
| |
| if( nPixSum ) |
| { |
| nRSum += nR * nPixSum; |
| nGSum += nG * nPixSum; |
| nBSum += nB * nPixSum; |
| } |
| } |
| } |
| } |
| |
| aCol.SetRed( (sal_uInt8) ( ( nRSum / nPixels ) << 3 ) ); |
| aCol.SetGreen( (sal_uInt8) ( ( nGSum / nPixels ) << 3 ) ); |
| aCol.SetBlue( (sal_uInt8) ( ( nBSum / nPixels ) << 3 ) ); |
| rPal[ (sal_uInt16) rIndex++ ] = aCol; |
| } |
| else |
| { |
| const long nTest = ( nPixels >> 1 ); |
| long nPixOld = 0; |
| long nPixNew = 0; |
| |
| if( nBLen > nGLen && nBLen > nRLen ) |
| { |
| nB = nB1 - 1; |
| |
| while( nPixNew < nTest ) |
| { |
| nB++, nPixOld = nPixNew; |
| for( nR = nR1; nR <= nR2; nR++ ) |
| for( nG = nG1; nG <= nG2; nG++ ) |
| nPixNew += pBuf[ RGB15( nR, nG, nB ) ]; |
| } |
| |
| if( nB < nB2 ) |
| { |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG1, nG2, nB1, nB, nColors >> 1, nPixNew, rIndex ); |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG1, nG2, nB + 1, nB2, nColors >> 1, nPixels - nPixNew, rIndex ); |
| } |
| else |
| { |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG1, nG2, nB1, nB - 1, nColors >> 1, nPixOld, rIndex ); |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG1, nG2, nB, nB2, nColors >> 1, nPixels - nPixOld, rIndex ); |
| } |
| } |
| else if( nGLen > nRLen ) |
| { |
| nG = nG1 - 1; |
| |
| while( nPixNew < nTest ) |
| { |
| nG++, nPixOld = nPixNew; |
| for( nR = nR1; nR <= nR2; nR++ ) |
| for( nB = nB1; nB <= nB2; nB++ ) |
| nPixNew += pBuf[ RGB15( nR, nG, nB ) ]; |
| } |
| |
| if( nG < nG2 ) |
| { |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG1, nG, nB1, nB2, nColors >> 1, nPixNew, rIndex ); |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG + 1, nG2, nB1, nB2, nColors >> 1, nPixels - nPixNew, rIndex ); |
| } |
| else |
| { |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG1, nG - 1, nB1, nB2, nColors >> 1, nPixOld, rIndex ); |
| ImplMedianCut( pBuf, rPal, nR1, nR2, nG, nG2, nB1, nB2, nColors >> 1, nPixels - nPixOld, rIndex ); |
| } |
| } |
| else |
| { |
| nR = nR1 - 1; |
| |
| while( nPixNew < nTest ) |
| { |
| nR++, nPixOld = nPixNew; |
| for( nG = nG1; nG <= nG2; nG++ ) |
| for( nB = nB1; nB <= nB2; nB++ ) |
| nPixNew += pBuf[ RGB15( nR, nG, nB ) ]; |
| } |
| |
| if( nR < nR2 ) |
| { |
| ImplMedianCut( pBuf, rPal, nR1, nR, nG1, nG2, nB1, nB2, nColors >> 1, nPixNew, rIndex ); |
| ImplMedianCut( pBuf, rPal, nR1 + 1, nR2, nG1, nG2, nB1, nB2, nColors >> 1, nPixels - nPixNew, rIndex ); |
| } |
| else |
| { |
| ImplMedianCut( pBuf, rPal, nR1, nR - 1, nG1, nG2, nB1, nB2, nColors >> 1, nPixOld, rIndex ); |
| ImplMedianCut( pBuf, rPal, nR, nR2, nG1, nG2, nB1, nB2, nColors >> 1, nPixels - nPixOld, rIndex ); |
| } |
| } |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::Vectorize( PolyPolygon& rPolyPoly, sal_uLong nFlags, const Link* pProgress ) |
| { |
| return ImplVectorizer().ImplVectorize( *this, rPolyPoly, nFlags, pProgress ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::Vectorize( GDIMetaFile& rMtf, sal_uInt8 cReduce, sal_uLong nFlags, const Link* pProgress ) |
| { |
| return ImplVectorizer().ImplVectorize( *this, rMtf, cReduce, nFlags, pProgress ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent, |
| short nChannelRPercent, short nChannelGPercent, short nChannelBPercent, |
| double fGamma, sal_Bool bInvert ) |
| { |
| sal_Bool bRet = sal_False; |
| |
| // nothing to do => return quickly |
| if( !nLuminancePercent && !nContrastPercent && |
| !nChannelRPercent && !nChannelGPercent && !nChannelBPercent && |
| ( fGamma == 1.0 ) && !bInvert ) |
| { |
| bRet = sal_True; |
| } |
| else |
| { |
| BitmapWriteAccess* pAcc = AcquireWriteAccess(); |
| |
| if( pAcc ) |
| { |
| BitmapColor aCol; |
| const long nW = pAcc->Width(); |
| const long nH = pAcc->Height(); |
| sal_uInt8* cMapR = new sal_uInt8[ 256 ]; |
| sal_uInt8* cMapG = new sal_uInt8[ 256 ]; |
| sal_uInt8* cMapB = new sal_uInt8[ 256 ]; |
| long nX, nY; |
| double fM, fROff, fGOff, fBOff, fOff; |
| |
| // calculate slope |
| if( nContrastPercent >= 0 ) |
| fM = 128.0 / ( 128.0 - 1.27 * MinMax( nContrastPercent, 0L, 100L ) ); |
| else |
| fM = ( 128.0 + 1.27 * MinMax( nContrastPercent, -100L, 0L ) ) / 128.0; |
| |
| // total offset = luminance offset + contrast offset |
| fOff = MinMax( nLuminancePercent, -100L, 100L ) * 2.55 + 128.0 - fM * 128.0; |
| |
| // channel offset = channel offset + total offset |
| fROff = nChannelRPercent * 2.55 + fOff; |
| fGOff = nChannelGPercent * 2.55 + fOff; |
| fBOff = nChannelBPercent * 2.55 + fOff; |
| |
| // calculate gamma value |
| fGamma = ( fGamma <= 0.0 || fGamma > 10.0 ) ? 1.0 : ( 1.0 / fGamma ); |
| const sal_Bool bGamma = ( fGamma != 1.0 ); |
| |
| // create mapping table |
| for( nX = 0L; nX < 256L; nX++ ) |
| { |
| cMapR[ nX ] = (sal_uInt8) MinMax( FRound( nX * fM + fROff ), 0L, 255L ); |
| cMapG[ nX ] = (sal_uInt8) MinMax( FRound( nX * fM + fGOff ), 0L, 255L ); |
| cMapB[ nX ] = (sal_uInt8) MinMax( FRound( nX * fM + fBOff ), 0L, 255L ); |
| |
| if( bGamma ) |
| { |
| cMapR[ nX ] = GAMMA( cMapR[ nX ], fGamma ); |
| cMapG[ nX ] = GAMMA( cMapG[ nX ], fGamma ); |
| cMapB[ nX ] = GAMMA( cMapB[ nX ], fGamma ); |
| } |
| |
| if( bInvert ) |
| { |
| cMapR[ nX ] = ~cMapR[ nX ]; |
| cMapG[ nX ] = ~cMapG[ nX ]; |
| cMapB[ nX ] = ~cMapB[ nX ]; |
| } |
| } |
| |
| // do modifying |
| if( pAcc->HasPalette() ) |
| { |
| BitmapColor aNewCol; |
| |
| for( sal_uInt16 i = 0, nCount = pAcc->GetPaletteEntryCount(); i < nCount; i++ ) |
| { |
| const BitmapColor& rCol = pAcc->GetPaletteColor( i ); |
| aNewCol.SetRed( cMapR[ rCol.GetRed() ] ); |
| aNewCol.SetGreen( cMapG[ rCol.GetGreen() ] ); |
| aNewCol.SetBlue( cMapB[ rCol.GetBlue() ] ); |
| pAcc->SetPaletteColor( i, aNewCol ); |
| } |
| } |
| else if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_BGR ) |
| { |
| for( nY = 0L; nY < nH; nY++ ) |
| { |
| Scanline pScan = pAcc->GetScanline( nY ); |
| |
| for( nX = 0L; nX < nW; nX++ ) |
| { |
| *pScan = cMapB[ *pScan ]; pScan++; |
| *pScan = cMapG[ *pScan ]; pScan++; |
| *pScan = cMapR[ *pScan ]; pScan++; |
| } |
| } |
| } |
| else if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_RGB ) |
| { |
| for( nY = 0L; nY < nH; nY++ ) |
| { |
| Scanline pScan = pAcc->GetScanline( nY ); |
| |
| for( nX = 0L; nX < nW; nX++ ) |
| { |
| *pScan = cMapR[ *pScan ]; pScan++; |
| *pScan = cMapG[ *pScan ]; pScan++; |
| *pScan = cMapB[ *pScan ]; pScan++; |
| } |
| } |
| } |
| else |
| { |
| for( nY = 0L; nY < nH; nY++ ) |
| { |
| for( nX = 0L; nX < nW; nX++ ) |
| { |
| aCol = pAcc->GetPixel( nY, nX ); |
| aCol.SetRed( cMapR[ aCol.GetRed() ] ); |
| aCol.SetGreen( cMapG[ aCol.GetGreen() ] ); |
| aCol.SetBlue( cMapB[ aCol.GetBlue() ] ); |
| pAcc->SetPixel( nY, nX, aCol ); |
| } |
| } |
| } |
| |
| delete[] cMapR; |
| delete[] cMapG; |
| delete[] cMapB; |
| ReleaseAccess( pAcc ); |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |