public static Version GetFileFormatVersion(FormplotTypes formplotType)
{
return(formplotType switch
{
FormplotTypes.None => new Version(1, 0),
FormplotTypes.Defect => new Version(3, 0),
_ => new Version(2, 0),
});
/// <summary>
/// Gets the current file format version of a specific <see cref="FormplotTypes"/>.
/// </summary>
internal static Version GetFileFormatVersion(FormplotTypes formplotType)
{
switch (formplotType)
{
case FormplotTypes.None:
return(new Version(1, 0));
default:
return(new Version(2, 0));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Formplot"/> class.
/// </summary>
/// <param name="formplotType">Type of the formplot.</param>
protected Formplot(FormplotTypes formplotType)
{
FormplotType = formplotType;
GeometryType = Geometry.GetGeometryTypeFromFormplotType(formplotType);
if (GeometryType != GeometryTypes.None)
{
_Nominal = Geometry.Create(GeometryType);
_Actual = Geometry.Create(GeometryType);
}
}
/// <summary>
/// Creates a formplot with the specified type.
/// </summary>
/// <param name="type">The formplot type.</param>
/// <returns></returns>
private static Formplot CreateFormplot(FormplotTypes type)
{
switch (type)
{
case FormplotTypes.None:
return(new EmptyPlot());
case FormplotTypes.Roundness:
return(new RoundnessPlot());
case FormplotTypes.Flatness:
return(new FlatnessPlot());
case FormplotTypes.CurveProfile:
return(new CurveProfilePlot());
case FormplotTypes.Straightness:
return(new StraightnessPlot());
case FormplotTypes.Cylindricity:
return(new CylindricityPlot());
case FormplotTypes.Pitch:
return(new PitchPlot());
case FormplotTypes.BorePattern:
return(new BorePatternPlot());
case FormplotTypes.CircleInProfile:
return(new CircleInProfilePlot());
case FormplotTypes.Fourier:
return(new FourierPlot());
case FormplotTypes.FlushGap:
return(new FlushGapPlot());
case FormplotTypes.Defect:
return(new DefectPlot());
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
private static Formplot CreateFormplot(Stream?pointDataStream, Version version, FormplotTypes formplotType, XmlReader reader)
{
return(formplotType switch
{
FormplotTypes.None => Deserialize <EmptyPlot, EmptyPoint, EmptyGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Roundness => Deserialize <RoundnessPlot, CirclePoint, CircleGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Flatness => Deserialize <FlatnessPlot, PlanePoint, PlaneGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.CurveProfile => Deserialize <CurveProfilePlot, CurvePoint, CurveGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Straightness => Deserialize <StraightnessPlot, LinePoint, LineGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Cylindricity => Deserialize <CylindricityPlot, CylinderPoint, CylinderGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Pitch => Deserialize <PitchPlot, PitchPoint, PitchGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.BorePattern => Deserialize <BorePatternPlot, CurvePoint, CurveGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.CircleInProfile => Deserialize <CircleInProfilePlot, CircleInProfilePoint, CircleInProfileGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Fourier => Deserialize <FourierPlot, FourierPoint, EmptyGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.FlushGap => Deserialize <FlushGapPlot, FlushGapPoint, FlushGapGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Defect => Deserialize <DefectPlot, Defect, DefectGeometry>(reader, pointDataStream, formplotType, version),
FormplotTypes.Fillet => Deserialize <FilletPlot, FilletPoint, FilletGeometry>(reader, pointDataStream, formplotType, version),
_ => throw new NotSupportedException($"Invalid form plot file. The plot with type {formplotType} is not supported.")
});
/// <summary>Constructor.</summary>
protected Formplot(FormplotTypes formplotType)
{
FormplotType = formplotType;
OriginalFormplotType = formplotType;
}
/// <summary>
/// Reads the points from the specified <see cref="Stream"/> and collects their specifications, such as type, tolerance, segment and metadata.
/// </summary>
/// <param name="formplotType">Type of the formplot.</param>
/// <param name="metadataReader">The metadata reader.</param>
/// <param name="pointdataStream">The pointdata stream.</param>
/// <returns></returns>
private static Point[] ReadPoints(FormplotTypes formplotType, XmlReader metadataReader, Stream pointdataStream)
{
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
if (pointdataStream == null)
{
throw new ArgumentNullException(nameof(pointdataStream));
}
var count = 0;
var propertyLists = new Dictionary <Property, RangeList>();
var statelists = new Dictionary <PointState, RangeList>();
var segmentlists = new Dictionary <Segment, RangeList>();
var tolerancelists = new Dictionary <Tolerance, RangeList>();
while (metadataReader.Read() && metadataReader.NodeType != XmlNodeType.EndElement)
{
if (metadataReader.IsEmptyElement)
{
continue;
}
switch (metadataReader.Name)
{
case "Count":
count = XmlConvert.ToInt32(metadataReader.ReadString());
break;
case "Properties":
while (metadataReader.Read() && metadataReader.NodeType != XmlNodeType.EndElement)
{
switch (metadataReader.Name)
{
case "Property":
var points = RangeList.TryParseOrEmpty(metadataReader.GetAttribute("Points"));
var property = Property.Deserialize(metadataReader);
propertyLists[property] = points;
break;
}
}
break;
case "States":
while (metadataReader.Read() && metadataReader.NodeType != XmlNodeType.EndElement)
{
switch (metadataReader.Name)
{
case "State":
var points = RangeList.TryParseOrEmpty(metadataReader.GetAttribute("Points"));
var text = metadataReader.ReadString();
var value = ( PointState )Enum.Parse(typeof(PointState), text);
statelists[value] = points;
break;
}
}
break;
case "Segments":
while (metadataReader.Read() && metadataReader.NodeType != XmlNodeType.EndElement)
{
switch (metadataReader.Name)
{
case "Segment":
var points = RangeList.TryParseOrEmpty(metadataReader.GetAttribute("Points"));
var typeString = metadataReader.GetAttribute("Type");
SegmentTypes type;
Enum.TryParse(typeString, out type);
var name = metadataReader.ReadString();
var segment = new Segment(name, type);
segmentlists[segment] = points;
break;
}
}
break;
case "Tolerances":
var isTolerancesElement = false;
while (metadataReader.NodeType != XmlNodeType.EndElement || !isTolerancesElement)
{
if (metadataReader.NodeType == XmlNodeType.Element && metadataReader.Name.Equals("Tolerance"))
{
var points = RangeList.TryParseOrEmpty(metadataReader.GetAttribute("Points"));
var tolerance = Tolerance.Deserialize(metadataReader);
tolerancelists[tolerance] = points;
metadataReader.Read();
}
else
{
metadataReader.Read();
}
isTolerancesElement = metadataReader.Name.Equals("Tolerances");
}
break;
}
}
var result = new List <Point>();
for (var index = 0; index < count; index++)
{
var point = Point.Create(formplotType);
point.ReadFromStream(pointdataStream, index);
result.Add(point);
}
SetProperties(propertyLists, result);
SetStates(statelists, result);
SetSegment(segmentlists, result);
SetTolerance(tolerancelists, result);
return(result.ToArray());
}
