Skip to content

C
core
Kaydet (Commit) 9536e3cb authored tarafından Armin Le Grand's avatar Armin Le Grand Kaydeden (comit) Caolán McNamara
Dosyalara gözat
Seçenekler

Resolves: #i121233# some slight corrections/enhancements 

(cherry picked from commit db00dfd9)

Conflicts:
	vcl/inc/vcl/bitmap.hxx
	vcl/source/gdi/bitmap3.cxx

Change-Id: I1a7817a94232b3d7f1c095dd27025e4cccea348c
üst a8551357
Show whitespace changes
Inline Side-by-side
Showing with 58 additions and 189 deletions
drawinglayer/source/processor2d/vclhelperbitmaptransform.cxx
Dosyayı görüntüle @ 9536e3cb
...@@ -110,78 +110,14 @@ namespace drawinglayer ...@@ -110,78 +110,14 @@ namespace drawinglayer
} }
} }
void impSmoothIndex(BitmapColor& rValue, const basegfx::B2DPoint& rSource, sal_Int32 nIntX, sal_Int32 nIntY, BitmapReadAccess& rRead) Bitmap impTransformBitmap(
const Bitmap& rSource,
const Size aDestinationSize,
const basegfx::B2DHomMatrix& rTransform,
bool bSmooth)
{ {
double fDeltaX(rSource.getX() - nIntX); Bitmap aDestination(aDestinationSize, 24);
double fDeltaY(rSource.getY() - nIntY); BitmapWriteAccess* pWrite = aDestination.AcquireWriteAccess();
sal_Int32 nIndX(0L);
sal_Int32 nIndY(0L);
if(fDeltaX > 0.0 && nIntX + 1L < rRead.Width())
{
nIndX++;
}
else if(fDeltaX < 0.0 && nIntX >= 1L)
{
fDeltaX = -fDeltaX;
nIndX--;
}
if(fDeltaY > 0.0 && nIntY + 1L < rRead.Height())
{
nIndY++;
}
else if(fDeltaY < 0.0 && nIntY >= 1L)
{
fDeltaY = -fDeltaY;
nIndY--;
}
if(nIndX || nIndY)
{
const double fColorToReal(1.0 / 255.0);
double fVal(rValue.GetIndex() * fColorToReal);
double fValBottom(0.0);
if(nIndX)
{
const double fMulA(fDeltaX * fColorToReal);
double fMulB(1.0 - fDeltaX);
const BitmapColor aTopPartner(rRead.GetPixel(nIntY, nIntX + nIndX));
fVal = (fVal * fMulB) + (aTopPartner.GetIndex() * fMulA);
if(nIndY)
{
fMulB *= fColorToReal;
const BitmapColor aBottom(rRead.GetPixel(nIntY + nIndY, nIntX));
const BitmapColor aBottomPartner(rRead.GetPixel(nIntY + nIndY, nIntX + nIndX));
fValBottom = (aBottom.GetIndex() * fMulB) + (aBottomPartner.GetIndex() * fMulA);
}
}
if(nIndY)
{
if(!nIndX)
{
const BitmapColor aBottom(rRead.GetPixel(nIntY + nIndY, nIntX));
fValBottom = aBottom.GetIndex() * fColorToReal;
}
const double fMulB(1.0 - fDeltaY);
fVal = (fVal * fMulB) + (fValBottom * fDeltaY);
}
rValue.SetIndex((sal_uInt8)(fVal * 255.0));
}
}
void impTransformBitmap(const Bitmap& rSource, Bitmap& rDestination, const basegfx::B2DHomMatrix& rTransform, bool bSmooth)
{
BitmapWriteAccess* pWrite = rDestination.AcquireWriteAccess();
if(pWrite) if(pWrite)
{ {
...@@ -190,9 +126,9 @@ namespace drawinglayer ...@@ -190,9 +126,9 @@ namespace drawinglayer
if(pRead) if(pRead)
{ {
const Size aDestinationSizePixel(rDestination.GetSizePixel()); const Size aDestinationSizePixel(aDestination.GetSizePixel());
bool bWorkWithIndex(rDestination.GetBitCount() <= 8); bool bWorkWithIndex(rSource.GetBitCount() <= 8);
BitmapColor aOutside(pRead->GetBestMatchingColor(BitmapColor(0xff, 0xff, 0xff))); BitmapColor aOutside(BitmapColor(0xff, 0xff, 0xff));
for(sal_Int32 y(0L); y < aDestinationSizePixel.getHeight(); y++) for(sal_Int32 y(0L); y < aDestinationSizePixel.getHeight(); y++)
{ {
...@@ -207,29 +143,24 @@ namespace drawinglayer ...@@ -207,29 +143,24 @@ namespace drawinglayer
if(nIntY >= 0L && nIntY < aContentSizePixel.getHeight()) if(nIntY >= 0L && nIntY < aContentSizePixel.getHeight())
{ {
if(bWorkWithIndex) // inside pixel
{ BitmapColor aValue;
BitmapColor aValue(pRead->GetPixel(nIntY, nIntX));
if(bSmooth) if(bWorkWithIndex)
{ {
impSmoothIndex(aValue, aSourceCoor, nIntX, nIntY, *pRead); aValue = pRead->GetPaletteColor(pRead->GetPixelIndex(nIntY, nIntX));
}
pWrite->SetPixel(y, x, aValue);
} }
else else
{ {
BitmapColor aValue(pRead->GetColor(nIntY, nIntX)); aValue = pRead->GetPixel(nIntY, nIntX);
}
if(bSmooth) if(bSmooth)
{ {
impSmoothPoint(aValue, aSourceCoor, nIntX, nIntY, *pRead); impSmoothPoint(aValue, aSourceCoor, nIntX, nIntY, *pRead);
} }
pWrite->SetPixel(y, x, aValue.IsIndex() ? aValue : pWrite->GetBestMatchingColor(aValue)); pWrite->SetPixel(y, x, aValue);
}
continue; continue;
} }
} }
...@@ -247,29 +178,10 @@ namespace drawinglayer ...@@ -247,29 +178,10 @@ namespace drawinglayer
delete pWrite; delete pWrite;
} }
}
Bitmap impCreateEmptyBitmapWithPattern(const Bitmap& rSource, const Size& aTargetSizePixel)
{
Bitmap aRetval;
BitmapReadAccess* pReadAccess = (const_cast< Bitmap& >(rSource)).AcquireReadAccess();
if(pReadAccess)
{
if(rSource.GetBitCount() <= 8)
{
BitmapPalette aPalette(pReadAccess->GetPalette());
aRetval = Bitmap(aTargetSizePixel, rSource.GetBitCount(), &aPalette);
}
else
{
aRetval = Bitmap(aTargetSizePixel, rSource.GetBitCount());
}
delete pReadAccess; rSource.AdaptBitCount(aDestination);
}
return aRetval; return aDestination;
} }
} // end of anonymous namespace } // end of anonymous namespace
} // end of namespace drawinglayer } // end of namespace drawinglayer
...@@ -283,23 +195,20 @@ namespace drawinglayer ...@@ -283,23 +195,20 @@ namespace drawinglayer
{ {
// force destination to 24 bit, we want to smooth output // force destination to 24 bit, we want to smooth output
const Size aDestinationSize(rCroppedRectPixel.GetSize()); const Size aDestinationSize(rCroppedRectPixel.GetSize());
Bitmap aDestination(impCreateEmptyBitmapWithPattern(rSource.GetBitmap(), aDestinationSize));
static bool bDoSmoothAtAll(true); static bool bDoSmoothAtAll(true);
impTransformBitmap(rSource.GetBitmap(), aDestination, rTransform, bDoSmoothAtAll); const Bitmap aDestination(impTransformBitmap(rSource.GetBitmap(), aDestinationSize, rTransform, bDoSmoothAtAll));
// create mask // create mask
if(rSource.IsTransparent()) if(rSource.IsTransparent())
{ {
if(rSource.IsAlpha()) if(rSource.IsAlpha())
{ {
Bitmap aAlpha(impCreateEmptyBitmapWithPattern(rSource.GetAlpha().GetBitmap(), aDestinationSize)); const Bitmap aAlpha(impTransformBitmap(rSource.GetAlpha().GetBitmap(), aDestinationSize, rTransform, bDoSmoothAtAll));
impTransformBitmap(rSource.GetAlpha().GetBitmap(), aAlpha, rTransform, bDoSmoothAtAll);
return BitmapEx(aDestination, AlphaMask(aAlpha)); return BitmapEx(aDestination, AlphaMask(aAlpha));
} }
else else
{ {
Bitmap aMask(impCreateEmptyBitmapWithPattern(rSource.GetMask(), aDestinationSize)); const Bitmap aMask(impTransformBitmap(rSource.GetMask(), aDestinationSize, rTransform, false));
impTransformBitmap(rSource.GetMask(), aMask, rTransform, false);
return BitmapEx(aDestination, aMask); return BitmapEx(aDestination, aMask);
} }
} }
......
include/vcl/bitmap.hxx
Dosyayı görüntüle @ 9536e3cb
...@@ -342,7 +342,7 @@ public: ...@@ -342,7 +342,7 @@ public:
BitmapWriteAccess& rAcc, sal_Bool bRLE4 ); BitmapWriteAccess& rAcc, sal_Bool bRLE4 );
SAL_DLLPRIVATE static sal_Bool ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool bRLE4 ); SAL_DLLPRIVATE static sal_Bool ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool bRLE4 );
SAL_DLLPRIVATE void ImplAdaptBitCount(Bitmap& rNew); SAL_DLLPRIVATE void ImplAdaptBitCount(Bitmap& rNew) const;
SAL_DLLPRIVATE sal_Bool ImplScaleFast( const double& rScaleX, const double& rScaleY ); SAL_DLLPRIVATE sal_Bool ImplScaleFast( const double& rScaleX, const double& rScaleY );
SAL_DLLPRIVATE sal_Bool ImplScaleInterpolate( const double& rScaleX, const double& rScaleY ); SAL_DLLPRIVATE sal_Bool ImplScaleInterpolate( const double& rScaleX, const double& rScaleY );
SAL_DLLPRIVATE sal_Bool ImplScaleSuper( const double& rScaleX, const double& rScaleY ); SAL_DLLPRIVATE sal_Bool ImplScaleSuper( const double& rScaleX, const double& rScaleY );
...@@ -616,6 +616,10 @@ public: ...@@ -616,6 +616,10 @@ public:
*/ */
sal_Bool Scale( const double& rScaleX, const double& rScaleY, sal_uInt32 nScaleFlag = BMP_SCALE_DEFAULT ); sal_Bool Scale( const double& rScaleX, const double& rScaleY, sal_uInt32 nScaleFlag = BMP_SCALE_DEFAULT );
// Adapt the BitCount of rNew to BitCount of lolal, including grey or color paltette
// Can be used to create alpha/mask bitmaps after their processing in 24bit
void AdaptBitCount(Bitmap& rNew) const;
/** Rotate bitmap by the specified angle /** Rotate bitmap by the specified angle
@param nAngle10 @param nAngle10
......
vcl/source/gdi/bitmap3.cxx
Dosyayı görüntüle @ 9536e3cb
...@@ -950,7 +950,16 @@ sal_Bool Bitmap::Scale( const Size& rNewSize, sal_uInt32 nScaleFlag ) ...@@ -950,7 +950,16 @@ sal_Bool Bitmap::Scale( const Size& rNewSize, sal_uInt32 nScaleFlag )
return bRet; return bRet;
} }
void Bitmap::ImplAdaptBitCount(Bitmap& rNew) // ------------------------------------------------------------------------
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) // aNew is the result of some operation; adapt it's BitCount to the original (this)
if(GetBitCount() != rNew.GetBitCount()) if(GetBitCount() != rNew.GetBitCount())
...@@ -1109,60 +1118,40 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1109,60 +1118,40 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
pLutFrac[ nX ] = (long) ( fTemp * 1024. ); pLutFrac[ nX ] = (long) ( fTemp * 1024. );
} }
if( pReadAcc->HasPalette() )
{
for( nY = 0L; nY < nHeight; nY++ ) for( nY = 0L; nY < nHeight; nY++ )
{ {
if( 1 == nWidth ) if( 1 == nWidth )
{
if( pReadAcc->HasPalette() )
{ {
aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, 0 ) ); aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, 0 ) );
for( nX = 0L; nX < nNewWidth; nX++ )
pWriteAcc->SetPixel( nY, nX, aCol0 );
} }
else else
{ {
aCol0 = pReadAcc->GetPixel( nY, 0 );
}
for( nX = 0L; nX < nNewWidth; nX++ ) for( nX = 0L; nX < nNewWidth; nX++ )
{ {
nTemp = pLutInt[ nX ];
aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp++ ) );
aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( 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 ); pWriteAcc->SetPixel( nY, nX, aCol0 );
} }
} }
}
}
else else
{ {
for( nY = 0L; nY < nHeight; nY++ ) for( nX = 0L; nX < nNewWidth; nX++ )
{
if( 1 == nWidth )
{ {
aCol0 = pReadAcc->GetPixel( nY, 0 ); nTemp = pLutInt[ nX ];
for( nX = 0L; nX < nNewWidth; nX++ ) if( pReadAcc->HasPalette() )
pWriteAcc->SetPixel( nY, nX, aCol0 ); {
aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp++ ) );
aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp ) );
} }
else else
{ {
for( nX = 0L; nX < nNewWidth; nX++ )
{
nTemp = pLutInt[ nX ];
aCol0 = pReadAcc->GetPixel( nY, nTemp++ ); aCol0 = pReadAcc->GetPixel( nY, nTemp++ );
aCol1 = pReadAcc->GetPixel( nY, nTemp ); aCol1 = pReadAcc->GetPixel( nY, nTemp );
}
nTemp = pLutFrac[ nX ]; nTemp = pLutFrac[ nX ];
...@@ -1178,7 +1167,6 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1178,7 +1167,6 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
} }
} }
} }
}
delete[] pLutInt; delete[] pLutInt;
delete[] pLutFrac; delete[] pLutFrac;
...@@ -1191,10 +1179,9 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1191,10 +1179,9 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
if( bRet ) if( bRet )
{ {
bRet = sal_False; bRet = sal_False;
ImplAdaptBitCount(aNewBmp); *this = aNewBmp;
ImplAssignWithSize( aNewBmp );
pReadAcc = AcquireReadAccess();
aNewBmp = Bitmap( Size( nNewWidth, nNewHeight ), 24 ); aNewBmp = Bitmap( Size( nNewWidth, nNewHeight ), 24 );
pReadAcc = AcquireReadAccess();
pWriteAcc = aNewBmp.AcquireWriteAccess(); pWriteAcc = aNewBmp.AcquireWriteAccess();
if( pReadAcc && pWriteAcc ) if( pReadAcc && pWriteAcc )
...@@ -1214,43 +1201,9 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1214,43 +1201,9 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
pLutFrac[ nY ] = (long) ( fTemp * 1024. ); pLutFrac[ nY ] = (long) ( fTemp * 1024. );
} }
if( pReadAcc->HasPalette() ) // 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->GetPaletteColor( pReadAcc->GetPixelIndex( 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->GetPaletteColor( pReadAcc->GetPixelIndex( nTemp++, nX ) );
aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( 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 );
}
}
}
}
else
{
for( nX = 0L; nX < nNewWidth; nX++ ) for( nX = 0L; nX < nNewWidth; nX++ )
{ {
if( 1 == nHeight ) if( 1 == nHeight )
...@@ -1258,8 +1211,10 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1258,8 +1211,10 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
aCol0 = pReadAcc->GetPixel( 0, nX ); aCol0 = pReadAcc->GetPixel( 0, nX );
for( nY = 0L; nY < nNewHeight; nY++ ) for( nY = 0L; nY < nNewHeight; nY++ )
{
pWriteAcc->SetPixel( nY, nX, aCol0 ); pWriteAcc->SetPixel( nY, nX, aCol0 );
} }
}
else else
{ {
for( nY = 0L; nY < nNewHeight; nY++ ) for( nY = 0L; nY < nNewHeight; nY++ )
...@@ -1283,7 +1238,6 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1283,7 +1238,6 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
} }
} }
} }
}
delete[] pLutInt; delete[] pLutInt;
delete[] pLutFrac; delete[] pLutFrac;
...@@ -1296,13 +1250,15 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca ...@@ -1296,13 +1250,15 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
if( bRet ) if( bRet )
{ {
ImplAdaptBitCount(aNewBmp); ImplAdaptBitCount(aNewBmp);
ImplAssignWithSize( aNewBmp ); *this = aNewBmp;
} }
} }
} }
if( !bRet ) if( !bRet )
{
bRet = ImplScaleFast( rScaleX, rScaleY ); bRet = ImplScaleFast( rScaleX, rScaleY );
}
return bRet; return bRet;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment