mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix dxcanvas gradient glitches

Browse Source 
* moved common gradient step size code
   out to canvastools to share
 * reverted back to manual polygon rendering
   for anisotrophic rect and ellipse gradients
 * fixed tilemode==none case for bitmap fills
This commit is contained in:
thb
2010-02-19 01:13:34 +01:00
parent 9f35771929
commit b76532e1fb
5 changed files with 177 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
canvas/inc/canvas/canvastools.hxx Normal file → Executable file
View File

@@ -69,6 +69,7 @@ namespace com { namespace sun { namespace star { namespace rendering
struct ViewState;
struct IntegerBitmapLayout;
class XCanvas;
struct Texture;
class XIntegerBitmapColorSpace;
class XPolyPolygon2D;
@@ -499,6 +500,18 @@ namespace canvas
*/
::basegfx::B2DPolyPolygon getBoundMarksPolyPolygon( const ::basegfx::B2DRange& rRange );
/** Calculate number of gradient "strips" to generate (takes
into account device resolution)
@param nColorSteps
Maximal integer difference between all color stops, needed
for smooth gradient color differences
*/
int calcGradientStepCount( ::basegfx::B2DHomMatrix& rTotalTransform,
const ::com::sun::star::rendering::ViewState& viewState,
const ::com::sun::star::rendering::RenderState& renderState,
const ::com::sun::star::rendering::Texture& texture,
int nColorSteps );
/** A very simplistic map for ASCII strings and arbitrary value
types.

182
canvas/source/directx/dx_canvashelper_texturefill.cxx
View File

@@ -41,6 +41,7 @@
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/range/b2drectangle.hxx>
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/tools/tools.hxx>
#include <basegfx/tools/lerp.hxx>
#include <basegfx/tools/keystoplerp.hxx>
@@ -67,7 +68,7 @@ namespace dxcanvas
typedef ::boost::shared_ptr< Gdiplus::PathGradientBrush > PathGradientBrushSharedPtr;
bool fillLinearGradient( GraphicsSharedPtr& rGraphics,
const ::canvas::ParametricPolyPolygon::Values& rValues,
const ::canvas::ParametricPolyPolygon::Values& /*rValues*/,
const std::vector< Gdiplus::Color >& rColors,
const std::vector< Gdiplus::REAL >& rStops,
const GraphicsPathSharedPtr& rFillPath,
@@ -214,23 +215,14 @@ namespace dxcanvas
const std::vector< Gdiplus::REAL >& rStops,
GraphicsSharedPtr& rGraphics,
const GraphicsPathSharedPtr& rPath,
const rendering::ViewState& viewState,
const rendering::RenderState& renderState,
const rendering::Texture& texture )
{
Gdiplus::Matrix aMatrix;
tools::gdiPlusMatrixFromAffineMatrix2D( aMatrix,
texture.AffineTransform );
// copy original fill path object, might have to change it
// below
GraphicsPathSharedPtr pFillPath( rPath );
// clone original gradient path object, we need to change it
// below
GraphicsPathSharedPtr pGradientPath(
tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ) );
ENSURE_OR_RETURN( pGradientPath.get(),
"ParametricPolyPolygon::fillPolygonalGradient(): Could not clone path" );
const ::basegfx::B2DPolygon& rGradientPoly( rValues.maGradientPoly );
PathGradientBrushSharedPtr pGradientBrush;
@@ -264,8 +256,6 @@ namespace dxcanvas
return false;
}
rGraphics->MultiplyTransform( &aMatrix );
// disable anti-aliasing, if any
const Gdiplus::SmoothingMode eOldAAMode( rGraphics->GetSmoothingMode() );
rGraphics->SetSmoothingMode( Gdiplus::SmoothingModeHighSpeed );
@@ -278,50 +268,80 @@ namespace dxcanvas
int nColorSteps = 0;
for( size_t i=0; i<rColors.size()-1; ++i )
nColorSteps += numColorSteps(rColors[i],rColors[i+1]);
::basegfx::B2DHomMatrix aTotalTransform;
const int nStepCount=
::canvas::tools::calcGradientStepCount(aTotalTransform,
viewState,
renderState,
texture,
nColorSteps);
Gdiplus::Matrix aWorldTransformMatrix;
rGraphics->GetTransform( &aWorldTransformMatrix );
::basegfx::B2DHomMatrix aTextureTransform;
::basegfx::unotools::homMatrixFromAffineMatrix( aTextureTransform,
texture.AffineTransform );
// determine overall transformation for inner polygon (might
// have to be prefixed by anisotrophic scaling)
::basegfx::B2DHomMatrix aInnerPolygonTransformMatrix;
Gdiplus::RectF aBounds;
pGradientPath->GetBounds( &aBounds, &aWorldTransformMatrix, NULL );
// For performance reasons, we create a temporary VCL polygon
// here, keep it all the way and only change the vertex values
// in the loop below (as ::Polygon is a pimpl class, creating
// one every loop turn would really stress the mem allocator)
::basegfx::B2DPolygon aOuterPoly( rGradientPoly );
::basegfx::B2DPolygon aInnerPoly;
// longest line in gradient bound rect
const int nGradientSize(
static_cast<int>( hypot( aBounds.Width, aBounds.Height ) + 1.0 ) );
// subdivide polygon _before_ rendering, would otherwise have
// to be performed on every loop turn.
if( aOuterPoly.areControlPointsUsed() )
aOuterPoly = ::basegfx::tools::adaptiveSubdivideByAngle(aOuterPoly);
// typical number for pixel of the same color (strip size)
const int nStripSize( nGradientSize < 50 ? 2 : 4 );
aInnerPoly = aOuterPoly;
aOuterPoly.transform(aTextureTransform);
// use at least three steps, and at utmost the number of color
// steps
const int nStepCount(
::std::max(
3,
::std::min(
nGradientSize / nStripSize,
nColorSteps ) ) );
Gdiplus::SolidBrush aFillBrush( rColors[0] );
Gdiplus::Matrix aGDIScaleMatrix;
::basegfx::B2DHomMatrix aScaleMatrix;
// apply scaling (possibly anisotrophic) to inner polygon
// ------------------------------------------------------
// calc relative size for anisotrophic polygon scaling:
// when the aspect ratio is e.g. 2.0, that denotes a
// gradient which is twice as wide as high. Then, to
// generate a symmetric gradient, the x direction is only
// scaled to 0.5 times the gradient width. Similarly, when
// the aspect ratio is 4.0, the focus has 3/4 the width of
// the overall gradient.
const double nRelativeFocusSize( rValues.mnAspectRatio > 1.0 ?
1.0 - 1.0/rValues.mnAspectRatio :
1.0 - rValues.mnAspectRatio );
// scale inner polygon according to aspect ratio: for
// wider-than-tall bounds (nAspectRatio > 1.0), the inner
// polygon, representing the gradient focus, must have
// non-zero width. Specifically, a bound rect twice as wide as
// tall has a focus polygon of half it's width.
const double nAspectRatio( rValues.mnAspectRatio );
if( nAspectRatio > 1.0 )
{
// width > height case
aInnerPolygonTransformMatrix.scale( 1.0 - 1.0/nAspectRatio,
0.0 );
}
else if( nAspectRatio < 1.0 )
{
// width < height case
aInnerPolygonTransformMatrix.scale( 0.0,
1.0 - nAspectRatio );
}
else
{
// isotrophic case
aInnerPolygonTransformMatrix.scale( 0.0, 0.0 );
}
// and finally, add texture transform to it.
aInnerPolygonTransformMatrix *= aTextureTransform;
// apply final matrix to polygon
aInnerPoly.transform( aInnerPolygonTransformMatrix );
Gdiplus::GraphicsPath aCurrPath;
Gdiplus::SolidBrush aFillBrush( rColors[0] );
const sal_uInt32 nNumPoints( aOuterPoly.count() );
basegfx::tools::KeyStopLerp aLerper(rValues.maStops);
for( int i=1; i<nStepCount; ++i )
{
std::ptrdiff_t nIndex;
double fAlpha;
boost::tuples::tie(nIndex,fAlpha)=aLerper.lerp(double(i)/nStepCount);
const double fT( i/double(nStepCount) );
boost::tuples::tie(nIndex,fAlpha)=aLerper.lerp(fT);
const Gdiplus::Color aFillColor(
static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetRed(),rColors[nIndex+1].GetRed(),fAlpha) ),
@@ -329,45 +349,23 @@ namespace dxcanvas
static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetBlue(),rColors[nIndex+1].GetBlue(),fAlpha) ) );
aFillBrush.SetColor( aFillColor );
const double nCurrScale( (nStepCount-i)/(double)nStepCount );
aScaleMatrix = basegfx::tools::createTranslateB2DHomMatrix(-0.5, -0.5);
// handle anisotrophic polygon scaling
if( rValues.mnAspectRatio < 1.0 )
aCurrPath.Reset(); aCurrPath.StartFigure();
for( unsigned int p=1; p<nNumPoints; ++p )
{
// height > width case
aScaleMatrix.scale( nCurrScale,
// lerp with nCurrScale
// between 1.0 and
// relative focus height
nCurrScale + (1.0-nCurrScale)*nRelativeFocusSize );
}
else if( rValues.mnAspectRatio > 1.0 )
{
// width > height case
aScaleMatrix.scale( nCurrScale + (1.0-nCurrScale)*nRelativeFocusSize,
// lerp with nCurrScale
// between 1.0 and
// relative focus width
nCurrScale );
}
else
{
aScaleMatrix.scale( nCurrScale,
nCurrScale );
const ::basegfx::B2DPoint& rOuterPoint1( aOuterPoly.getB2DPoint(p-1) );
const ::basegfx::B2DPoint& rInnerPoint1( aInnerPoly.getB2DPoint(p-1) );
const ::basegfx::B2DPoint& rOuterPoint2( aOuterPoly.getB2DPoint(p) );
const ::basegfx::B2DPoint& rInnerPoint2( aInnerPoly.getB2DPoint(p) );
aCurrPath.AddLine(
Gdiplus::REAL(fT*rInnerPoint1.getX() + (1-fT)*rOuterPoint1.getX()),
Gdiplus::REAL(fT*rInnerPoint1.getY() + (1-fT)*rOuterPoint1.getY()),
Gdiplus::REAL(fT*rInnerPoint2.getX() + (1-fT)*rOuterPoint2.getX()),
Gdiplus::REAL(fT*rInnerPoint2.getY() + (1-fT)*rOuterPoint2.getY()));
}
aCurrPath.CloseFigure();
aScaleMatrix.translate( 0.5, 0.5 );
tools::gdiPlusMatrixFromB2DHomMatrix( aGDIScaleMatrix,
aScaleMatrix );
GraphicsPathSharedPtr pScaledGradientPath(
tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ) );
pScaledGradientPath->Transform( &aGDIScaleMatrix );
rGraphics->FillPath( &aFillBrush, pScaledGradientPath.get() );
rGraphics->FillPath( &aFillBrush, &aCurrPath );
}
// reset to old anti-alias mode
@@ -388,6 +386,11 @@ namespace dxcanvas
// one sets both, only the translational components of the
// texture is respected.
Gdiplus::Matrix aMatrix;
tools::gdiPlusMatrixFromAffineMatrix2D( aMatrix,
texture.AffineTransform );
GraphicsPathSharedPtr pGradientPath(
tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ));
pGradientPath->Transform( &aMatrix );
pGradientBrush.reset(
@@ -400,7 +403,7 @@ namespace dxcanvas
// gradients are by default the _centroid_ of the path
// (i.e. the weighted sum of edge points), it will not
// necessarily coincide with our notion of center.
Gdiplus::PointF aCenterPoint(0.5, 0.5);
Gdiplus::PointF aCenterPoint(0, 0);
aMatrix.TransformPoints( &aCenterPoint );
pGradientBrush->SetCenterPoint( aCenterPoint );
@@ -440,6 +443,8 @@ namespace dxcanvas
const std::vector< Gdiplus::REAL >& rStops,
GraphicsSharedPtr& rGraphics,
const GraphicsPathSharedPtr& rPath,
const rendering::ViewState& viewState,
const rendering::RenderState& renderState,
const rendering::Texture& texture )
{
switch( rValues.meType )
@@ -461,6 +466,8 @@ namespace dxcanvas
rStops,
rGraphics,
rPath,
viewState,
renderState,
texture );
break;
@@ -486,8 +493,8 @@ namespace dxcanvas
const geometry::IntegerSize2D aBmpSize( xBitmap->getSize() );
ENSURE_ARG_OR_THROW( aBmpSize.Width != 0 &&
aBmpSize.Height != 0,
"CanvasHelper::fillBitmap(): zero-sized texture bitmap" );
aBmpSize.Height != 0,
"CanvasHelper::fillBitmap(): zero-sized texture bitmap" );
// TODO(P3): Detect case that path is rectangle and
// bitmap is just scaled into that. Then, we can
@@ -499,7 +506,6 @@ namespace dxcanvas
tools::bitmapFromXBitmap( xBitmap ) );
TextureBrushSharedPtr pBrush;
if( ::rtl::math::approxEqual( rTexture.Alpha,
1.0 ) )
{
@@ -537,9 +543,9 @@ namespace dxcanvas
// scale down bitmap to [0,1]x[0,1] rect, as required
// from the XCanvas interface.
pBrush->MultiplyTransform( &aTextureTransform );
pBrush->ScaleTransform( static_cast< Gdiplus::REAL >(1.0/aBmpSize.Width),
static_cast< Gdiplus::REAL >(1.0/aBmpSize.Height) );
pBrush->MultiplyTransform( &aTextureTransform );
// TODO(F1): FillRule
ENSURE_OR_THROW(
@@ -602,6 +608,8 @@ namespace dxcanvas
aStops,
pGraphics,
tools::graphicsPathFromXPolyPolygon2D( xPolyPolygon ),
viewState,
renderState,
textures[0] );
}
}

2
canvas/source/directx/dx_impltools.cxx
View File

@@ -199,7 +199,7 @@ namespace dxcanvas
{
const sal_uInt32 nPoints( rPoly.count() );
if( !nPoints )
if( nPoints < 2 )
return;
rOutput->StartFigure();

48
canvas/source/tools/canvastools.cxx Normal file → Executable file
View File

@@ -994,6 +994,54 @@ namespace canvas
return aPolyPoly;
}
int calcGradientStepCount( ::basegfx::B2DHomMatrix& rTotalTransform,
const rendering::ViewState& viewState,
const rendering::RenderState& renderState,
const rendering::Texture& texture,
int nColorSteps )
{
// calculate overall texture transformation (directly from
// texture to device space).
::basegfx::B2DHomMatrix aMatrix;
rTotalTransform.identity();
::basegfx::unotools::homMatrixFromAffineMatrix( rTotalTransform,
texture.AffineTransform );
::canvas::tools::mergeViewAndRenderTransform(aMatrix,
viewState,
renderState);
rTotalTransform *= aMatrix; // prepend total view/render transformation
// determine size of gradient in device coordinate system
// (to e.g. determine sensible number of gradient steps)
::basegfx::B2DPoint aLeftTop( 0.0, 0.0 );
::basegfx::B2DPoint aLeftBottom( 0.0, 1.0 );
::basegfx::B2DPoint aRightTop( 1.0, 0.0 );
::basegfx::B2DPoint aRightBottom( 1.0, 1.0 );
aLeftTop *= rTotalTransform;
aLeftBottom *= rTotalTransform;
aRightTop *= rTotalTransform;
aRightBottom*= rTotalTransform;
// longest line in gradient bound rect
const int nGradientSize(
static_cast<int>(
::std::max(
::basegfx::B2DVector(aRightBottom-aLeftTop).getLength(),
::basegfx::B2DVector(aRightTop-aLeftBottom).getLength() ) + 1.0 ) );
// typical number for pixel of the same color (strip size)
const int nStripSize( nGradientSize < 50 ? 2 : 4 );
// use at least three steps, and at utmost the number of color
// steps
return ::std::max( 3,
::std::min(
nGradientSize / nStripSize,
nColorSteps ) );
}
} // namespace tools
} // namespace canvas

75
canvas/source/vcl/canvashelper_texturefill.cxx Normal file → Executable file
View File

@@ -562,62 +562,27 @@ namespace vclcanvas
// deadlocks, canvashelper calls this method with locked own
// mutex.
// calculate overall texture transformation (directly from
// texture to device space).
::basegfx::B2DHomMatrix aMatrix;
::basegfx::B2DHomMatrix aTextureTransform;
::basegfx::unotools::homMatrixFromAffineMatrix( aTextureTransform,
texture.AffineTransform );
::canvas::tools::mergeViewAndRenderTransform(aMatrix,
viewState,
renderState);
aTextureTransform *= aMatrix; // prepend total view/render transformation
// determine maximal bound rect of gradient-filled polygon
const ::Rectangle aPolygonDeviceRectOrig(
rPoly.GetBoundRect() );
// determine size of gradient in device coordinate system
// (to e.g. determine sensible number of gradient steps)
::basegfx::B2DPoint aLeftTop( 0.0, 0.0 );
::basegfx::B2DPoint aLeftBottom( 0.0, 1.0 );
::basegfx::B2DPoint aRightTop( 1.0, 0.0 );
::basegfx::B2DPoint aRightBottom( 1.0, 1.0 );
aLeftTop *= aTextureTransform;
aLeftBottom *= aTextureTransform;
aRightTop *= aTextureTransform;
aRightBottom*= aTextureTransform;
// calc step size
// --------------
int nColorSteps = 0;
for( size_t i=0; i<rColors.size()-1; ++i )
nColorSteps += numColorSteps(rColors[i],rColors[i+1]);
// longest line in gradient bound rect
const int nGradientSize(
static_cast<int>(
::std::max(
::basegfx::B2DVector(aRightBottom-aLeftTop).getLength(),
::basegfx::B2DVector(aRightTop-aLeftBottom).getLength() ) + 1.0 ) );
// typical number for pixel of the same color (strip size)
const int nStripSize( nGradientSize < 50 ? 2 : 4 );
// use at least three steps, and at utmost the number of color
// steps
const int nStepCount(
::std::max(
3,
::std::min(
nGradientSize / nStripSize,
nColorSteps ) ) );
::basegfx::B2DHomMatrix aTotalTransform;
const int nStepCount=
::canvas::tools::calcGradientStepCount(aTotalTransform,
viewState,
renderState,
texture,
nColorSteps);
rOutDev.SetLineColor();
// determine maximal bound rect of texture-filled
// polygon
const ::Rectangle aPolygonDeviceRectOrig(
rPoly.GetBoundRect() );
if( tools::isRectangle( rPoly ) )
{
// use optimized output path
@@ -635,7 +600,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -648,7 +613,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -666,7 +631,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -679,7 +644,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -694,7 +659,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
@@ -705,7 +670,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
@@ -718,7 +683,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
@@ -729,7 +694,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
aTextureTransform,
aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );