public bool SetAlarmTemp(double value, ToleranceType limit, int chanelNo)
{
if (value <= 0)
{
return(false);
}
if (limit == ToleranceType.High)
{
try
{
byte[] bytes = this.ModbusMaster.BuildWriteMessage(this.SlaveAddr, (ushort)(this.UpLimitAlarmAddr + chanelNo * 4), this.ConvertToWriteTemp(value));
this.EasySerialPort.SerialPort.DiscardInBuffer();
ByteData data = this.EasySerialPort.WriteAndGetReply(bytes, TimeSpan.FromSeconds(1));
return(true);
}
catch (Exception)
{
return(false);
}
}
else
{
try
{
byte[] bytes = this.ModbusMaster.BuildWriteMessage(this.SlaveAddr, (ushort)(this.DownLimitAlarmAddr + chanelNo * 4), this.ConvertToWriteTemp(value));
this.EasySerialPort.SerialPort.DiscardInBuffer();
ByteData data = this.EasySerialPort.WriteAndGetReply(bytes, TimeSpan.FromSeconds(1));
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public PIDController(double Kp, double Ki, double Kd, double Kf,
IPIDSource source, IPIDOutput output,
double period)
{
if (source == null)
throw new ArgumentNullException(nameof(source), "Null PIDSource was given");
if (output == null)
throw new ArgumentNullException(nameof(output), "Null PIDOutput was given");
m_controlLoop = new Notifier(CallCalculate, this);
m_P = Kp;
m_I = Ki;
m_D = Kd;
m_F = Kf;
m_ipidInput = source;
m_ipidOutput = output;
m_period = period;
m_controlLoop.StartPeriodic(m_period);
s_instances++;
HLUsageReporting.ReportPIDController(s_instances);
m_toleranceType = ToleranceType.NoTolerance;
}
public bool GetAlarmTemp(out double result, ToleranceType limit, int chanelNo)
{
try
{
if (limit == ToleranceType.High)
{
byte[] bytes = this.ModbusMaster.BuildReadMessage(this.SlaveAddr, (ushort)(this.UpLimitAlarmAddr + chanelNo * 4), 2);
this.EasySerialPort.SerialPort.DiscardInBuffer();
ByteData data = this.EasySerialPort.WriteAndGetReply(bytes, TimeSpan.FromSeconds(1));
string s1 = data.Bytes[3].ToString("X2");
string s2 = data.Bytes[4].ToString("X2");
result = Convert.ToInt32((s1 + s2), 16) * 0.1;
}
else
{
byte[] bytes = this.ModbusMaster.BuildReadMessage(this.SlaveAddr, (ushort)(this.DownLimitAlarmAddr + chanelNo * 4), 2);
this.EasySerialPort.SerialPort.DiscardInBuffer();
ByteData data = this.EasySerialPort.WriteAndGetReply(bytes, TimeSpan.FromSeconds(1));
string s1 = data.Bytes[3].ToString("X2");
string s2 = data.Bytes[4].ToString("X2");
result = Convert.ToInt32((s1 + s2), 16) * 0.1;
}
return(true);
}
catch (Exception)
{
result = 0;
return(false);
}
}
/// <summary>
/// Gets the bounds of this PathGeometry as an axis-aligned bounding box with pen and/or transform
/// </summary>
internal static Rect GetPathBounds(
PathGeometryData pathData,
Pen pen,
Matrix worldMatrix,
double tolerance,
ToleranceType type,
bool skipHollows)
{
if (pathData.IsEmpty())
{
return(Rect.Empty);
}
else
{
MilRectD bounds = PathGeometry.GetPathBoundsAsRB(
pathData,
pen,
worldMatrix,
tolerance,
type,
skipHollows);
return(bounds.AsRect);
}
}
/// <summary>
/// Creates a new PID object with the given contants for P, I, D and F.
/// </summary>
/// <param name="kp">The proportional coefficient.</param>
/// <param name="ki">The integral coefficient</param>
/// <param name="kd">The derivative coefficient</param>
/// <param name="kf">The feed forward term.</param>
/// <param name="source">The PIDSource object that is used to get values.</param>
/// <param name="output">The PIDOutput object that is set to the output percentage.</param>
/// <param name="period">The loop time for doing calculations.</param>
public PIDController(double kp, double ki, double kd, double kf,
IPIDSource source, IPIDOutput output,
double period)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source), "Null PIDSource was given");
}
if (output == null)
{
throw new ArgumentNullException(nameof(output), "Null PIDOutput was given");
}
CalculateCallback = Calculate;
m_controlLoop = new Notifier(CalculateCallback);
m_setpointTimer = new Timer();
m_setpointTimer.Start();
m_P = kp;
m_I = ki;
m_D = kd;
m_F = kf;
PIDInput = source;
PIDOutput = output;
m_period = period;
m_controlLoop.StartPeriodic(m_period);
s_instances++;
HAL.Base.HAL.Report(ResourceType.kResourceType_PIDController, (byte)s_instances);
m_toleranceType = ToleranceType.NoTolerance;
m_buf = new Queue <double>(m_bufLength + 1);
}
public bool SetAlarmTemp(double value, ToleranceType limit, int chanelNo)
{
if (value <= 0)
{
return(false);
}
try
{
byte[] bytes = null;
if (limit == ToleranceType.High)
{
bytes = this.ModbusMaster.BuildWriteMessage(this.AddressSlave, this.AddrUpperAlarm, this.ConvertToWriteTemp(value));
}
else
{
bytes = this.ModbusMaster.BuildWriteMessage(this.AddressSlave, this.AddrLowerAlarm, this.ConvertToWriteTemp(value));
}
this.EasySerialPort.SerialPort.DiscardInBuffer();
ByteData data = this.EasySerialPort.WriteAndGetReply(bytes, TimeSpan.FromSeconds(1));
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
ReadPreamble();
if (IsEmpty())
{
return(0.0);
}
double radiusX = RadiusX;
double radiusY = RadiusY;
Rect rect = Rect;
// Get the area of the bounding rectangle
double area = Math.Abs(rect.Width * rect.Height);
// correct it for the rounded corners
area -= Math.Abs(radiusX * radiusY) * (4.0 - Math.PI);
// Adjust to internal transformation
Transform transform = Transform;
if (!transform.IsIdentity)
{
area *= Math.Abs(transform.Value.Determinant);
}
return(area);
}
/// <summary>
/// Returns the axis-aligned bounding rectangle when stroked with a pen.
/// </summary>
/// <param name="pen">The pen</param>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
public virtual Rect GetRenderBounds(Pen pen, double tolerance, ToleranceType type)
{
ReadPreamble();
Matrix matrix = Matrix.Identity;
return(GetBoundsInternal(pen, matrix, tolerance, type));
}
/// <summary>
/// Sets the absolute error which is considered tolerable for use with <see cref="OnTarget"/>.
/// </summary>
/// <remarks>The value is in the same range as the PIDInput values.</remarks>
/// <param name="absTolerance">The absolute tolerance.</param>
public void SetAbsoluteTolerance(double absTolerance)
{
lock (m_lockObject)
{
m_toleranceType = ToleranceType.AbsoluteTolerance;
m_tolerance = absTolerance;
}
}
/// <summary>
/// Set the percentage error which is considered tolerable for use with <see cref="OnTarget"/>.
/// </summary>
/// <param name="percent">The percent tolerance.</param>
public void SetPercentTolerance(double percent)
{
lock (m_lockObject)
{
m_toleranceType = ToleranceType.PercentTolerance;
m_tolerance = percent;
}
}
/// <summary>
/// Serializes this instance
/// </summary>
internal void Serialize(XmlWriter writer)
{
switch (ToleranceType)
{
case ToleranceType.Circular when CircularToleranceRadius.HasValue:
writer.WriteAttributeString("Type", ToleranceType.ToString());
writer.WriteAttributeString("Radius", XmlConvert.ToString(CircularToleranceRadius.Value));
break;
case ToleranceType.Rectangular:
writer.WriteAttributeString("Type", ToleranceType.ToString());
if (RectangleToleranceHeight.HasValue)
{
writer.WriteAttributeString("Height", XmlConvert.ToString(RectangleToleranceHeight.Value));
}
if (RectangleToleranceWidth.HasValue)
{
writer.WriteAttributeString("Width", XmlConvert.ToString(RectangleToleranceWidth.Value));
}
break;
case ToleranceType.Spatial:
writer.WriteAttributeString("Type", ToleranceType.ToString());
if (SpatialTolerance != null)
{
writer.WriteAttributeString("X", XmlConvert.ToString(SpatialTolerance.X));
writer.WriteAttributeString("Y", XmlConvert.ToString(SpatialTolerance.Y));
writer.WriteAttributeString("Z", XmlConvert.ToString(SpatialTolerance.Z));
}
break;
case ToleranceType.Default:
if (IsSymmetric)
{
if (Upper != null && Lower != null)
{
writer.WriteValue(XmlConvert.ToString(Upper.Value - Lower.Value));
}
}
else
{
if (Lower.HasValue)
{
writer.WriteElementString("Lower", XmlConvert.ToString(Lower.Value));
}
if (Upper.HasValue)
{
writer.WriteElementString("Upper", XmlConvert.ToString(Upper.Value));
}
}
break;
}
}
/// <summary>
/// Returns true if point is inside the stroke of a pen on this geometry.
/// </summary>
/// <param name="pen">The pen used to define the stroke</param>
/// <param name="hitPoint">The point tested for containment</param>
/// <param name="tolerance">Acceptable margin of error in distance computation</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
public bool StrokeContains(Pen pen, Point hitPoint, double tolerance, ToleranceType type)
{
if (pen == null)
{
return(false);
}
return(ContainsInternal(pen, hitPoint, tolerance, type));
}
/// <summary>
/// Returns the result of a Boolean combination of two Geometry objects.
/// </summary>
/// <param name="geometry1">The first Geometry object</param>
/// <param name="geometry2">The second Geometry object</param>
/// <param name="mode">The mode in which the objects will be combined</param>
/// <param name="transform">A transformation to apply to the result, or null</param>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
public static PathGeometry Combine(
Geometry geometry1,
Geometry geometry2,
GeometryCombineMode mode,
Transform transform,
double tolerance,
ToleranceType type)
{
return(PathGeometry.InternalCombine(geometry1, geometry2, mode, transform, tolerance, type));
}
public virtual PathGeometry GetOutlinedPathGeometry(double tolerance, ToleranceType type)
{
ReadPreamble();
if (IsObviouslyEmpty())
{
return(new PathGeometry());
}
PathGeometryData pathData = GetPathGeometryData();
if (pathData.IsEmpty())
{
return(new PathGeometry());
}
PathGeometry resultGeometry = null;
unsafe
{
fixed(byte *pbPathData = pathData.SerializedData)
{
Invariant.Assert(pbPathData != (byte *)0);
FillRule fillRule = FillRule.Nonzero;
PathGeometry.FigureList list = new PathGeometry.FigureList();
int hr = UnsafeNativeMethods.MilCoreApi.MilUtility_PathGeometryOutline(
&pathData.Matrix,
pathData.FillRule,
pbPathData,
pathData.Size,
tolerance,
type == ToleranceType.Relative,
new PathGeometry.AddFigureToListDelegate(list.AddFigureToList),
out fillRule);
if (hr == (int)MILErrors.WGXERR_BADNUMBER)
{
// When we encounter NaNs in the renderer, we absorb the error and draw
// nothing. To be consistent, we return an empty geometry.
resultGeometry = new PathGeometry();
}
else
{
HRESULT.Check(hr);
resultGeometry = new PathGeometry(list.Figures, fillRule, null);
}
}
}
return(resultGeometry);
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - realtive or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
ReadPreamble();
// Potential speedup, to be done if proved important: As the result of a Combine
// operation, the result of GetAsPathGeometry() is guaranteed to be organized into
// flattened well oriented figures. Its area can therefore be computed much faster
// without the heavy machinary of CArea. This will require writing an internal
// CShapeBase::GetRawArea method, and a utility to invoke it. For now:
return(GetAsPathGeometry().GetArea(tolerance, type));
}
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);
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - realtive or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
ReadPreamble();
double area = Math.Abs(RadiusX * RadiusY) * Math.PI;
// Adjust to internal transformation
Transform transform = Transform;
if (transform != null && !transform.IsIdentity)
{
area *= Math.Abs(transform.Value.Determinant);
}
return(area);
}
/// <summary>
/// Approximate this figure with a polygonal PathFigure
/// </summary>
/// <param name="tolerance">The approximation error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
/// <returns>Returns the polygonal approximation as a PathFigure.</returns>
public PathFigure GetFlattenedPathFigure(double tolerance, ToleranceType type)
{
PathGeometry geometry = new PathGeometry();
geometry.Figures.Add(this);
PathGeometry flattenedGeometry = geometry.GetFlattenedPathGeometry(tolerance, type);
int count = flattenedGeometry.Figures.Count;
if (count == 0)
{
return new PathFigure();
}
else if (count == 1)
{
return flattenedGeometry.Figures[0];
}
else
{
throw new InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
}
/// <summary>
/// Approximate this figure with a polygonal PathFigure
/// </summary>
/// <param name="tolerance">The approximation error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
/// <returns>Returns the polygonal approximation as a PathFigure.</returns>
public PathFigure GetFlattenedPathFigure(double tolerance, ToleranceType type)
{
PathGeometry geometry = new PathGeometry();
geometry.Figures.Add(this);
PathGeometry flattenedGeometry = geometry.GetFlattenedPathGeometry(tolerance, type);
int count = flattenedGeometry.Figures.Count;
if (count == 0)
{
return(new PathFigure());
}
else if (count == 1)
{
return(flattenedGeometry.Figures[0]);
}
else
{
throw new InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
}
internal override bool ContainsInternal(Pen pen, Point hitPoint, double tolerance, ToleranceType type)
{
unsafe
{
Point *pPoints = stackalloc Point[(int)GetPointCount()];
EllipseGeometry.GetPointList(pPoints, GetPointCount(), Center, RadiusX, RadiusY);
fixed(byte *pTypes = GetTypeList())
{
return(ContainsInternal(
pen,
hitPoint,
tolerance,
type,
pPoints,
GetPointCount(),
pTypes,
GetSegmentCount()));
}
}
}
/// <summary>
/// Returns the axis-aligned bounding rectangle when stroked with a pen, after applying
/// the supplied transform (if non-null).
/// </summary>
internal override Rect GetBoundsInternal(Pen pen, Matrix matrix, double tolerance, ToleranceType type)
{
Matrix geometryMatrix;
Transform.GetTransformValue(Transform, out geometryMatrix);
return(EllipseGeometry.GetBoundsHelper(
pen,
matrix,
Center,
RadiusX,
RadiusY,
geometryMatrix,
tolerance,
type));
}
/// <summary>
/// Creates a new tolerance given a unit, value, and whether the tolerance is ±
/// </summary>
/// <param name="unit">The units for this tolerance</param>
/// <param name="value">The numerical value of the tolerance</param>
/// <param name="type">Whether the tolerance is full or half width</param>
public Tolerance(ToleranceUnit unit, double value, ToleranceType type = ToleranceType.PlusAndMinus)
{
Unit = unit;
Value = value;
Type = type;
}
public virtual new double GetArea(double tolerance, ToleranceType type)
{
return default(double);
}
public bool FillContains(Geometry geometry, double tolerance, ToleranceType type)
{
return default(bool);
}
public static PathGeometry Combine(Geometry geometry1, Geometry geometry2, GeometryCombineMode mode, Transform transform, double tolerance, ToleranceType type)
{
return default(PathGeometry);
}
public bool StrokeContains(Pen pen, System.Windows.Point hitPoint, double tolerance, ToleranceType type)
{
return default(bool);
}
public Tolerance(ToleranceUnit unit, double experimental, double theoretical, ToleranceType type = ToleranceType.PlusAndMinus)
: this(unit, GetTolerance(experimental, theoretical, unit), type)
{
}
public Tolerance(ToleranceUnit unit, double value, ToleranceType type = ToleranceType.PlusAndMinus)
{
Unit = unit;
Value = value;
Type = type;
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
return 0.0;
}
/// <summary>
/// Returns the axis-aligned bounding rectangle when stroked with a pen, after applying
/// the supplied transform (if non-null).
/// </summary>
internal override Rect GetBoundsInternal(Pen pen, Matrix worldMatrix, double tolerance, ToleranceType type)
{
Matrix geometryMatrix;
Transform.GetTransformValue(Transform, out geometryMatrix);
return LineGeometry.GetBoundsHelper(
pen,
worldMatrix,
StartPoint,
EndPoint,
geometryMatrix,
tolerance,
type);
}
/// <summary>
/// Set the percentage error which is considered tolerable for use with <see cref="OnTarget"/>.
/// </summary>
/// <param name="percent">The percent tolerance.</param>
public void SetPercentTolerance(double percent)
{
lock (m_lockObject)
{
m_toleranceType = ToleranceType.PercentTolerance;
m_tolerance = percent;
}
}
/// <summary>
/// Sets the absolute error which is considered tolerable for use with <see cref="OnTarget"/>.
/// </summary>
/// <remarks>The value is in the same range as the PIDInput values.</remarks>
/// <param name="absTolerance">The absolute tolerance.</param>
public void SetAbsoluteTolerance(double absTolerance)
{
lock (m_lockObject)
{
m_toleranceType = ToleranceType.AbsoluteTolerance;
m_tolerance = absTolerance;
}
}
/// <summary>
/// Creates a new PID object with the given contants for P, I, D and F.
/// </summary>
/// <param name="kp">The proportional coefficient.</param>
/// <param name="ki">The integral coefficient</param>
/// <param name="kd">The derivative coefficient</param>
/// <param name="kf">The feed forward term.</param>
/// <param name="source">The PIDSource object that is used to get values.</param>
/// <param name="output">The PIDOutput object that is set to the output percentage.</param>
/// <param name="period">The loop time for doing calculations.</param>
public PIDController(double kp, double ki, double kd, double kf,
IPIDSource source, IPIDOutput output,
double period)
{
if (source == null)
throw new ArgumentNullException(nameof(source), "Null PIDSource was given");
if (output == null)
throw new ArgumentNullException(nameof(output), "Null PIDOutput was given");
CalculateCallback = Calculate;
m_controlLoop = new Notifier(CalculateCallback);
m_setpointTimer = new Timer();
m_setpointTimer.Start();
m_P = kp;
m_I = ki;
m_D = kd;
m_F = kf;
PIDInput = source;
PIDOutput = output;
m_period = period;
m_controlLoop.StartPeriodic(m_period);
s_instances++;
HLUsageReporting.ReportPIDController(s_instances);
m_toleranceType = ToleranceType.NoTolerance;
m_buf = new Queue<double>();
}
public virtual new PathGeometry GetWidenedPathGeometry(Pen pen, double tolerance, ToleranceType type)
{
return default(PathGeometry);
}
/// <summary>
/// Returns the axis-aligned bounding rectangle when stroked with a pen, after applying
/// the supplied transform (if non-null).
/// </summary>
internal override Rect GetBoundsInternal(Pen pen, Matrix matrix, double tolerance, ToleranceType type)
{
Matrix geometryMatrix;
Transform.GetTransformValue(Transform, out geometryMatrix);
return EllipseGeometry.GetBoundsHelper(
pen,
matrix,
Center,
RadiusX,
RadiusY,
geometryMatrix,
tolerance,
type);
}
public IntersectionDetail StrokeContainsWithDetail(Pen pen, Geometry geometry, double tolerance, ToleranceType type)
{
return default(IntersectionDetail);
}
internal override bool ContainsInternal(Pen pen, Point hitPoint, double tolerance, ToleranceType type)
{
unsafe
{
Point *pPoints = stackalloc Point[(int)GetPointCount()];
EllipseGeometry.GetPointList(pPoints, GetPointCount(), Center, RadiusX, RadiusY);
fixed (byte* pTypes = GetTypeList())
{
return ContainsInternal(
pen,
hitPoint,
tolerance,
type,
pPoints,
GetPointCount(),
pTypes,
GetSegmentCount());
}
}
}
public bool FillContains(System.Windows.Point hitPoint, double tolerance, ToleranceType type)
{
return default(bool);
}
/// <summary>Creates a new <see cref="ExitCondition"/> object.
/// </summary>
/// <param name="maxIterations">The maximal number of iterations.</param>
/// <param name="maxEvaluations">The maximal number of function evaluations.</param>
/// <param name="tolerance">The tolerance to take into account as exit condition; or <see cref="System.Double.NaN"/>.</param>
/// <param name="toleranceType">A value indicating how to interprete <paramref name="tolerance"/>.</param>
/// <returns>A specific <see cref="ExitCondition"/> object.</returns>
public static ExitCondition Create(int maxIterations, int maxEvaluations = Int32.MaxValue, double tolerance = Double.NaN, ToleranceType toleranceType = ToleranceType.None)
{
return(new ExitCondition(maxIterations, maxEvaluations, tolerance, toleranceType));
}
public virtual new IntersectionDetail FillContainsWithDetail(Geometry geometry, double tolerance, ToleranceType type)
{
return default(IntersectionDetail);
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
return(0.0);
}
public static Tolerance FromPPM(double value, ToleranceType toleranceType = ToleranceType.PlusAndMinus)
{
return new Tolerance(ToleranceUnit.PPM, value, toleranceType);
}
/// <summary>
/// Returns the axis-aligned bounding rectangle when stroked with a pen, after applying
/// the supplied transform (if non-null).
/// </summary>
internal override Rect GetBoundsInternal(Pen pen, Matrix worldMatrix, double tolerance, ToleranceType type)
{
Matrix geometryMatrix;
Transform.GetTransformValue(Transform, out geometryMatrix);
return(LineGeometry.GetBoundsHelper(
pen,
worldMatrix,
StartPoint,
EndPoint,
geometryMatrix,
tolerance,
type));
}
/// <summary>
/// Creates a new tolerance given a unit, two points (one experimental and one theoretical), and whether the tolerance is ±
/// </summary>
/// <param name="unit">The units for this tolerance</param>
/// <param name="experimental">The experimental value</param>
/// <param name="theoretical">The theoretical value</param>
/// <param name="type">Whether the tolerance is full or half width</param>
public Tolerance(ToleranceUnit unit, double experimental, double theoretical, ToleranceType type = ToleranceType.PlusAndMinus)
: this(unit, GetTolerance(experimental, theoretical, unit), type)
{
}
public virtual new PathGeometry GetOutlinedPathGeometry(double tolerance, ToleranceType type)
{
return default(PathGeometry);
}
internal static Rect GetBoundsHelper(Pen pen, Matrix worldMatrix, Point center, double radiusX, double radiusY,
Matrix geometryMatrix, double tolerance, ToleranceType type)
{
Rect rect;
Debug.Assert(worldMatrix != null);
Debug.Assert(geometryMatrix != null);
if ((pen == null || pen.DoesNotContainGaps) &&
worldMatrix.IsIdentity && geometryMatrix.IsIdentity)
{
double strokeThickness = 0.0;
if (Pen.ContributesToBounds(pen))
{
strokeThickness = Math.Abs(pen.Thickness);
}
rect = new Rect(
center.X - Math.Abs(radiusX) - 0.5 * strokeThickness,
center.Y - Math.Abs(radiusY) - 0.5 * strokeThickness,
2.0 * Math.Abs(radiusX) + strokeThickness,
2.0 * Math.Abs(radiusY) + strokeThickness);
}
else
{
unsafe
{
Point *pPoints = stackalloc Point[(int)c_pointCount];
EllipseGeometry.GetPointList(pPoints, c_pointCount, center, radiusX, radiusY);
fixed(byte *pTypes = EllipseGeometry.s_roundedPathTypes)
{
rect = Geometry.GetBoundsHelper(
pen,
&worldMatrix,
pPoints,
pTypes,
c_pointCount,
c_segmentCount,
&geometryMatrix,
tolerance,
type,
false); // skip hollows - meaningless here, this is never a hollow
}
}
}
return(rect);
}
public virtual new System.Windows.Rect GetRenderBounds(Pen pen, double tolerance, ToleranceType type)
{
return default(System.Windows.Rect);
}
/// <summary>
/// Gets the bounds of this Geometry as an axis-aligned bounding box given a Pen and/or Transform
/// </summary>
internal override Rect GetBoundsInternal(Pen pen, Matrix matrix, double tolerance, ToleranceType type)
{
if (IsObviouslyEmpty())
{
return Rect.Empty;
}
return GetAsPathGeometry().GetBoundsInternal(pen, matrix, tolerance, type);
}
public override double GetArea (double flatteningTolerance, ToleranceType tolerance)
{
throw new NotImplementedException ();
}
public static Tolerance FromMMU(double value, ToleranceType toleranceType = ToleranceType.PlusAndMinus)
{
return(new Tolerance(ToleranceUnit.MMU, value, toleranceType));
}
/// <summary>
/// Returns if point is inside the filled geometry.
/// </summary>
internal override bool ContainsInternal(Pen pen, Point hitPoint, double tolerance, ToleranceType type)
{
if (pen == null)
{
ReadPreamble();
// Hit the two operands
bool hit1 = false;
bool hit2 = false;
Transform transform = Transform;
if (transform != null && !transform.IsIdentity)
{
// Inverse-transform the hit point
Matrix matrix = transform.Value;
if (matrix.HasInverse)
{
matrix.Invert();
hitPoint *= matrix;
}
else
{
// The matrix will collapse the geometry to nothing, containing nothing
return false;
}
}
Geometry geometry1 = Geometry1;
Geometry geometry2 = Geometry2;
if (geometry1 != null)
{
hit1 = geometry1.ContainsInternal(pen, hitPoint, tolerance, type);
}
if (geometry2 != null)
{
hit2 = geometry2.ContainsInternal(pen, hitPoint, tolerance, type);
}
// Determine containment according to the theoretical definition
switch (GeometryCombineMode)
{
case GeometryCombineMode.Union:
return hit1 || hit2;
case GeometryCombineMode.Intersect:
return hit1 && hit2;
case GeometryCombineMode.Exclude:
return hit1 && !hit2;
case GeometryCombineMode.Xor:
return hit1 != hit2;
}
// We should have returned from one of the cases
Debug.Assert(false);
return false;
}
else
{
// pen != null
return base.ContainsInternal(pen, hitPoint, tolerance, type);
}
}
public override double GetArea(double tolerance, ToleranceType type)
{
return default(double);
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - realtive or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
ReadPreamble();
// Potential speedup, to be done if proved important: As the result of a Combine
// operation, the result of GetAsPathGeometry() is guaranteed to be organized into
// flattened well oriented figures. Its area can therefore be computed much faster
// without the heavy machinary of CArea. This will require writing an internal
// CShapeBase::GetRawArea method, and a utility to invoke it. For now:
return GetAsPathGeometry().GetArea(tolerance, type);
}
internal static Rect GetBoundsHelper(Pen pen, Matrix worldMatrix, Point center, double radiusX, double radiusY,
Matrix geometryMatrix, double tolerance, ToleranceType type)
{
Rect rect;
Debug.Assert(worldMatrix != null);
Debug.Assert(geometryMatrix != null);
if ( (pen == null || pen.DoesNotContainGaps) &&
worldMatrix.IsIdentity && geometryMatrix.IsIdentity)
{
double strokeThickness = 0.0;
if (Pen.ContributesToBounds(pen))
{
strokeThickness = Math.Abs(pen.Thickness);
}
rect = new Rect(
center.X - Math.Abs(radiusX)-0.5*strokeThickness,
center.Y - Math.Abs(radiusY)-0.5*strokeThickness,
2.0 * Math.Abs(radiusX)+strokeThickness,
2.0 * Math.Abs(radiusY)+strokeThickness);
}
else
{
unsafe
{
Point * pPoints = stackalloc Point[(int)c_pointCount];
EllipseGeometry.GetPointList(pPoints, c_pointCount, center, radiusX, radiusY);
fixed (byte *pTypes = EllipseGeometry.s_roundedPathTypes)
{
rect = Geometry.GetBoundsHelper(
pen,
&worldMatrix,
pPoints,
pTypes,
c_pointCount,
c_segmentCount,
&geometryMatrix,
tolerance,
type,
false); // skip hollows - meaningless here, this is never a hollow
}
}
}
return rect;
}
public virtual Rect GetRenderBounds(Pen pen, double tolerance, ToleranceType type)
{
return this.PlatformImpl.GetRenderBounds(pen, tolerance, type);
}
/// <summary>
/// Gets the area of this geometry
/// </summary>
/// <param name="tolerance">The computational error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - realtive or absolute</param>
public override double GetArea(double tolerance, ToleranceType type)
{
ReadPreamble();
double area = Math.Abs(RadiusX * RadiusY) * Math.PI;
// Adjust to internal transformation
Transform transform = Transform;
if (transform != null && !transform.IsIdentity)
{
area *= Math.Abs(transform.Value.Determinant);
}
return area;
}
internal static Rect GetBoundsHelper(Pen pen, Matrix worldMatrix, Point pt1, Point pt2,
Matrix geometryMatrix, double tolerance, ToleranceType type)
{
Debug.Assert(worldMatrix != null);
Debug.Assert(geometryMatrix != null);
if (pen == null && worldMatrix.IsIdentity && geometryMatrix.IsIdentity)
{
return(new Rect(pt1, pt2));
}
else
{
unsafe
{
Point *pPoints = stackalloc Point[2];
pPoints[0] = pt1;
pPoints[1] = pt2;
fixed(byte *pTypes = LineGeometry.s_lineTypes)
{
return(Geometry.GetBoundsHelper(
pen,
&worldMatrix,
pPoints,
pTypes,
c_pointCount,
c_segmentCount,
&geometryMatrix,
tolerance,
type,
false)); // skip hollows - meaningless here, this is never a hollow
}
}
}
}
/// <summary>Initializes a new instance of the <see cref="ExitCondition"/> class.
/// </summary>
/// <param name="maxIterations">The maximal number of iterations.</param>
/// <param name="maxEvaluations">The maximal number of function evaluations.</param>
/// <param name="tolerance">The tolerance to take into account as exit condition; or <see cref="System.Double.NaN"/>.</param>
/// <param name="toleranceType">A value indicating how to interprete <paramref name="tolerance"/>.</param>
protected ExitCondition(int maxIterations, int maxEvaluations = Int32.MaxValue, double tolerance = Double.NaN, ToleranceType toleranceType = ToleranceType.None)
{
MaxIterations = maxIterations;
MaxEvaluations = maxEvaluations;
switch (toleranceType)
{
case ToleranceType.WithinAbsoluteTolerance:
m_AbsoluteTolerance = tolerance;
m_RelativeTolerance = Double.NaN;
break;
case ToleranceType.WithinRelativeTolerance:
m_RelativeTolerance = tolerance;
m_AbsoluteTolerance = Double.NaN;
break;
default:
m_AbsoluteTolerance = m_RelativeTolerance = Double.NaN;
break;
}
}
internal override bool ContainsInternal(Pen pen, Point hitPoint, double tolerance, ToleranceType type)
{
unsafe
{
Point *pPoints = stackalloc Point[2];
pPoints[0] = StartPoint;
pPoints[1] = EndPoint;
fixed(byte *pTypes = GetTypeList())
{
return(ContainsInternal(
pen,
hitPoint,
tolerance,
type,
pPoints,
GetPointCount(),
pTypes,
GetSegmentCount()));
}
}
}
