f7d373d18f
(cherry picked from commit 4be8cc079667cca2cae91dba9e46c16ccff1537f) Conflicts: vcl/source/gdi/bitmap3.cxx Change-Id: I329ebc63df0dd96d4a2596ad42ff1aa14405bdd4
3423 lines
131 KiB
C++
3423 lines
131 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* 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 .
|
|
*/
|
|
|
|
|
|
#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>
|
|
#include <math.h>
|
|
|
|
#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];
|
|
|
|
const extern sal_uLong nVCLRLut[ 6 ] = { 16, 17, 18, 19, 20, 21 };
|
|
const extern sal_uLong nVCLGLut[ 6 ] = { 0, 6, 12, 18, 24, 30 };
|
|
const extern sal_uLong nVCLBLut[ 6 ] = { 0, 36, 72, 108, 144, 180 };
|
|
|
|
const extern 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
|
|
};
|
|
|
|
const extern 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
|
|
};
|
|
|
|
const 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
|
|
};
|
|
|
|
const 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
|
|
};
|
|
|
|
const 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
|
|
};
|
|
|
|
const 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
|
|
};
|
|
|
|
const 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
|
|
};
|
|
|
|
const long FloydIndexMap[6] =
|
|
{
|
|
-30, 21, 72, 123, 174, 225
|
|
};
|
|
|
|
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 } };
|
|
|
|
// Build MagicSquare
|
|
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 = std::max ( pMtx[ (k<<2) + i][(l<<2 ) + j] =
|
|
(sal_uInt16) ( 0.5 + pMagic[i][j]*fVal + pMagic[k][l]*fVal16 ), nMax );
|
|
|
|
// Scale to interval [0;254]
|
|
for ( i = 0, fVal = 254. / nMax; i < 16; i++ )
|
|
for( j = 0; j < 16; j++ )
|
|
(*pDitherMatrix)[i][j] = (sal_uInt8) ( fVal * pMtx[i][j] );
|
|
}
|
|
|
|
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:
|
|
OSL_FAIL( "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 );
|
|
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;
|
|
bool bQ1 = 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 < std::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 );
|
|
}
|
|
|
|
// Last RowPixel
|
|
if( nX < nWidth )
|
|
{
|
|
cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ nWidth1 ].ImplGetColor() );
|
|
pWriteAcc->SetPixelIndex( nY, nX, cIndex );
|
|
}
|
|
|
|
// Refill/copy row buffer
|
|
pQLine1 = pQLine2;
|
|
pQLine2 = ( bQ1 = !bQ1 ) ? 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 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Delete row buffer
|
|
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 )
|
|
{
|
|
bool bRetval(false);
|
|
|
|
#ifdef DBG_UTIL
|
|
const sal_uInt16 nStartCount(GetBitCount());
|
|
#endif
|
|
|
|
if(basegfx::fTools::equalZero(rScaleX) || basegfx::fTools::equalZero(rScaleY))
|
|
{
|
|
// no scale
|
|
bRetval = true;
|
|
}
|
|
|
|
if(basegfx::fTools::equal(rScaleX, 1.0) && basegfx::fTools::equal(rScaleY, 1.0))
|
|
{
|
|
// no scale
|
|
bRetval = true;
|
|
}
|
|
|
|
switch(nScaleFlag)
|
|
{
|
|
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
|
|
{
|
|
// #i121233# 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() );
|
|
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)
|
|
{
|
|
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 ];
|
|
|
|
if( nNewWidth1 && nNewHeight1 )
|
|
{
|
|
long nX, nY, nMapY, nActY = 0L;
|
|
|
|
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;
|
|
aNewBmp.ReleaseAccess( pWriteAcc );
|
|
}
|
|
|
|
delete[] pLutX;
|
|
delete[] pLutY;
|
|
}
|
|
ReleaseAccess( pReadAcc );
|
|
|
|
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;
|
|
}
|
|
|
|
// #i121233# 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;
|
|
}
|
|
}
|
|
|
|
// #i121233# Added BMP_SCALE_LANCZOS, BMP_SCALE_BICUBIC, BMP_SCALE_BILINEAR and
|
|
// BMP_SCALE_BOX derived from the original commit from Tomas 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 aInterm;
|
|
if(nInBetweenSizeHorFirst < nInBetweenSizeVerFirst)
|
|
{
|
|
if(bScaleHor)
|
|
{
|
|
bResult = ImplScaleConvolutionHor(*this, aInterm, fScaleX, aKernel);
|
|
}
|
|
else
|
|
aInterm = *this;
|
|
|
|
if(bResult && bScaleVer)
|
|
{
|
|
bResult = ImplScaleConvolutionVer(aInterm, aResult, fScaleY, aKernel);
|
|
}
|
|
else
|
|
aResult = aInterm;
|
|
}
|
|
else
|
|
{
|
|
if(bScaleVer)
|
|
{
|
|
bResult = ImplScaleConvolutionVer(*this, aInterm, fScaleY, aKernel);
|
|
}
|
|
else
|
|
aInterm = *this;
|
|
|
|
if(bResult && bScaleHor)
|
|
{
|
|
bResult = ImplScaleConvolutionHor(aInterm, aResult, fScaleX, aKernel);
|
|
}
|
|
else
|
|
aResult = aInterm;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Examine first Pixel separately
|
|
nX = 0;
|
|
CALC_ERRORS;
|
|
CALC_TABLES7;
|
|
nX -= 5;
|
|
CALC_TABLES5;
|
|
pWriteAcc->SetPixelIndex( nYAcc, 0, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) );
|
|
|
|
// Get middle Pixels using a loop
|
|
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 ]) );
|
|
}
|
|
|
|
// Treat last Pixel separately
|
|
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;
|
|
bool bQ1 = true;
|
|
|
|
for( nY = 0L; nY < std::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++ )
|
|
{
|
|
// First RowPixel
|
|
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 );
|
|
}
|
|
|
|
// Last RowPixel
|
|
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 );
|
|
|
|
// Refill/copy row buffer
|
|
pQLine1 = pQLine2;
|
|
pQLine2 = ( bQ1 = !bQ1 ) ? pErrQuad2 : pErrQuad1;
|
|
|
|
if( nYTmp < nHeight )
|
|
for( nX = 0L; nX < nWidth; nX++ )
|
|
pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX );
|
|
}
|
|
|
|
// Destroy row buffer
|
|
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 = std::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 SAL_CALL 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;
|
|
|
|
memset( pCountTable, 0, 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
|
|
{
|
|
OSL_FAIL( "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;
|
|
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( long nR = nR1; nR <= nR2; nR++ )
|
|
{
|
|
for( long nG = nG1; nG <= nG2; nG++ )
|
|
{
|
|
for( long 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 )
|
|
{
|
|
long nB = nB1 - 1;
|
|
|
|
while( nPixNew < nTest )
|
|
{
|
|
nB++, nPixOld = nPixNew;
|
|
for( long nR = nR1; nR <= nR2; nR++ )
|
|
for( long 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 )
|
|
{
|
|
long nG = nG1 - 1;
|
|
|
|
while( nPixNew < nTest )
|
|
{
|
|
nG++, nPixOld = nPixNew;
|
|
for( long nR = nR1; nR <= nR2; nR++ )
|
|
for( long 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
|
|
{
|
|
long nR = nR1 - 1;
|
|
|
|
while( nPixNew < nTest )
|
|
{
|
|
nR++, nPixOld = nPixNew;
|
|
for( long nG = nG1; nG <= nG2; nG++ )
|
|
for( long 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 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;
|
|
}
|
|
|
|
bool Bitmap::ImplConvolutionPass(Bitmap& aNewBitmap, const int nNewSize, BitmapReadAccess* pReadAcc, int aNumberOfContributions, double* pWeights, int* pPixels, int* pCount)
|
|
{
|
|
BitmapWriteAccess* pWriteAcc = aNewBitmap.AcquireWriteAccess();
|
|
|
|
if (!pReadAcc || !pWriteAcc)
|
|
return false;
|
|
|
|
const int nHeight = GetSizePixel().Height();
|
|
|
|
BitmapColor aColor;
|
|
double aValueRed, aValueGreen, aValueBlue;
|
|
double aSum, aWeight;
|
|
int aBaseIndex, aIndex;
|
|
|
|
for ( int y = 0; y < nHeight; y++ )
|
|
{
|
|
for ( int x = 0; x < nNewSize; x++ )
|
|
{
|
|
aBaseIndex = x * aNumberOfContributions;
|
|
aSum = aValueRed = aValueGreen = aValueBlue = 0.0;
|
|
|
|
for ( int j=0; j < pCount[x]; j++ )
|
|
{
|
|
aIndex = aBaseIndex + j;
|
|
aSum += aWeight = pWeights[ aIndex ];
|
|
|
|
aColor = pReadAcc->GetColor( y, pPixels[ aIndex ] );
|
|
|
|
aValueRed += aWeight * aColor.GetRed();
|
|
aValueGreen += aWeight * aColor.GetGreen();
|
|
aValueBlue += aWeight * aColor.GetBlue();
|
|
}
|
|
|
|
BitmapColor aResultColor(
|
|
(sal_uInt8) MinMax( aValueRed / aSum, 0, 255 ),
|
|
(sal_uInt8) MinMax( aValueGreen / aSum, 0, 255 ),
|
|
(sal_uInt8) MinMax( aValueBlue / aSum, 0, 255 ) );
|
|
pWriteAcc->SetPixel( x, y, aResultColor );
|
|
}
|
|
}
|
|
aNewBitmap.ReleaseAccess( pWriteAcc );
|
|
return true;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|