public async Task <IActionResult> Edit(int id, [Bind("Id,ParentId,Text")] Knots knots)
{
if (id != knots.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(knots);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!KnotsExists(knots.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(knots));
}
public void TestKnots()
{
// initialize value.
Knots ten = 10;
// convert from.
KilometerPerHour tenInKilometerPerHour = 18.52;
MeterPerSecond tenInMeterPerSecond = 5.14444444444;
MilesPerHour tenInMilesPerHour = 11.50779;
// test converts to.
Assert.AreEqual(ten.Value, ((Knots)tenInKilometerPerHour).Value, 0.000001);
Assert.AreEqual(ten.Value, ((Knots)tenInMeterPerSecond).Value, 0.000001);
Assert.AreEqual(ten.Value, ((Knots)tenInMilesPerHour).Value, 0.000001);
// tests division of distance with time resulting in speed.
Kilometer distance = ten * (Hour)2;
Assert.AreEqual(18.52 * 2.0, distance.Value);
// tests some parsing functions.
Knots tenPointFive = 10.5;
Knots tenPointFiveParsed;
Assert.IsTrue(Knots.TryParse(tenPointFive.ToString(), out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(Knots.TryParse("10.5", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(Knots.TryParse("10.5 knots", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsFalse(Knots.TryParse("10.5 m/s", out tenPointFiveParsed));
Assert.IsFalse(Knots.TryParse("10.5 mph", out tenPointFiveParsed));
Assert.IsFalse(Knots.TryParse("10.5 k/h", out tenPointFiveParsed));
}
public static bool TryParseSpeed(string s, out KilometerPerHour result)
{
result = (KilometerPerHour)double.MaxValue;
if (string.IsNullOrWhiteSpace(s) || (int)s[0] != 48 && (int)s[0] != 49 && ((int)s[0] != 50 && (int)s[0] != 51) && ((int)s[0] != 52 && (int)s[0] != 53 && ((int)s[0] != 54 && (int)s[0] != 55)) && ((int)s[0] != 56 && (int)s[0] != 57) || s.Contains(","))
{
return(false);
}
double result1;
if (double.TryParse(s, NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture, out result1))
{
result = (KilometerPerHour)result1;
}
if (KilometerPerHour.TryParse(s, out result))
{
return(true);
}
MilesPerHour result2;
if (MilesPerHour.TryParse(s, out result2))
{
result = (KilometerPerHour)result2;
return(true);
}
Knots result3;
if (!Knots.TryParse(s, out result3))
{
return(false);
}
result = (KilometerPerHour)result3;
return(true);
}
protected void SetValues(int splineOrder, IEnumerable <CgmPoint> points, IEnumerable <double> knots, double start, double end)
{
SplineOrder = splineOrder;
Points.AddRange(points);
Knots.AddRange(knots);
StartValue = start;
EndValue = end;
}
/// <summary>
/// Adds a knot to the end of the path.
/// </summary>
/// <param name="NewKnot">The knot to add</param>
public void AddKnot(Knot NewKnot)
{
// Add the knot to the end of the Knots list
Knots.Add(NewKnot);
// Regenerate the segments
GenerateSegments();
}
/// <summary>
/// Inserts a knot at the specified index in the path.
/// </summary>
/// <param name="Index">The index to insert the knot at.</param>
/// <param name="NewKnot">The knot to insert.</param>
public void InsertKnot(int Index, Knot NewKnot)
{
// Insert the new knot at the specified index
Knots.Insert(Index, NewKnot);
// Regenerate the segments
GenerateSegments();
}
/// <summary>
/// Removes the knot at the specified index.
/// </summary>
/// <param name="Index">The index of the knot to remove.</param>
public void RemoveKnot(int Index)
{
// Remove the knot at the specified index
Knots.RemoveAt(Index);
// Regenerate the segments
GenerateSegments();
}
//public int NewNo { get; set; }
// Display Info of the RFEM Objects on Panels
// Parameters are separated by ";". The component split text can be used to break the string down into a list.
public override string ToString()
{
return(string.Format($"RFEM-Line;No:{No};Length:{Length}[m];Type:{Type};NodeList:{((NodeList == "") ? "-" : NodeList)};" +
$"NodeCount:{NodeCount};Nodes:{ControlPoints.ToLabelString()};Tag:{((Tag == "") ? "-" : Tag)};" +
$"IsValid:{IsValid};IsGenerated:{IsGenerated};ID:{((ID == "") ? "-" : ID)};RotationAngle:{RotationAngle}[rad];" +
$"RotationHelpNodeNo:{RotationHelpNodeNo};RotationPlane:{RotationPlane};RotationType:{RotationType};" +
$"Order:{((Order == 0) ? "-" : Order.ToString())};" +
$"Weights:{(Weights.ToLabelString())};Knots:{(Knots.ToLabelString())};" +
$"ToModify:{ToModify};ToDelete:{ToDelete};Comment:{((Comment == "") ? "-" : Comment)};"));
}
/// <summary>
/// Tries to parse a speed value from a given tag-value.
/// </summary>
/// <param name="s"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool TryParseSpeed(string s, out KilometerPerHour result)
{
result = double.MaxValue;
if (string.IsNullOrWhiteSpace(s))
{
return(false);
}
if (s[0] != '0' && s[0] != '1' && s[0] != '2' && s[0] != '3' && s[0] != '4' &&
s[0] != '5' && s[0] != '6' && s[0] != '7' && s[0] != '8' && s[0] != '9')
{ // performance inprovement, quick negative answer.
return(false);
}
if (s.Contains(','))
{ // refuse comma as a decimal seperator or anywhere else in the number.
return(false);
}
// try regular speed: convention in OSM is km/h in this case.
double kmphDouble;
if (double.TryParse(s, NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out kmphDouble))
{
result = kmphDouble;
}
// try km/h
if (KilometerPerHour.TryParse(s, out result))
{
return(true);
}
// try mph.
MilesPerHour resultMph;
if (MilesPerHour.TryParse(s, out resultMph))
{
result = resultMph;
return(true);
}
// try knots.
Knots resultKnots;
if (Knots.TryParse(s, out resultKnots))
{
result = resultKnots;
return(true);
}
return(false);
}
public void FromX(XElement xe)
{
Closed = bool.Parse(xe.Attribute("Closed").Value);
Degree = 3;
ControlPoints.Clear();
foreach (var pt in xe.Element("ControlPoints").Elements())
{
ControlPoints.Add(XParser.Parse <Point2D>(pt));
}
Knots.FromX(xe.Element("Knots"));
}
public async Task <IActionResult> Create([Bind("Id,ParentId,Text")] Knots knots)
{
if (ModelState.IsValid)
{
_context.Add(knots);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(knots));
}
internal override IEnumerable <StepSyntax> GetParameters(StepWriter writer)
{
foreach (var parameter in base.GetParameters(writer))
{
yield return(parameter);
}
yield return(new StepSyntaxList(KnotMultiplicities.Select(m => new StepIntegerSyntax(m))));
yield return(new StepSyntaxList(Knots.Select(k => new StepRealSyntax(k))));
yield return(new StepEnumerationValueSyntax(GetKnotSpec(KnotSpec)));
}
/// <summary>
/// 获取参数对应点
/// </summary>
/// <param name="par">参数</param>
/// <returns>参数对应点</returns>
public Point2D GetPointAtParam(double par)
{
int span = Knots.FindSpan(par);
var nn = Knots.BasicFuns(span, par);
Point2D pt = new Point2D();
int id = span - Degree;
for (int i = 0; i <= Degree; i++)
{
pt += GetControlPointAt(id + i) * nn[i];
}
return(pt);
}
public void TestKilometerPerHour()
{
// initialize value.
KilometerPerHour ten = 10;
// convert from.
Knots tenInKnots = 5.39956803;
MeterPerSecond tenInMeterPerSecond = 2.77777777778;
MilesPerHour tenInMilesPerHour = 6.21371192;
// test converts to.
Assert.AreEqual(ten.Value, ((KilometerPerHour)tenInKnots).Value, 0.000001);
Assert.AreEqual(ten.Value, ((KilometerPerHour)tenInMeterPerSecond).Value, 0.000001);
Assert.AreEqual(ten.Value, ((KilometerPerHour)tenInMilesPerHour).Value, 0.000001);
// tests division of distance with time resulting in speed.
Kilometer twenty = ten * (Hour)2;
Assert.AreEqual(20, twenty.Value);
// tests some parsing functions.
KilometerPerHour tenPointFive = 10.5;
KilometerPerHour tenPointFiveParsed;
Assert.IsTrue(KilometerPerHour.TryParse(tenPointFive.ToString(), out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5 km/h", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5 kmh", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5 kph", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5 kmph", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5km/h", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5kmh", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5kph", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(KilometerPerHour.TryParse("10.5kmph", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsFalse(KilometerPerHour.TryParse("10.5 m/s", out tenPointFiveParsed));
Assert.IsFalse(KilometerPerHour.TryParse("10.5 mph", out tenPointFiveParsed));
Assert.IsFalse(KilometerPerHour.TryParse("10.5 knots", out tenPointFiveParsed));
}
public override string GetStepParameters()
{
var parameters = new List <string>();
parameters.Add(Degree != null ? Degree.ToStepValue() : "$");
parameters.Add(ControlPointsList != null ? ControlPointsList.ToStepValue() : "$");
parameters.Add(CurveForm != null ? CurveForm.ToStepValue() : "$");
parameters.Add(ClosedCurve != null ? ClosedCurve.ToStepValue() : "$");
parameters.Add(SelfIntersect != null ? SelfIntersect.ToStepValue() : "$");
parameters.Add(KnotMultiplicities != null ? KnotMultiplicities.ToStepValue() : "$");
parameters.Add(Knots != null ? Knots.ToStepValue() : "$");
parameters.Add(KnotSpec != null ? KnotSpec.ToStepValue() : "$");
return(string.Join(", ", parameters.ToArray()));
}
public override void SerializeBlock(SerializerObject s)
{
var blockOffset = s.CurrentPointer;
// Serialize data (always little endian)
s.DoEndian(R1Engine.Serialize.BinaryFile.Endian.Little, () =>
{
// Parse data
GameObjectsCount = s.Serialize <ushort>(GameObjectsCount, name: nameof(GameObjectsCount));
GameObjectsOffset = s.Serialize <ushort>(GameObjectsOffset, name: nameof(GameObjectsOffset));
KnotsHeight = s.Serialize <byte>(KnotsHeight, name: nameof(KnotsHeight));
KnotsWidth = s.Serialize <byte>(KnotsWidth, name: nameof(KnotsWidth));
KnotsOffset = s.Serialize <ushort>(KnotsOffset, name: nameof(KnotsOffset));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Timeout = s.Serialize <byte>(Timeout, name: nameof(Timeout));
Index_PlayField = s.Serialize <byte>(Index_PlayField, name: nameof(Index_PlayField));
IndexMin_ActorModels = s.Serialize <byte>(IndexMin_ActorModels, name: nameof(IndexMin_ActorModels));
IndexMax_ActorModels = s.Serialize <byte>(IndexMax_ActorModels, name: nameof(IndexMax_ActorModels));
ObjPalette = s.SerializeObjectArray <RGBA5551Color>(ObjPalette, 8 * 4, name: nameof(ObjPalette));
TilePalette = s.SerializeObjectArray <RGBA5551Color>(TilePalette, 8 * 4, name: nameof(TilePalette));
MainActor_0 = s.Serialize <ushort>(MainActor_0, name: nameof(MainActor_0));
MainActor_1 = s.Serialize <ushort>(MainActor_1, name: nameof(MainActor_1));
MainActor_2 = s.Serialize <ushort>(MainActor_2, name: nameof(MainActor_2));
Index_SoundBank = s.Serialize <byte>(Index_SoundBank, name: nameof(Index_SoundBank));
// TODO: Parse data (UnkActorStructs?)
UnknownData = s.SerializeArray <byte>(UnknownData, (blockOffset + GameObjectsOffset).AbsoluteOffset - s.CurrentPointer.AbsoluteOffset, name: nameof(UnknownData));
// Parse from pointers
GameObjects = s.DoAt(blockOffset + GameObjectsOffset, () => s.SerializeObjectArray <GBC_GameObject>(GameObjects, GameObjectsCount, name: nameof(GameObjects)));
Knots = s.DoAt(blockOffset + KnotsOffset, () => s.SerializeObjectArray <GBC_Knot>(Knots, KnotsHeight * KnotsWidth, name: nameof(Knots)));
s.Goto(Knots.Last().Offset + Knots.Last().ActorsCount * 2 + 1); // Go to end of the block
});
// Parse data from pointers
PlayField = s.DoAt(DependencyTable.GetPointer(Index_PlayField - 1), () => s.SerializeObject <GBC_PlayField>(PlayField, name: nameof(PlayField)));
SoundBank = s.DoAt(DependencyTable.GetPointer(Index_SoundBank - 1), () => s.SerializeObject <GBC_SoundBank>(SoundBank, name: nameof(SoundBank)));
// Parse actor models
foreach (var actor in GameObjects.Where(x => x.Index_ActorModel > 1))
{
actor.ActorModel = s.DoAt(DependencyTable.GetPointer(actor.Index_ActorModel - 1), () => s.SerializeObject <GBC_ActorModelBlock>(actor.ActorModel, name: $"{nameof(actor.ActorModel)}[{actor.Index_ActorModel}]"));
}
}
private void HashStep()
{
foreach (var length in ConvertedInput)
{
if (length > Knots.Count)
{
continue;
}
//Reverse
if (length != 1)
{
// Snap around list
if (Position + length > Knots.Count)
{
var lengthEnd = Knots.Count - Position;
var temp1 = Knots.GetRange(Position, lengthEnd);
temp1.AddRange(Knots.GetRange(0, length - lengthEnd));
temp1.Reverse();
Knots.RemoveRange(Position, lengthEnd);
Knots.InsertRange(Position, temp1.GetRange(0, lengthEnd));
temp1.RemoveRange(0, lengthEnd);
Knots.RemoveRange(0, length - lengthEnd);
Knots.InsertRange(0, temp1);
}
else
{
var temp = Knots.GetRange(Position, length);
temp.Reverse();
Knots.RemoveRange(Position, length);
Knots.InsertRange(Position, temp);
}
}
//Move
Position = (Position + length + SkipSize) % Knots.Count;
//Increase
SkipSize++;
}
}
public override void ReadFromBinary(IBinaryReader reader)
{
SplineOrder = reader.ReadInt();
var numberOfControlPoints = reader.ReadInt();
for (var i = 0; i < numberOfControlPoints; i++)
{
Points.Add(reader.ReadPoint());
}
for (var i = 0; i < numberOfControlPoints + SplineOrder; i++)
{
Knots.Add(reader.ReadReal());
}
StartValue = reader.ReadReal();
EndValue = reader.ReadReal();
}
public MarkGeometrySpline(
int flag,
int degree,
List <double> knotsIn,
List <MarkGeometryPoint> controlPointsIn,
List <MarkGeometryPoint> fitPointsIn
)
{
Degree = degree;
IsClosed = (flag == 1);
IsPeriodic = (flag == 2);
Knots.AddRange(knotsIn);
ControlPoints.AddRange(controlPointsIn);
FitPoints.AddRange(fitPointsIn);
// generate points
Points.AddRange(ApproximatePoints(3 * ControlPoints.Count));
Update();
}
public List <NurbsBase> SplitAt(double t)
{
int degree = Degree;
List <double> knotsToInsert = CollectionHelpers.RepeatData(t, degree + 1);
NurbsBase refinedCurve = Modify.Curve.KnotRefine(this, knotsToInsert);
int s = Knots.Span(degree, t);
KnotVector knots0 = refinedCurve.Knots.ToList().GetRange(0, s + degree + 2).ToKnot();
KnotVector knots1 = refinedCurve.Knots.GetRange(s + 1, refinedCurve.Knots.Count - (s + 1)).ToKnot();
List <Point4> controlPoints0 = refinedCurve.ControlPoints.GetRange(0, s + 1);
List <Point4> controlPoints1 = refinedCurve.ControlPoints.GetRange(s + 1, refinedCurve.ControlPointLocations.Count - (s + 1));
return(new List <NurbsBase> {
new NurbsCurve(degree, knots0, controlPoints0), new NurbsCurve(degree, knots1, controlPoints1)
});
}
public void ToX(XElement xe)
{
var closed = Closed;
if (GeoUtils.Equals(ControlPoints[0], ControlPoints[ControlPoints.Count - 1]))
{
closed = true;
}
xe.Add(new XAttribute("Closed", closed));
xe.Add(new XAttribute("Degree", Degree));
var controlPoints = new XElement("ControlPoints");
xe.Add(controlPoints);
foreach (var pt in ControlPoints)
{
controlPoints.Add(pt.ToX("Point"));
}
xe.Add(Knots.ToX());
}
/// <summary>
/// Check that all values in other are within epsilon of the values in this
/// </summary>
/// <param name="other"></param>
/// <param name="epsilon"></param>
/// <returns></returns>
public bool EpsilonEquals(NurbsCurve other, double epsilon)
{
if (null == other)
{
throw new ArgumentNullException("other");
}
if (ReferenceEquals(this, other))
{
return(true);
}
if (IsRational != other.IsRational)
{
return(false);
}
if (Degree != other.Degree)
{
return(false);
}
if (Points.Count != other.Points.Count)
{
return(false);
}
if (!Knots.EpsilonEquals(other.Knots, epsilon))
{
return(false);
}
if (!Points.EpsilonEquals(other.Points, epsilon))
{
return(false);
}
return(true);
}
public List <NurbsBase> SplitAt(double[] parameters)
{
var curves = new List <NurbsBase>();
if (parameters.Length == 0)
{
curves.Add(this);
return(curves);
}
var sortedParameters = parameters.OrderBy(x => x).ToArray();
Interval curveDomain = Knots.GetDomain(this.Degree);
if (Math.Abs(sortedParameters[0] - curveDomain.T0) > GSharkMath.MaxTolerance)
{
var tempParams = new double[sortedParameters.Length + 1];
tempParams[0] = curveDomain.T0;
for (var i = 0; i < sortedParameters.Length; i++)
{
tempParams[i + 1] = sortedParameters[i];
}
sortedParameters = tempParams;
}
if (Math.Abs(sortedParameters[sortedParameters.Length - 1] - curveDomain.T1) > GSharkMath.MaxTolerance)
{
Array.Resize(ref sortedParameters, sortedParameters.Length + 1);
sortedParameters[sortedParameters.Length - 1] = curveDomain.T1;
}
for (int i = 0; i < sortedParameters.Length - 1; i++)
{
curves.Add(SubCurve(new Interval(sortedParameters[i], sortedParameters[i + 1])));
}
return(curves);
}
public void TestMeterPerSecond()
{
// initialize value.
MeterPerSecond ten = 10;
// convert from.
Knots tenInKnots = 19.43844492440605;
KilometerPerHour tenInKilometerPerHour = 36;
MilesPerHour tenInMilesPerHour = 22.36936292054402;
// test converts to.
Assert.AreEqual(ten.Value, ((MeterPerSecond)tenInKnots).Value, 0.000001);
Assert.AreEqual(ten.Value, ((MeterPerSecond)tenInKilometerPerHour).Value, 0.000001);
Assert.AreEqual(ten.Value, ((MeterPerSecond)tenInMilesPerHour).Value, 0.000001);
// tests division of distance with time resulting in speed.
Kilometer twenty = ten * (Hour)2;
Assert.AreEqual(tenInKilometerPerHour.Value * 2.0, twenty.Value);
// tests some parsing functions.
MeterPerSecond tenPointFive = 10.5;
MeterPerSecond tenPointFiveParsed;
Assert.IsTrue(MeterPerSecond.TryParse(tenPointFive.ToString(), out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(MeterPerSecond.TryParse("10.5", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(MeterPerSecond.TryParse("10.5 m/s", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsTrue(MeterPerSecond.TryParse("10.5m/s", out tenPointFiveParsed));
Assert.AreEqual(tenPointFive.Value, tenPointFiveParsed.Value);
Assert.IsFalse(MeterPerSecond.TryParse("10.5 km/h", out tenPointFiveParsed));
Assert.IsFalse(MeterPerSecond.TryParse("10.5 mph", out tenPointFiveParsed));
Assert.IsFalse(MeterPerSecond.TryParse("10.5 knots", out tenPointFiveParsed));
}
public bool Equals(NurbsBase?other)
{
if (other == null)
{
return(false);
}
if (!ControlPointLocations.SequenceEqual(other.ControlPointLocations))
{
return(false);
}
if (!Knots.SequenceEqual(other.Knots))
{
return(false);
}
if (Degree != other.Degree)
{
return(false);
}
return(Weights.SequenceEqual(other.Weights));
}
internal override bool TrySetPair(DxfCodePair pair)
{
switch (pair.Code)
{
case 94:
Degree = pair.IntegerValue;
break;
case 73:
IsRational = BoolShort(pair.ShortValue);
break;
case 74:
IsPeriodic = BoolShort(pair.ShortValue);
break;
case 95:
var _knotCount = pair.IntegerValue;
break;
case 96:
var _controlPointCount = pair.IntegerValue;
break;
case 40:
Knots.Add(pair.DoubleValue);
break;
case 10:
ControlPoints.Add(new DxfControlPoint(new DxfPoint(pair.DoubleValue, 0.0, 0.0)));
break;
case 20:
ControlPoints[ControlPoints.Count - 1] = new DxfControlPoint(ControlPoints[ControlPoints.Count - 1].Point.WithUpdatedY(pair.DoubleValue));
break;
case 42:
ControlPoints[_currentWeight] = new DxfControlPoint(ControlPoints[_currentWeight].Point, pair.DoubleValue);
_currentWeight++;
break;
case 97:
var _fitPointCount = pair.IntegerValue;
break;
case 11:
FitPoints.Add(new DxfPoint(pair.DoubleValue, 0.0, 0.0));
break;
case 21:
FitPoints[FitPoints.Count - 1] = FitPoints[FitPoints.Count - 1].WithUpdatedY(pair.DoubleValue);
break;
case 12:
StartTangent = StartTangent.WithUpdatedX(pair.DoubleValue);
break;
case 22:
StartTangent = StartTangent.WithUpdatedY(pair.DoubleValue);
break;
case 13:
EndTangent = EndTangent.WithUpdatedX(pair.DoubleValue);
break;
case 23:
EndTangent = EndTangent.WithUpdatedY(pair.DoubleValue);
break;
default:
return(false);
}
return(true);
}
