public void GetPointAtFractionLength(
double progress,
out Point point,
out Point tangent)
{
if (IsEmpty())
{
point = new Point();
tangent = new Point();
return;
}
unsafe
{
PathGeometryData pathData = GetPathGeometryData();
fixed(byte *pbPathData = pathData.SerializedData)
{
Debug.Assert(pbPathData != (byte *)0);
HRESULT.Check(MilCoreApi.MilUtility_GetPointAtLengthFraction(
&pathData.Matrix,
pathData.FillRule,
pbPathData,
pathData.Size,
progress,
out point,
out tangent));
}
}
}
internal static IntersectionDetail HitTestWithPathGeometry(
Geometry geometry1,
Geometry geometry2,
double tolerance,
ToleranceType type)
{
IntersectionDetail detail = IntersectionDetail.NotCalculated;
unsafe
{
PathGeometryData data1 = geometry1.GetPathGeometryData();
PathGeometryData data2 = geometry2.GetPathGeometryData();
fixed(byte *pbPathData1 = data1.SerializedData)
{
Debug.Assert(pbPathData1 != (byte *)0);
fixed(byte *pbPathData2 = data2.SerializedData)
{
Debug.Assert(pbPathData2 != (byte *)0);
int hr = MilCoreApi.MilUtility_PathGeometryHitTestPathGeometry(
&data1.Matrix,
data1.FillRule,
pbPathData1,
data1.Size,
&data2.Matrix,
data2.FillRule,
pbPathData2,
data2.Size,
tolerance,
type == ToleranceType.Relative,
&detail);
if (hr == (int)MILErrors.WGXERR_BADNUMBER)
{
// When we encounter NaNs in the renderer, we absorb the error and draw
// nothing. To be consistent, we report that the geometry is never hittable.
detail = IntersectionDetail.Empty;
}
else
{
HRESULT.Check(hr);
}
}
}
}
Debug.Assert(detail != IntersectionDetail.NotCalculated);
return(detail);
}
public virtual double GetArea(double tolerance, ToleranceType type)
{
ReadPreamble();
if (IsObviouslyEmpty())
{
return(0);
}
PathGeometryData pathData = GetPathGeometryData();
if (pathData.IsEmpty())
{
return(0);
}
double area;
unsafe
{
// Call the core method on the path data
fixed(byte *pbPathData = pathData.SerializedData)
{
Debug.Assert(pbPathData != (byte *)0);
int hr = MilCoreApi.MilUtility_GeometryGetArea(
pathData.FillRule,
pbPathData,
pathData.Size,
&pathData.Matrix,
tolerance,
type == ToleranceType.Relative,
&area);
if (hr == (int)MILErrors.WGXERR_BADNUMBER)
{
// When we encounter NaNs in the renderer, we absorb the error and draw
// nothing. To be consistent, we report that the geometry has 0 area.
area = 0.0;
}
else
{
HRESULT.Check(hr);
}
}
}
return(area);
}
internal unsafe bool ContainsInternal(Pen pen, Point hitPoint, double tolerance, ToleranceType type,
Point *pPoints, uint pointCount, byte *pTypes, uint typeCount)
{
bool contains = false;
MilMatrix3x2D matrix = CompositionResourceManager.TransformToMilMatrix3x2D(Transform);
MIL_PEN_DATA penData;
double[] dashArray = null;
if (pen != null)
{
pen.GetBasicPenData(&penData, out dashArray);
}
fixed(double *dashArrayFixed = dashArray)
{
int hr = MilCoreApi.MilUtility_PolygonHitTest(
&matrix,
(pen == null) ? null : &penData,
dashArrayFixed,
pPoints,
pTypes,
pointCount,
typeCount,
tolerance,
type == ToleranceType.Relative,
&hitPoint,
out contains);
if (hr == (int)MILErrors.WGXERR_BADNUMBER)
{
// When we encounter NaNs in the renderer, we absorb the error and draw
// nothing. To be consistent, we report that the geometry is never hittable.
contains = false;
}
else
{
HRESULT.Check(hr);
}
}
return(contains);
}
internal virtual bool ContainsInternal(Pen pen, Point hitPoint, double tolerance, ToleranceType type)
{
if (IsObviouslyEmpty())
{
return(false);
}
PathGeometryData pathData = GetPathGeometryData();
if (pathData.IsEmpty())
{
return(false);
}
bool contains = false;
unsafe
{
MIL_PEN_DATA penData;
double[] dashArray = null;
// If we have a pen, populate the CMD struct
if (pen != null)
{
pen.GetBasicPenData(&penData, out dashArray);
}
fixed(byte *pbPathData = pathData.SerializedData)
{
Debug.Assert(pbPathData != (byte *)0);
fixed(double *dashArrayFixed = dashArray)
{
int hr = MilCoreApi.MilUtility_PathGeometryHitTest(
&pathData.Matrix,
(pen == null) ? null : &penData,
dashArrayFixed,
pathData.FillRule,
pbPathData,
pathData.Size,
tolerance,
type == ToleranceType.Relative,
&hitPoint,
out contains);
if (hr == (int)MILErrors.WGXERR_BADNUMBER)
{
// When we encounter NaNs in the renderer, we absorb the error and draw
// nothing. To be consistent, we report that the geometry is never hittable.
contains = false;
}
else
{
HRESULT.Check(hr);
}
}
}
}
return(contains);
}
internal unsafe static Rect GetBoundsHelper(
Pen pen,
Matrix *pWorldMatrix,
Point *pPoints,
byte *pTypes,
uint pointCount,
uint segmentCount,
Matrix *pGeometryMatrix,
double tolerance,
ToleranceType type,
bool fSkipHollows)
{
MIL_PEN_DATA penData;
double[] dashArray = null;
// If the pen contributes to the bounds, populate the CMD struct
bool fPenContributesToBounds = Pen.ContributesToBounds(pen);
if (fPenContributesToBounds)
{
pen.GetBasicPenData(&penData, out dashArray);
}
MilMatrix3x2D geometryMatrix;
if (pGeometryMatrix != null)
{
geometryMatrix = CompositionResourceManager.MatrixToMilMatrix3x2D(ref (*pGeometryMatrix));
}
Debug.Assert(pWorldMatrix != null);
MilMatrix3x2D worldMatrix =
CompositionResourceManager.MatrixToMilMatrix3x2D(ref (*pWorldMatrix));
Rect bounds;
fixed(double *pDashArray = dashArray)
{
int hr = MilCoreApi.MilUtility_PolygonBounds(
&worldMatrix,
(fPenContributesToBounds) ? &penData : null,
(dashArray == null) ? null : pDashArray,
pPoints,
pTypes,
pointCount,
segmentCount,
(pGeometryMatrix == null) ? null : &geometryMatrix,
tolerance,
type == ToleranceType.Relative,
fSkipHollows,
&bounds
);
if (hr == (int)MILErrors.WGXERR_BADNUMBER)
{
// When we encounter NaNs in the renderer, we absorb the error and draw
// nothing. To be consistent, we report that the geometry has empty bounds.
bounds = Rect.Empty;
}
else
{
HRESULT.Check(hr);
}
}
return(bounds);
}
