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); }