Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Print / Reach / AlphaFlattener / Utility.cs / 1 / Utility.cs
//------------------------------------------------------------------------------
// Microsoft Printing
// Copyright (c) Microsoft Corporation, 2004
//
// File: Primitive.cs
//
// History:
// [....]: 04/20/2004 Created
//-----------------------------------------------------------------------------
using System;
using System.Collections; // for ArrayList
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows; // for Rect WindowsBase.dll
using System.Windows.Media; // for Geometry, Brush, ImageData. PresentationCore.dll
using System.Windows.Media.Effects;
using System.Windows.Media.Imaging;
using System.Windows.Controls; // for Image
using System.Windows.Shapes; // for Glyphs
using Microsoft.Internal;
using System.Runtime.CompilerServices;
using MS.Internal.ReachFramework;
using System.Security;
using System.Security.Permissions;
using System.Windows.Xps.Serialization;
[assembly: InternalsVisibleTo( "System.Printing, PublicKey=" + BuildInfo.WCP_PUBLIC_KEY_STRING)]
// This code is debug only until we decide to go all the way with enforcements.
#if ENFORCEMENT
//[assembly:SecurityCritical] //needed to run critical code
#endif
// DRT tests
[assembly: InternalsVisibleTo( "DrtAlphaFlattener, PublicKey=" + BuildInfo.WCP_PUBLIC_KEY_STRING)]
[assembly: InternalsVisibleTo("DrtVisualSerialization, PublicKey=" + BuildInfo.WCP_PUBLIC_KEY_STRING)]
[assembly: InternalsVisibleTo( "AvaPrint, PublicKey=" + "0024000004800000940000000602000000240000525341310004000001000100c1bcd9b7844cd35725b1138216ed5e0fab914676d580860f6f081c8c0e83b92d835ffae76fa968f7637e4b6e32d77fee1c084088cee736ce589d65ad0fa66f086c2f5f755a6f2909d17c643b45c72a906aaac617bfd67491a8fce54784ca98317aea28c0544546ff9123f6f94e59793f2874437bc3d136a40095d0f960e6a6a4")]
[assembly: InternalsVisibleTo( "AvaVV, PublicKey=" + "0024000004800000940000000602000000240000525341310004000001000100c1bcd9b7844cd35725b1138216ed5e0fab914676d580860f6f081c8c0e83b92d835ffae76fa968f7637e4b6e32d77fee1c084088cee736ce589d65ad0fa66f086c2f5f755a6f2909d17c643b45c72a906aaac617bfd67491a8fce54784ca98317aea28c0544546ff9123f6f94e59793f2874437bc3d136a40095d0f960e6a6a4")]
namespace Microsoft.Internal.AlphaFlattener
{
#if DEBUG
internal static class StopWatch
{
static double s_total; // = 0;
static DateTime s_startTime;
static int s_count; // = 0;
internal static void Start()
{
s_startTime = DateTime.Now;
}
internal static void Stop()
{
TimeSpan elapsed = DateTime.Now - s_startTime;
s_total += elapsed.TotalSeconds;
s_count++;
if (Configuration.Verbose >= 2)
{
Console.WriteLine("{0} {1} {2}", s_count, elapsed.TotalSeconds, s_total);
}
}
}
#endif
internal static class Utility
{
#region Constants
private const double OpaqueEnough = 250.0 / 255; // 0.98
private const double AlmostTransparent = 5.0 / 255; // 0.02
// Espilon for detecting two doubles as the same. It's a pretty large epsilon due to
// high error when dealing with PathGeometry.
private const double Epsilon = 0.00002;
///
/// Minimum geometry width and height in world space for it to be considered visible.
///
///
/// Currently defined as 1x1 rectangle at 960 DPI.
///
private const double GeometryMinimumDimension = 1 * (96.0 / 960.0);
///
/// Numerical limits from the XPS specification.
///
private const double XpsMaxDouble = 1e38;
private const double XpsMinDouble = -1e38;
///
/// Drawing cost of having transparency.
///
public const double TransparencyCostFactor = 2.5;
#endregion
#region Math and Transform
///
/// Apply transformation to Rect
///
static public Rect TransformRect(Rect r, Matrix t)
{
if (t.IsIdentity)
{
return r;
}
r.Transform(t);
return r;
}
///
/// IsOne - Returns whether or not the double is "close" to 1.
///
/// The double to compare to 1.
public static bool IsOne(double value)
{
return Math.Abs(value - 1.0) < Epsilon;
}
///
/// IsZero - Returns whether or not the double is "close" to 0.
///
/// The double to compare to 0.
public static bool IsZero(double value)
{
return Math.Abs(value) < Epsilon;
}
static public bool AreClose(double v1, double v2)
{
return IsZero(v1 - v2);
}
static public bool AreClose(Point p1, Point p2)
{
return IsZero(p1.X - p2.X) && IsZero(p1.Y - p2.Y);
}
static public bool AreClose(Vector v1, Vector v2)
{
return IsZero(v1.X - v2.X) && IsZero(v2.Y - v2.Y);
}
static public bool AreClose(Size s1, Size s2)
{
return IsZero(s1.Width - s2.Width) && IsZero(s1.Height - s2.Height);
}
static public bool AreClose(Rect r1, Rect r2)
{
return AreClose(r1.TopLeft, r2.TopLeft) && AreClose(r1.BottomRight, r2.BottomRight);
}
static public bool IsMultipleOf(double v1, double v2)
{
if (IsZero(v2))
{
return IsZero(v1);
}
double scale = v1 / v2;
double s = Math.Round(scale);
return (s >= 1) && IsZero(scale - s);
}
static public bool IsScaleTranslate(Matrix transform)
{
return IsZero(transform.M12) && IsZero(transform.M21);
}
// x' = m11 * x + m21 * y + dx
// y' = m12 * x + m22 * y + dy
// When m11^2 + m12^2 = m21^2 + m22^2 and m11 * m21 + m12 * m22 = 0
// Distance between any two points will be scaled by a constant
static public bool HasUniformScale(Matrix mat, out double scale)
{
scale = 1;
double A = mat.M11 * mat.M11 + mat.M12 * mat.M12;
double B = mat.M21 * mat.M21 + mat.M22 * mat.M22;
if (IsZero(A - B))
{
double C = mat.M11 * mat.M21 + mat.M12 * mat.M22;
scale = Math.Sqrt(A);
return IsZero(C);
}
return false;
}
// Euclidean distance: optimized for common cases where either x or y is zero.
public static double Hypotenuse(double x, double y)
{
x = Math.Abs(x);
y = Math.Abs(y);
if (IsZero(x))
{
return y;
}
else if (IsZero(y))
{
return x;
}
else
{
if (y < x)
{
double temp = x;
x = y;
y = temp;
}
double r = x / y;
return y * Math.Sqrt(r * r + 1.0);
}
}
public static double GetScaleX(Matrix matrix)
{
return Hypotenuse(matrix.M11, matrix.M21);
}
public static double GetScaleY(Matrix matrix)
{
return Hypotenuse(matrix.M12, matrix.M22);
}
public static double GetScale(Matrix trans)
{
return Math.Max(GetScaleX(trans), GetScaleY(trans));
}
public static bool IsIdentity(Matrix mat)
{
if (mat.IsIdentity)
{
return true;
}
else
{
return IsOne(mat.M11) && IsZero(mat.M12) &&
IsZero(mat.M21) && IsOne(mat.M22) &&
IsZero(mat.OffsetX) && IsZero(mat.OffsetY);
}
}
// Check if transform is null, identity or close enough to identity
public static bool IsIdentity(Transform transform)
{
if (transform == null)
{
return true;
}
else
{
return IsIdentity(transform.Value);
}
}
///
/// Merge transform with relative transform
///
///
///
///
///
/// Creates transformation mapping from first rectangle to the second rectangle.
///
///
///
///
/// Creates transformation mapping from first rectangle to rectangle at origin with specified dimensions.
///
///
///
///
///
/// Apply transformation to Geometry
///
static public Geometry TransformGeometry(Geometry g, Matrix t)
{
if (g == null)
{
return null;
}
if (t.IsIdentity)
{
return g;
}
Geometry newg = g.CloneCurrentValue();
newg.Transform = MultiplyTransform(newg.Transform, new MatrixTransform(t));
return newg;
}
///
/// Apply transformation to Geometry
///
static public Geometry TransformGeometry(Geometry g, Transform t)
{
if (g == null)
{
return null;
}
if (t.Value.IsIdentity)
{
return g;
}
Geometry newg = g.CloneCurrentValue();
newg.Transform = MultiplyTransform(newg.Transform, t);
return newg;
}
static public Geometry InverseTransformGeometry(Geometry g, Matrix mat)
{
if ((g == null) || mat.IsIdentity)
{
return g;
}
mat.Invert();
return TransformGeometry(g, mat);
}
///
/// Checks if a Geometry can be considered empty after transformation.
///
///
/// Transformation hint to world space, may be identity
///
/// mat is used to transform geometry bounds to world space to test for
/// non-visible geometry.
///
static public bool IsEmpty(Geometry shape, Matrix mat)
{
if (shape == null)
{
return true;
}
Rect bounds = shape.Bounds;
// If bounding rectangle is empty, the shape is empty
if (bounds.IsEmpty)
{
return true;
}
if (!mat.IsIdentity)
{
bounds.Transform(mat);
if (bounds.Width < GeometryMinimumDimension || bounds.Height < GeometryMinimumDimension)
{
// geometry bounds in world space is too small, treat as empty
return true;
}
}
return false;
}
[FriendAccessAllowed]
static public PathGeometry GetAsPathGeometry(Geometry geo)
{
PathGeometry pg = geo as PathGeometry;
if (pg == null)
{
pg = PathGeometry.CreateFromGeometry(geo);
}
return pg;
}
[FriendAccessAllowed]
static public bool IsRectangle(Geometry geometry)
{
if (geometry.Transform != null && !IsScaleTranslate(geometry.Transform.Value))
{
// assume the transformation distorts the geometry, thus it can't be rectangle
return false;
}
bool rect = geometry is RectangleGeometry;
if (!rect)
{
StreamGeometry streamGeometry = geometry as StreamGeometry;
if (streamGeometry != null)
{
rect = IsRectangle(streamGeometry);
}
}
if (!rect)
{
PathGeometry pathGeometry = geometry as PathGeometry;
if (pathGeometry != null)
{
rect = IsRectangle(pathGeometry);
}
}
return rect;
}
// Checks if StreamGeometry is a rectangle
private static bool IsRectangle(StreamGeometry geometry)
{
int pointCount;
bool isRectangle;
bool isLineSegment;
GeometryAnalyzer.Analyze(
geometry.GetPathGeometryData(),
geometry.Bounds,
out pointCount,
out isRectangle,
out isLineSegment
);
return isRectangle;
}
// Check if a PathGeometry is a normal rectangle
private static bool IsRectangle(PathGeometry geometry)
{
if ((geometry == null) || (geometry.Figures.Count != 1))
{
return false;
}
PathFigure figure = geometry.Figures[0];
if ((figure != null) && figure.IsClosed)
{
Point p = figure.StartPoint;
int n = 0;
for (int s = 0; s < figure.Segments.Count; s++)
{
PathSegment segment = figure.Segments[s];
if (segment != null)
{
LineSegment seg = segment as LineSegment;
PolyLineSegment pseg = null;
int count = 1;
if (seg == null)
{
pseg = segment as PolyLineSegment;
if ((pseg == null) || (pseg.Points == null) || (pseg.Points.Count != 3))
{
return false;
}
count = 3;
}
for (int i = 0; i < count; i++)
{
Point q;
if (seg != null)
{
q = seg.Point;
}
else
{
q = pseg.Points[i];
}
if (!IsOnRectangle(figure.StartPoint, p, q, n))
{
return false;
}
p = q;
n++;
}
}
else
{
return false;
}
}
return n >= 3; // 3 or 4 points
}
return false;
}
///
/// Non-exhaustive check if geometry is a single line segment.
///
///
///
/// Check if the first Geometry completely covers the second one.
/// It's only used for optimization, so it's okay to return false anytime.
///
///
///
/// True if Intersect(one, two) = two
static public bool FullyCovers(Geometry one, Geometry two)
{
Rect bounds1 = one.Bounds;
Rect bounds2 = two.Bounds;
// Check if the bounds of one covers the bounds of two
if (bounds1.Contains(bounds2))
{
if (IsRectangle(one))
{
return true;
}
double cost1 = GetGeometryCost(one);
double cost2 = GetGeometryCost(two);
// Avoid expensive calls to convert to PathGeometry and calling ContainsWithDetail
if (cost1 * cost2 < 10000) // 100 x 100
{
IntersectionDetail detail = one.FillContainsWithDetail(two);
return (detail == IntersectionDetail.FullyContains);
}
else if (cost1 < 500)
{
IntersectionDetail detail = one.FillContainsWithDetail(new RectangleGeometry(bounds2));
return (detail == IntersectionDetail.FullyContains);
}
}
return false;
}
static public bool Covers(Geometry one, Geometry two)
{
Rect bounds1 = one.Bounds;
Rect bounds2 = two.Bounds;
if (bounds1.Contains(bounds2))
{
if (one is RectangleGeometry && one.Transform.Value.IsIdentity)
{
return true;
}
}
IntersectionDetail detail = one.FillContainsWithDetail(two);
return (detail == IntersectionDetail.FullyContains);
}
///
/// Find intersection of two Geometries
///
///
///
/// Transformation of resulting intersection geometry to world space for optimization purposes;
/// may be null.
///
///
/// mat is used to estimate world-space size of the intersection, and return empty if
/// intersection result is too small to be visible.
///
static public Geometry Intersect(Geometry one, Geometry two, Matrix mat, out bool empty)
{
empty = false;
if (one == null) // null is whole
{
return two;
}
if (two == null)
{
return one;
}
if (FullyCovers(one, two))
{
return two;
}
if (FullyCovers(two, one))
{
return one;
}
if (one.Bounds.IntersectsWith(two.Bounds))
{
one = Combine(one, two, GeometryCombineMode.Intersect, mat);
}
else
{
one = null;
}
empty = one == null;
return one;
}
///
/// Excludes second geometry from the first.
///
///
///
/// Transformation of resulting intersection geometry to world space for optimization purposes;
/// may be null.
///
/// mat is used to estimate world-space size of the intersection, and return empty if
/// intersection result is too small to be visible.
///
static public Geometry Exclude(Geometry one, Geometry two, Matrix mat)
{
if ((one == null) || (two == null))
{
return one;
}
return Combine(one, two, GeometryCombineMode.Exclude, mat);
}
///
/// Check if a clip Geometry is disjoint with a bounding box
///
///
///
///
/// Gets upper bound to number of points in geometry data.
///
///
///
/// Get opacity to be in [0..1], default = 1
///
///
///
/// Check if opacity is high enough to be considered totally opaque
///
public static bool IsOpaque(double opacity)
{
return Utility.NormalizeOpacity(opacity) > OpaqueEnough;
}
///
/// Check if opacity is low enough to be considered totally transparent
///
public static bool IsTransparent(double opacity)
{
return Utility.NormalizeOpacity(opacity) < AlmostTransparent;
}
///
/// Check if a brush is opacity
///
///
/// True if brush is known to be opaque. It's okay to return false
public static bool IsBrushOpaque(Brush brush)
{
if (IsOpaque(brush.Opacity))
{
SolidColorBrush sb = brush as SolidColorBrush;
if (sb != null)
{
return Utility.IsOpaque(sb.Color.ScA);
}
// More common brushes can be added later
}
return false;
}
///
/// Converts a floating-point opacity value to a byte value.
///
///
///
/// Converts a floating-point color channel value to a byte value.
///
///
///
/// Calculate the blended color of two colors, the color which can achieve
/// the same result as drawing two colors seperately
///
///
///
///
/// Multiply a color's alpha channel by an opacity value
///
///
///
///
/// Blend an array of PBGRA pixels with a given Color rendering under it
///
///
///
///
///
/// Only use the alpha channel in the image
///
/// Critical : pixels may contain critical information
/// TreatAsSafe: pixels is modified in place, not leaked
///
[SecurityCritical, SecurityTreatAsSafe]
static public void BlendOverColor(byte[] pixels, int count, Color colorX, double opacity, bool opacityOnly)
{
/* if (Configuration.ForceAlphaOpaque)
{
for (int q = 3; q < count * 4; q += 4)
{
pixels[q] = 255; // Force opaque
}
return;
}
*/
Byte xA = colorX.A;
Byte xR = colorX.R;
Byte xG = colorX.G;
Byte xB = colorX.B;
int p = 0;
int op = OpacityToByte(opacity);
while (count > 0)
{
int b = pixels[p + 3] * op / 255; // pixel.Opacity * opacity
if (opacityOnly)
{
Byte pa = (Byte) (b * xA / 255); // pixel.Opacity * opacity * colorX.A;
pixels[p] = (Byte) (xB * pa / 255);
pixels[p + 1] = (Byte) (xG * pa / 255);
pixels[p + 2] = (Byte) (xR * pa / 255);
pixels[p + 3] = pa;
}
else
{
int c = xA * (255 - b) / 255; // colorX.A * (1 - pixel.Opacity * opacity)
pixels[p] = Div255(xB * c + pixels[p ] * op);
pixels[p + 1] = Div255(xG * c + pixels[p + 1] * op);
pixels[p + 2] = Div255(xR * c + pixels[p + 2] * op);
pixels[p + 3] = Div255((xA + b) * 255 - xA * b);
}
p += 4;
count --;
}
}
///
/// Blend an array of PBGRA pixels with a given Color rendering over it
///
///
///
///
///
/// Only use the alpha channel in the image
///
/// Critical : pixels may contain critical information
/// TreatAsSafe: pixels is modified in place, not leaked
///
[SecurityCritical, SecurityTreatAsSafe]
static public void BlendUnderColor(byte[] pixels, int count, Color colorY, double opacity, bool opacityOnly)
{
Byte b = colorY.A;
Byte yR = colorY.R;
Byte yG = colorY.G;
Byte yB = colorY.B;
int yRb = colorY.R * b;
int yGb = colorY.G * b;
int yBb = colorY.B * b;
int p = 0;
int op = OpacityToByte(opacity);
int op1_b = op * (255 -b ) / 255;
while (count > 0)
{
int a = pixels[p + 3] * op / 255;
if (opacityOnly)
{
Byte pa = (Byte)(b * a / 255);
pixels[p] = (Byte)(yB * pa / 255);
pixels[p + 1] = (Byte)(yG * pa / 255);
pixels[p + 2] = (Byte)(yR * pa / 255);
pixels[p + 3] = pa;
}
else
{
pixels[p ] = Div255(pixels[p] * op1_b + yBb);
pixels[p + 1] = Div255(pixels[p + 1] * op1_b + yGb);
pixels[p + 2] = Div255(pixels[p + 2] * op1_b + yRb);
pixels[p + 3] = Div255((a + b) * 255 - a * b);
}
p += 4;
count --;
}
}
///
/// Blend two PBGRA buffer into one PBGRA buffer
///
///
///
///
///
///
/// Output pixel array
///
/// Critical : pixels may contain critical information
/// TreatAsSafe: pixels is modified in place, not leaked
///
[SecurityCritical, SecurityTreatAsSafe]
static public void BlendPixels(byte[] pixelsA, bool opacityOnlyA, byte[] pixelsB, bool opacityOnlyB, int count, byte[] pixelsC)
{
int p = 0;
while (count > 0)
{
count --;
Byte a = pixelsA[p + 3]; // alpha for A
Byte b = pixelsB[p + 3]; // alpha for B
if (opacityOnlyA)
{
pixelsC[p] = (Byte)(pixelsB[p] * a / 255); p++;
pixelsC[p] = (Byte)(pixelsB[p] * a / 255); p++;
pixelsC[p] = (Byte)(pixelsB[p] * a / 255); p++;
pixelsC[p] = (Byte)(a * b / 255);
}
else if (opacityOnlyB)
{
pixelsC[p] = (Byte)(pixelsA[p] * b / 255); p++;
pixelsC[p] = (Byte)(pixelsA[p] * b / 255); p++;
pixelsC[p] = (Byte)(pixelsA[p] * b / 255); p++;
pixelsC[p] = (Byte)(a * b / 255);
}
else
{
pixelsC[p] = Div255(pixelsA[p] * (255 - b) + pixelsB[p] * 255); p++;
pixelsC[p] = Div255(pixelsA[p] * (255 - b) + pixelsB[p] * 255); p++;
pixelsC[p] = Div255(pixelsA[p] * (255 - b) + pixelsB[p] * 255); p++;
pixelsC[p] = Div255((a + b) * 255 - a * b);
}
p ++;
}
}
///
/// Clips pixels to specified rectangle.
///
///
///
///
/// Left position of clip rectangle.
///
///
///
/// Returns array of clipped pixels.
///
/// Critical : pixels may contain critical information
///
[SecurityCritical]
static public byte[] ClipPixels(byte[] pixels, int width, int height, int x0, int y0, int clipWidth, int clipHeight)
{
Debug.Assert(
(x0 >= 0) &&
(y0 >= 0) &&
((x0 + clipWidth) <= width) &&
((y0 + clipHeight) <= height)
);
if (x0 == 0 && y0 == 0 && clipWidth == width && clipHeight == height)
{
// no clipping
return pixels;
}
else
{
int stride = width * 4;
int clipStride = clipWidth * 4;
Byte[] result = new Byte[checked(clipStride * clipHeight)];
int clipIndex = 0;
for (int y = y0; y < (y0 + clipHeight); y++)
{
Array.Copy(
pixels, stride * y + x0 * 4, // source
result, clipIndex, // destination
clipWidth * 4
);
clipIndex += clipWidth * 4;
}
return result;
}
}
///
/// Check if an image is of Pbgra format and has pixel with bgr > a.
/// Such images have to be encoded with pre-multiplied alpha channel to be accurate.
///
///
///
/// Critical: This code calls an internal PresentationCore function CriticalCopyPixels
/// TreatAsSafe: We just return a boolean value, image itself is not exposed
///
[SecurityCritical, SecurityTreatAsSafe]
internal static bool NeedPremultiplyAlpha(BitmapSource bitmapSource)
{
if ((bitmapSource != null) && (bitmapSource.Format == PixelFormats.Pbgra32))
{
int width = bitmapSource.PixelWidth;
int height = bitmapSource.PixelHeight;
int stride = width * 4;
Int32Rect rect = new Int32Rect(0, 0, width, 1);
byte[] pixels = new byte[stride];
for (int y = 0; y < height; y ++)
{
bitmapSource.CriticalCopyPixels(rect, pixels, stride, 0);
int p = 0;
for (int x = 0; x < width; x ++)
{
if ((pixels[p ] > pixels[p + 3]) ||
(pixels[p + 1] > pixels[p + 3]) ||
(pixels[p + 2] > pixels[p + 3]))
{
return true;
}
p += 4;
}
rect.Y ++;
}
}
return false;
}
///
/// Extract constant alpha out from opacity mask
///
///
///
///
///
/// Create a DrawingBrush which is Opt-out of inheritance
///
///
///
/// Retrieves the bounding box of TileBrush content.
///
/// All Avalon brushes accepted, including VisualBrush
///
/// DrawingBrush content bounding box may have TopLeft that isn't (0, 0).
///
/// Returns Rect.Empty if no content, or content isn't visible.
public static Rect GetTileContentBounds(TileBrush brush)
{
Rect bounds = Rect.Empty;
ImageBrush imageBrush = brush as ImageBrush;
if (imageBrush != null)
{
if (imageBrush.ImageSource != null)
{
bounds = new Rect(0, 0, imageBrush.ImageSource.Width, imageBrush.ImageSource.Height);
}
return bounds;
}
DrawingBrush drawingBrush = brush as DrawingBrush;
if (drawingBrush != null)
{
if (drawingBrush.Drawing != null)
{
bounds = drawingBrush.Drawing.Bounds;
}
return bounds;
}
VisualBrush visualBrush = brush as VisualBrush;
if (visualBrush != null)
{
if (visualBrush.Visual != null)
{
bounds = VisualTreeHelper.GetDescendantBounds(visualBrush.Visual);
Geometry clip = VisualTreeHelper.GetClip(visualBrush.Visual);
if (clip != null)
{
bounds.Intersect(clip.Bounds);
}
}
return bounds;
}
Debug.Assert(false, "Unhandled TileBrush type");
return bounds;
}
///
/// Gets TileBrush absolute Viewbox.
///
///
/// Returns Empty if brush doesn't have absolute viewbox and content is not visible
public static Rect GetTileAbsoluteViewbox(TileBrush brush)
{
Rect viewbox = brush.Viewbox;
if (brush.ViewboxUnits == BrushMappingMode.RelativeToBoundingBox)
{
Rect content = GetTileContentBounds(brush);
if (IsRenderVisible(content))
{
viewbox.Scale(content.Width, content.Height);
viewbox.Offset(content.Left, content.Top);
}
else
{
viewbox = Rect.Empty;
}
}
return viewbox;
}
///
/// Gets TileBrush absolute Viewport relative to fill bounds.
///
///
///
/// Returns Empty if brush doesn't have absolute viewport and bounds are not visible
public static Rect GetTileAbsoluteViewport(TileBrush brush, Rect bounds)
{
Rect viewport = brush.Viewport;
if (brush.ViewportUnits == BrushMappingMode.RelativeToBoundingBox)
{
if (IsRenderVisible(bounds))
{
viewport.Scale(bounds.Width, bounds.Height);
viewport.Offset(bounds.Left, bounds.Top);
}
else
{
viewport = Rect.Empty;
}
}
return viewport;
}
///
/// Creates transformation from TileBrush viewbox to viewport, with stretching and alignment
/// taken into consideration.
///
///
/// Absolute TileBrush viewbox; must be visible
/// Absolute TileBrush viewport; must be visible
///
/// This can be used to get world-space bounds of TileBrush content.
///
public static Matrix CreateViewboxToViewportTransform(TileBrush brush, Rect viewbox, Rect viewport)
{
Debug.Assert(IsValidViewbox(viewbox, brush.Stretch != Stretch.None) &&
IsRenderVisible(viewport), "Invisible viewbox and/or viewport");
Matrix transform = Matrix.CreateTranslation(-viewbox.Left, -viewbox.Top);
// brush stretch
double scale;
switch (brush.Stretch)
{
case Stretch.Uniform:
scale = Math.Min(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height);
transform.Scale(scale, scale);
break;
case Stretch.Fill:
transform.Scale(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height);
break;
case Stretch.UniformToFill:
scale = Math.Max(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height);
transform.Scale(scale, scale);
break;
default:
// do nothing
break;
}
// brush alignment
{
Rect stretchedViewbox = viewbox;
stretchedViewbox.Transform(transform);
double dx = 0;
double dy = 0;
switch (brush.AlignmentX)
{
case AlignmentX.Left: dx = viewport.Left - stretchedViewbox.Left; break;
case AlignmentX.Center: dx = viewport.Left - stretchedViewbox.Left + (viewport.Width - stretchedViewbox.Width) / 2; break;
case AlignmentX.Right: dx = viewport.Right - stretchedViewbox.Right; break;
}
switch (brush.AlignmentY)
{
case AlignmentY.Top: dy = viewport.Top - stretchedViewbox.Top; break;
case AlignmentY.Center: dy = viewport.Top - stretchedViewbox.Top + (viewport.Height - stretchedViewbox.Height) / 2; break;
case AlignmentY.Bottom: dy = viewport.Bottom - stretchedViewbox.Bottom; break;
}
transform.Translate(dx, dy);
}
return transform;
}
///
/// Creates transformation from TileBrush viewbox to viewport, with stretching and alignment
/// taken into consideration.
///
/// Brush with absolute viewbox, viewport.
///
/// Creates transformation from TileBrush viewbox to viewport, with stretching and alignment
/// taken into consideration.
///
/// Brush with relative or absolute viewbox, viewport.
/// Brush fill bounds used to calculate absolute viewport if needed.
///
/// Critical - It calls critical internal function CriticalUriDiscoveryPermission
///
[SecurityCritical]
[FriendAccessAllowed]
public static Uri GetFontUri(GlyphTypeface typeface)
{
CodeAccessPermission discoveryPermission = typeface.CriticalUriDiscoveryPermission;
if (discoveryPermission != null)
{
discoveryPermission.Assert(); // BlessedAssert
}
try
{
return typeface.FontUri;
}
finally
{
if (discoveryPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
}
#endregion
#region Visual
///
/// Gets Visual transformation with offset included.
///
///
///
/// Visual rasterization pixel limit.
/// Rasterization is split into bands if it exceeds this limit.
///
private const int VisualRasterizeBandPixelLimit = 1600 * 1200;
///
/// Gets pixel dimensions of a bitmap given device-independent dimensions and DPI.
///
///
///
///
///
///
///
private static void GetBitmapPixelDimensions(
double width,
double height,
double dpiX,
double dpiY,
out int pixelWidth,
out int pixelHeight)
{
pixelWidth = (int)(width * dpiX / 96.0);
pixelHeight = (int)(height * dpiY / 96.0);
}
///
/// Gets rasterization bitmap information given a Visual's bounds.
///
///
/// Used to calculate world-space bounds to determine rasterization size
///
///
///
///
/// Returns false if bounds are invalid or too small for rasterization.
private static bool GetVisualRasterizationBitmapInfo(
Rect visualBounds,
Matrix visualToWorldTransformHint,
out double bitmapWidth,
out double bitmapHeight,
out double bitmapDpiX,
out double bitmapDpiY
)
{
bitmapWidth = -1;
bitmapHeight = -1;
bitmapDpiX = 0;
bitmapDpiY = 0;
if (!Utility.IsRenderVisible(visualBounds))
{
// visual bounds invalid
return false;
}
// estimate world bounds of visual to use as bitmap DPI
Rect approxWorldBounds = visualBounds;
approxWorldBounds.Transform(visualToWorldTransformHint);
bitmapDpiX = approxWorldBounds.Width / visualBounds.Width * Configuration.RasterizationDPI;
bitmapDpiY = approxWorldBounds.Height / visualBounds.Height * Configuration.RasterizationDPI;
// render only if pixel dimensions are > 0
bitmapWidth = visualBounds.Width;
bitmapHeight = visualBounds.Height;
int pixelWidth, pixelHeight;
GetBitmapPixelDimensions(bitmapWidth, bitmapHeight, bitmapDpiX, bitmapDpiY, out pixelWidth, out pixelHeight);
return (pixelWidth > 0 && pixelHeight > 0);
}
///
/// Rasterizes the specified bounds of a Visual to a bitmap.
///
///
/// Bounds to rectangle to rasterize.
///
///
///
///
///
///
///
/// Applies a bitmap effect to input, returning the output and any possible effect transformation.
///
///
///
///
///
/// Information on rendering a band of a Visual.
///
public struct RenderedVisualBand
{
public RenderedVisualBand(BitmapSource bitmap, Matrix bitmapToVisualTransform)
{
Bitmap = bitmap;
BitmapToVisualTransform = bitmapToVisualTransform;
}
///
/// Rasterized visual.
///
public BitmapSource Bitmap;
///
/// Transformation from bitmap to Visual/Drawing space.
///
public Matrix BitmapToVisualTransform;
}
///
/// Rasterizes a Visual in its entirety to a bitmap.
///
///
///
/// Used to calculate world-space bounds to determine rasterization size
///
///
/// Rasterizes a Drawing in its entirety to a bitmap.
///
///
///
/// Used to calculate world-space bounds to determine rasterization size
///
///
/// Rasterizes a Visual with bitmap effect to a bitmap.
///
///
///
/// Used to calculate world-space bounds to determine rasterization size
///
/// May be null
///
///
/// Returns true if Rect when rendered would be visible.
///
///
///
/// A rectangle is visible if it does not contain NaN, is finite, and has positive area.
///
/// Warning: Be careful when using to cull geometry. Ensure that the bounds you
/// are testing include the stroke, as it is possible to have visible output with
/// zero-area geometry and a pen.
///
public static bool IsRenderVisible(Rect rect)
{
bool result = false;
if (!rect.IsEmpty)
{
result = IsValid(rect) && IsFinite(rect) && rect.Width > 0 && rect.Height > 0;
}
return result;
}
///
/// Returns true if Rect is valid Viewbox
/// Viewbox is used for setup a transformation by design. When Stretch == None, it's not used for
/// source clipping, so viewbox can have zero height/width.
///
///
///
///
/// A rectangle is valid viewbox if it does not contain NaN, is finite, and has non negative width/height.
///
public static bool IsValidViewbox(Rect rect, bool hasStretch)
{
if (hasStretch)
{
return IsRenderVisible(rect);
}
else
{
return IsValid(rect) && IsFinite(rect) && rect.Width >= 0 && rect.Height >= 0;
}
}
public static bool IsRenderVisible(Point point)
{
return IsValid(point) && IsFinite(point);
}
public static bool IsRenderVisible(Size size)
{
return IsValid(size) && IsFinite(size) && size.Width > 0 && size.Height > 0;
}
public static bool IsRenderVisible(double value)
{
return IsValid(value) && IsFinite(value);
}
public static bool IsRenderVisible(DrawingGroup drawing)
{
if (Utility.IsTransparent(Utility.NormalizeOpacity(drawing.Opacity)))
return false;
if (drawing.Children == null || drawing.Children.Count == 0)
return false;
if (drawing.ClipGeometry != null && !Utility.IsRenderVisible(drawing.ClipGeometry.Bounds))
return false;
if (drawing.Transform != null && !Utility.IsValid(drawing.Transform.Value))
return false;
if (BrushProxy.IsEmpty(drawing.OpacityMask))
return false;
return true;
}
///
/// Returns true if the value is valid input.
///
///
///
/// Currently validity means the value is not NaN.
///
public static bool IsValid(double value)
{
return !double.IsNaN(value);
}
public static bool IsValid(Point point)
{
return !double.IsNaN(point.X) && !double.IsNaN(point.Y);
}
///
/// Returns true if Size is valid.
///
///
/// Empty size is treated as valid.
public static bool IsValid(Size size)
{
return !double.IsNaN(size.Width) && !double.IsNaN(size.Height);
}
///
/// Returns true if Rect is valid.
///
///
/// Empty rect is treated as valid.
public static bool IsValid(Rect rect)
{
return !double.IsNaN(rect.X) &&
!double.IsNaN(rect.Y) &&
!double.IsNaN(rect.Width) &&
!double.IsNaN(rect.Height);
}
///
/// Returns true if Matrix is valid.
///
///
///
/// Normalizes opacity/alpha value to [0, 1].
///
///
///
///
/// Normalizes color channels to [0, 1] if NaN or they exceed limits.
///
///
///
///
/// Normalizes if outside range, otherwise returns NaN if no normalization needed.
///
///
///
/// Normalizes Color so its components are in the range [0, 1].
///
///
///
/// Indicates if a debug header should be printed at the top of GDI output.
///
///
/// Accessed by GDIExporter!CGDIDevice.HrEndPage.
///
[FriendAccessAllowed]
public static bool DisplayPageDebugHeader
{
get
{
return Configuration.DisplayPageDebugHeader;
}
}
#if DEBUG
private static int _bitmapDumpIndex = 0;
///
/// Saves a bitmap dump to file bitmap#.png. Debug only.
///
///
private static void SaveBitmapDump(BitmapSource bitmap)
{
string filename = "bitmap" + _bitmapDumpIndex.ToString() + ".png";
_bitmapDumpIndex++;
BitmapEncoder encoder = new System.Windows.Media.Imaging.PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmap));
System.IO.Stream stream = new System.IO.FileStream(filename, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None);
encoder.Save(stream);
stream.Close();
}
#endif
#endregion
}
#region GeometryAnalyzer
///
/// Analyzes Geometry through StreamGeometryContext implementation.
///
internal class GeometryAnalyzer : CapacityStreamGeometryContext
{
#region Constructors
///
/// Constructs analyzer.
///
///
/// Non-null to test for rectangular geometry
private GeometryAnalyzer(Matrix transform, Rect? checkRectangular)
{
_transform = transform;
if (checkRectangular.HasValue)
{
Rect rect = checkRectangular.Value;
Debug.Assert(!rect.IsEmpty);
_rectDirection = TraversalDirection.None;
_rect = rect;
}
}
#endregion
#region Public Static Methods
///
/// Analyzes geometry for point count.
///
///
///
public static void Analyze(Geometry.PathGeometryData geometryData, out int estimatedPointCount)
{
GeometryAnalyzer analyzer = new GeometryAnalyzer(Matrix.Identity, null);
PathGeometry.ParsePathGeometryData(geometryData, analyzer);
analyzer.FinishAnalysis();
estimatedPointCount = analyzer.EstimatedPointCount;
}
///
/// Performs more complex analysis of geometry.
///
///
/// If not null, checks if geometry is the provided rectangle
/// Estimated number of points in geometry
/// True to indicate that geometry is guaranteed to be a rectangle
/// True to indicate that geometry is one line
///
/// A geometry with one closed figure containing one segment is considered to
/// have two line segments.
///
public static void Analyze(
Geometry.PathGeometryData geometryData,
Rect? checkRectangular,
out int estimatedPointCount,
out bool isRectangle,
out bool isLineSegment
)
{
Matrix transform = Matrix.Identity;
if (checkRectangular.HasValue)
{
// transform geometry to coordinate space of checkRectangular to allow for comparison
transform = System.Windows.Media.Composition.CompositionResourceManager.MIL_MATRIX3X2DToMatrix(
ref geometryData.Matrix
);
}
GeometryAnalyzer analyzer = new GeometryAnalyzer(transform, checkRectangular);
PathGeometry.ParsePathGeometryData(geometryData, analyzer);
analyzer.FinishAnalysis();
estimatedPointCount = analyzer.EstimatedPointCount;
isRectangle = analyzer.IsRectangle;
isLineSegment = analyzer.IsLineSegment;
}
#endregion
#region Private Fields
private int _count;
// transformation to apply to incoming geometry data; currently only used when checking rectangular
private Matrix _transform;
// Check if geometry is a rectangle when != Invalid.
// Rectangle checking can handle CW/CCW rectangles and intermediate points not at corners.
private TraversalDirection _rectDirection = TraversalDirection.Invalid;
private Rect _rect;
private Point _rectFirstPointUntransformed; // first point traversed, not transformed by _transform
private Point _rectLastPoint; // last point traversed, transformed
private int _rectCornerCount; // number of rectangle corners traversed
// Check if geometry is exactly one line segment.
private int _lineSegmentCount;
// Upper bound to GDI point count.
private int EstimatedPointCount
{
get
{
return _count;
}
}
// If true, geometry is guaranteed to be a rectangle.
private bool IsRectangle
{
get
{
return _rectDirection != TraversalDirection.Invalid;
}
}
///
/// If true, geometry is guaranteed to be a single line segment.
///
private bool IsLineSegment
{
get
{
return _lineSegmentCount == 1;
}
}
#endregion
#region Private Methods
///
/// Finishes geometry analysis. Call after PathGeometry.ParsePathGeometryData returns.
///
private void FinishAnalysis()
{
if (IsRectangle)
{
// traverse back to start point to finish rectangle check
CheckRectanglePoint(_rectFirstPointUntransformed);
if (_rectCornerCount != 4)
{
SetNotRectangle();
}
}
}
#endregion
#region Rectangle Checking Methods
///
/// Returns true if specified point is on a rectangle corner.
///
///
///
/// Starts rectangle checking with first point.
///
///
private void CheckRectangleStart(Point point)
{
_rectFirstPointUntransformed = point;
_rectLastPoint = _transform.Transform(point);
if (IsRectangleCorner(_rectLastPoint))
{
_rectCornerCount++;
}
}
///
/// Checks if geometry point is part of rectangle.
///
///
private void CheckRectanglePoint(Point point)
{
//
// The idea is to get direction we're walking the rectangle compared to last point.
// Direction changes imply we're at a corner, and a rectangle has 4 corners.
//
point = _transform.Transform(point);
TraversalDirection dir = GetDirection(point - _rectLastPoint);
if (dir != TraversalDirection.None &&
_rectDirection != TraversalDirection.None &&
dir != _rectDirection)
{
// direction change must occur at corner, and new direction must be perpendicular
// to old direction
if (IsRectangleCorner(point) && ArePerpendicularDirections(dir, _rectDirection))
{
_rectCornerCount++;
}
else
{
SetNotRectangle();
}
}
_rectDirection = dir;
_rectLastPoint = point;
}
///
/// Indicates geometry is not a rectangle.
///
private void SetNotRectangle()
{
_rectDirection = TraversalDirection.Invalid;
}
#endregion
#region Line Checking Methods
///
/// Adds another line segment count.
///
private void AddLineSegments(int count)
{
_lineSegmentCount += count;
}
///
/// Indicates geometry is not a single line segment.
///
private void SetNotLineSegment()
{
_lineSegmentCount = 2; // too many segments to be a single line segment
}
#endregion
#region Traversal Direction Members
private enum TraversalDirection
{
Right = 0, Down = 1, Left = 2, Up = 3,
Invalid, // geometry is not a rectangle
None, // no direction, point duplicates previous point or haven't reached 2nd point yet
FirstValid = Right,
LastValid = Up,
}
///
/// Given a vector, gets direction in which we're traversing the rectangle.
///
///
///
/// Returns true if travel directions are perpendicular.
///
///
///
/// points, bool isStroked, bool isSmoothJoin)
{
_count += points.Count;
if (IsRectangle)
{
for (int index = 0; index < points.Count && IsRectangle; index++)
{
CheckRectanglePoint(points[index]);
}
}
AddLineSegments(points.Count);
}
public override void PolyQuadraticBezierTo(IList points, bool isStroked, bool isSmoothJoin)
{
SetNotRectangle();
SetNotLineSegment();
_count += (points.Count + 1) / 2 * 3;
}
public override void PolyBezierTo(IList points, bool isStroked, bool isSmoothJoin)
{
SetNotRectangle();
SetNotLineSegment();
_count += (points.Count + 2) / 3 * 3;
}
public override void ArcTo(Point point, Size size, double rotationAngle, bool isLargeArc, SweepDirection sweepDirection, bool isStroked, bool isSmoothJoin)
{
SetNotRectangle();
SetNotLineSegment();
// An arc can be converted to a maxiumum of 4 Bezier segments, Check ArcToBezier in DrawingContextFlattener.cs
_count += 4 * 3;
}
internal override void SetClosedState(bool closed)
{
}
internal override void SetFigureCount(int figureCount)
{
if (figureCount != 1)
{
// assume more than one figure is not rectangle, not single line
SetNotRectangle();
SetNotLineSegment();
}
}
internal override void SetSegmentCount(int segmentCount)
{
if (segmentCount != 1)
{
SetNotLineSegment();
}
}
#endregion
}
#endregion
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MetabaseReader.cs
- DataGridViewTopRowAccessibleObject.cs
- ClientProxyGenerator.cs
- SqlDataSourceView.cs
- UpDownEvent.cs
- EmptyQuery.cs
- VectorAnimationUsingKeyFrames.cs
- PropertyItem.cs
- LayeredChannelFactory.cs
- TypeBuilderInstantiation.cs
- errorpatternmatcher.cs
- LocatorGroup.cs
- ImageInfo.cs
- BehaviorEditorPart.cs
- BinaryExpression.cs
- Helpers.cs
- ArrayWithOffset.cs
- ValidatedControlConverter.cs
- MatrixStack.cs
- ReachObjectContext.cs
- SettingsPropertyValueCollection.cs
- EntityParameterCollection.cs
- MouseEvent.cs
- DataControlFieldCell.cs
- WizardForm.cs
- ActiveXSite.cs
- StylusPointPropertyInfoDefaults.cs
- KeyEvent.cs
- SymmetricKeyWrap.cs
- Duration.cs
- WebBrowsableAttribute.cs
- HandleCollector.cs
- ColorConvertedBitmap.cs
- EventMappingSettingsCollection.cs
- UxThemeWrapper.cs
- SessionMode.cs
- WindowPatternIdentifiers.cs
- ISessionStateStore.cs
- X509SubjectKeyIdentifierClause.cs
- ExpressionTextBox.xaml.cs
- FormsAuthenticationModule.cs
- XmlSchemaAttributeGroup.cs
- ToolboxItemAttribute.cs
- SamlAttributeStatement.cs
- StyleCollection.cs
- ObjectCacheSettings.cs
- WebPartDisplayMode.cs
- VersionedStreamOwner.cs
- ComboBoxAutomationPeer.cs
- DurableTimerExtension.cs
- BrowserDefinition.cs
- ObjectStateEntryDbUpdatableDataRecord.cs
- ELinqQueryState.cs
- DataBindingCollectionConverter.cs
- ALinqExpressionVisitor.cs
- XmlSerializerFactory.cs
- MinMaxParagraphWidth.cs
- SystemException.cs
- RangeValidator.cs
- Queue.cs
- GuidConverter.cs
- DEREncoding.cs
- RichTextBox.cs
- DocumentPageViewAutomationPeer.cs
- InfoCardXmlSerializer.cs
- ValueProviderWrapper.cs
- DictionaryGlobals.cs
- PersistChildrenAttribute.cs
- AnonymousIdentificationSection.cs
- SetState.cs
- CustomValidator.cs
- SqlCaseSimplifier.cs
- SharedPerformanceCounter.cs
- ExpressionBuilder.cs
- AssociationSet.cs
- ErrorTableItemStyle.cs
- DoubleCollectionValueSerializer.cs
- BinaryFormatterWriter.cs
- mediapermission.cs
- MultiPageTextView.cs
- Helper.cs
- EnumDataContract.cs
- SqlCrossApplyToCrossJoin.cs
- StickyNote.cs
- DoubleKeyFrameCollection.cs
- EncodingTable.cs
- BaseParser.cs
- RSAPKCS1SignatureDeformatter.cs
- DataServiceConfiguration.cs
- XmlDocumentSurrogate.cs
- EventSetter.cs
- Publisher.cs
- StorageEntitySetMapping.cs
- QueryParameter.cs
- NetworkInformationPermission.cs
- SharedPersonalizationStateInfo.cs
- InspectionWorker.cs
- querybuilder.cs
- Coordinator.cs
- HtmlTableRow.cs