private static void Main(string[] args) { TestVoxelization(); //TS_Testing_Functions.TestModify(); //TVGL3Dto2DTests.TestSilhouette(); // Polygon_Testing_Functions.TestSimplify(); //TS_Testing_Functions.TestClassify(); //TVGL3Dto2DTests.TestXSectionAndMonotoneTriangulate(); #if PRESENT // 1. bubble up from the bin directories to find the TestFiles directory var polysValue = TestCases.MakeBumpyRings(50, 28, 1.8); //var polysValue = TestCases.EdgeCases["tinyOffsetProb"]; var polygon1 = new Polygon(polysValue.Item1); var polygon2 = new Polygon(polysValue.Item2); //Presenter.ShowAndHang(new[] { polygon1, polygon2 }); var polygons = polygon1.Union(polygon2); var polygon = polygons.LargestPolygon(); Presenter.ShowAndHang(polygon); polygon.Transform(Matrix3x3.CreateRotation(1)); Presenter.ShowAndHang(polygon); //var polygons = new List<Polygon> { polygon1 }; //var coords1 = TestCases.MakeStarryCircularPolygon(50, 28, 1.8).ToList(); //var hole1 = TestCases.MakeStarryCircularPolygon(80, 14, 1.5).ToList(); //hole1.Reverse(); //var polygon1 = new Polygon(coords1); //polygon1 = polygon1.Intersect(new Polygon(hole1))[0]; //Presenter.ShowAndHang(polygons); //var polygon1 = new Polygon(coords1, true); // Presenter.ShowAndHang(polygon1); //var polygons3 = polygon1.OffsetRound(88); var offsetBase = Math.Sqrt(polygons.LargestPolygon().Area); var factors = new[] { -.03, 0.03, -.1, 0.1, -.3, 0.3, -1, 1, -3, 3, -10 }; foreach (var factor in factors) { var offset = factor * offsetBase; var polygons3 = polygons[0].OffsetRound(offset, 0.00254); Presenter.ShowAndHang(polygons3); } #else //#endif //PolygonBooleanTester.FullComparison(); //var stats = new List<(string, int, long, long)>(); //foreach (var testCase in TestCases.GetAllTwoArgumentEdgeCases()) //{ // var polys = testCase.Value; // PolygonBooleanTester.SingleCompare(stats, TestCases.C2Poly(polys.Item1), TestCases.C2Poly(polys.Item2), // TestCases.C2PLs(polys.Item1), TestCases.C2PLs(polys.Item2)); //} #endif //var summary = BenchmarkRunner.Run(typeof(PolygonBooleanTester).Assembly); //PolygonOperationsTesting.DebugEdgeCases("nestedSquares"); //PolygonOperationsTesting.TestRemoveSelfIntersect(); //PolygonOperationsTesting.DebugEdgeCases(); //PolygonOperationsTesting.DebugOctagons(); //PolygonOperationsTesting.TestUnionSimple(); }
public string ApplyUserReset(Object2D realUser, Object2D virtualUser, Vector2 resetDirection) { //float ratio = 2; float rotationSpeed = 60.0f; if (isFirst) { initialAngle = Vector2.SignedAngle(realUser.transform.forward, resetDirection); realTargetRotation = Matrix3x3.CreateRotation(initialAngle) * realUser.transform.forward; //virtualTargetRotation = Matrix3x3.CreateRotation(ratio * targetAngle) * virtualUser.transform.forward; freeze-turn when user reset isFirst = false; maxRotTime = Mathf.Abs(initialAngle) / rotationSpeed; //Debug.Log(maxRotTime); remainRotTime = 0; } float realAngle = Vector2.SignedAngle(realUser.transform.forward, realTargetRotation); if (remainRotTime < maxRotTime) { //Debug.Log(remainRotTime); realUser.Rotate(Mathf.Sign(initialAngle) * rotationSpeed * Time.fixedDeltaTime); //virtualUser.Rotate(ratio * rotationSpeed * Time.fixedDeltaTime); remainRotTime += Time.fixedDeltaTime; } else { SyncDirection(realUser, resetDirection); //Debug.Log("SYNC"); //Utility.SyncDirection(virtualUser, realUser, virtualTargetRotation, realTargetRotation); //realUser.transform.position = realUser.transform.position + realUser.transform.forward * 0.1f; //if (realUser.gameObject != null) realUser.gameObject.transform.position = Utility.Cast2Dto3D(realUser.transform.position); //Utility.SyncPosition(virtualUser, realUser, virtualUser.transform.localPosition, newRealPosition); //bool isNeedReset = NeedWallReset(realUser, realSpace); //Debug.Log(virtualUser.transform); //Debug.Log(realUser.transform); ////Debug.Log(virtualUser.gameObject.transform.localPosition); ////Debug.Log(realUser.gameObject.transform.localPosition); //Debug.Log(isNeedReset); //realUser.transform.position = realUser.transform.position + realUser.transform.forward * 0.1f; // 다시 리셋 상태에 빠지는 것을 방지 isFirst = true; return("DONE"); //episode.DeleteTarget(); //isFirst = true; //isFirst2 = true; } return("NOT_YET"); }
public void GetBoundingRectangle_ShouldReturnMinimalAxisAlignedRectangleContainingThisRectangle_WhenRectangleIsNotAxisAligned() { // Arrange var rectangle = new Rectangle(new Vector2(4, 2), new Vector2(10, 6)) .Transform(Matrix3x3.CreateRotation(Angle.Deg2Rad(30))); // Act var boundingRectangle = rectangle.GetBoundingRectangle(); // Assert Assert.That(boundingRectangle.Center, Is.EqualTo(new Vector2(2.464101, 3.732050)).Using(Vector2Comparer)); Assert.That(boundingRectangle.Dimensions, Is.EqualTo(new Vector2(11.660254, 10.196152)).Using(Vector2Comparer)); }
public void Translate(Vector2 translation, Space relativeTo = Space.Self) { if (relativeTo == Space.World) { Vector2 newPosition = this.position + translation; this.position = newPosition; } else if (relativeTo == Space.Self) { Matrix3x3 rotationMatrix = Matrix3x3.CreateRotation(this.localRotation); Vector2 newPosition = this.localPosition + rotationMatrix * translation; this.localPosition = newPosition; } }
public void Width_Test(double centerX, double centerY, double width, double height, double rotation, double expectedWidth) { // Arrange var center = new Vector2(centerX, centerY); var dimensions = new Vector2(width, height); var rectangle = new Rectangle(center, dimensions).Transform(Matrix3x3.CreateRotation(Angle.Deg2Rad(rotation))); // Act var actualWidth = rectangle.Width; // Assert Assert.That(actualWidth, Is.EqualTo(expectedWidth)); }
private static IShape CreateRectangle(Vector2 center, Vector2 dimension, double rotation = 0, Axis[]?axes = null) { var rot = Matrix3x3.CreateRotation(Angle.Deg2Rad(rotation)); var shape = CreatePolygon( (rot * new Vector2(-dimension.X / 2, -dimension.Y / 2).Homogeneous).ToVector2() + new Vector2(center.X, center.Y), (rot * new Vector2(+dimension.X / 2, -dimension.Y / 2).Homogeneous).ToVector2() + new Vector2(center.X, center.Y), (rot * new Vector2(+dimension.X / 2, +dimension.Y / 2).Homogeneous).ToVector2() + new Vector2(center.X, center.Y), (rot * new Vector2(-dimension.X / 2, +dimension.Y / 2).Homogeneous).ToVector2() + new Vector2(center.X, center.Y) ); shape.GetAxes().Returns(axes ?? Array.Empty <Axis>()); return(shape); }
/// <summary> /// Creates view matrix that converts coordinates from 2D space to the screen space as seen by camera. /// </summary> /// <param name="cameraEntity">Entity with camera component attached.</param> /// <returns>View matrix that converts coordinates from 2D space to the screen space as seen by camera.</returns> public static Matrix3x3 Create2DWorldToScreenMatrix(this Entity cameraEntity) { if (!cameraEntity.HasComponent <CameraComponent>()) { throw new ArgumentException("Entity is not a camera."); } var cameraTransform = cameraEntity.GetComponent <Transform2DComponent>(); var cameraScale = cameraTransform.Scale; var viewRectangleScale = GetViewRectangleScale(cameraEntity); var finalCameraScale = new Vector2(cameraScale.X * viewRectangleScale.X, cameraScale.Y * viewRectangleScale.Y); return(Matrix3x3.CreateScale(new Vector2(1 / finalCameraScale.X, 1 / finalCameraScale.Y)) * Matrix3x3.CreateRotation(-cameraTransform.Rotation) * Matrix3x3.CreateTranslation(-cameraTransform.Translation) * Matrix3x3.Identity); }
//public RandomEpisode(Space2D virtualSpace, int episodeLength) : base(virtualSpace, episodeLength) { } protected override void GenerateEpisode(Transform2D virtualUserTransform, Space2D virtualSpace) { Vector2 samplingPosition = Vector2.zero; Vector2 userPosition = virtualUserTransform.localPosition; do { float angle = Utility.sampleUniform(-180.0f, 180.0f); float distance = Utility.sampleUniform(2.0f, 5.0f); Vector2 sampleForward = Matrix3x3.CreateRotation(angle) * virtualUserTransform.forward; //Vector3 sampleForward = Quaternion.AngleAxis(angle, Vector3.up) * simulationController.GetUserVirtualTransform().forward; samplingPosition = userPosition + sampleForward * distance; // local 좌표계에서 절대 위치 기준 } while (!virtualSpace.IsInside(samplingPosition, 0.1f)); // while (!virtualSpace.IsReallyInside(userPosition, samplingPosition)); currentTargetPosition = samplingPosition; }
public void Center_Test(double centerX, double centerY, double width, double height, double rotation) { // Arrange var center = new Vector2(centerX, centerY); var dimensions = new Vector2(width, height); // We want to rotate around center of rectangle thus we need to transform by center after rotation. // ReSharper disable once CompareOfFloatsByEqualityOperator var rectangle = rotation == 0 ? new Rectangle(center, dimensions) : new Rectangle(dimensions).Transform(Matrix3x3.CreateRotation(Angle.Deg2Rad(rotation))).Transform(Matrix3x3.CreateTranslation(center)); // Act var actualCenter = rectangle.Center; // Assert Assert.That(actualCenter, Is.EqualTo(center).Using(Vector2Comparer)); }
public override string ApplyReset(Object2D realUser, Object2D virtualUser, Space2D realSpace, string resetType) { if (isFirst) { realTargetRotation = Matrix3x3.CreateRotation(targetAngle) * realUser.transform.forward; virtualTargetRotation = Matrix3x3.CreateRotation(ratio * targetAngle) * virtualUser.transform.forward; isFirst = false; } float realAngle = Vector2.SignedAngle(realUser.transform.forward, realTargetRotation); if (Mathf.Abs(realAngle) >= epsilonRotation) { realUser.Rotate(rotationSpeed * Time.deltaTime); virtualUser.Rotate(ratio * rotationSpeed * Time.deltaTime); } else { Utility.SyncDirection(virtualUser, realUser, virtualTargetRotation, realTargetRotation); switch (resetType) { case "Wall": while (NeedWallReset(realUser, realSpace)) { CalculationErrorAdjustment(realUser.transform, resetType, (Polygon2D)realSpace.space); } break; case "User": break; } if (realUser.gameObject != null) { realUser.gameObject.transform.position = Utility.Cast2Dto3D(realUser.transform.position); } isFirst = true; return("DONE"); } return("NOT_YET"); }
public void CreateRotation(double angle, double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33) { // Arrange // Act var rotationMatrix = Matrix3x3.CreateRotation(angle); // Assert Assert.That(rotationMatrix.M11, Is.EqualTo(m11)); Assert.That(rotationMatrix.M12, Is.EqualTo(m12)); Assert.That(rotationMatrix.M13, Is.EqualTo(m13)); Assert.That(rotationMatrix.M21, Is.EqualTo(m21)); Assert.That(rotationMatrix.M22, Is.EqualTo(m22)); Assert.That(rotationMatrix.M23, Is.EqualTo(m23)); Assert.That(rotationMatrix.M31, Is.EqualTo(m31)); Assert.That(rotationMatrix.M32, Is.EqualTo(m32)); Assert.That(rotationMatrix.M33, Is.EqualTo(m33)); }
public static GridData3D <VoxelInfo> Rotate(GridData3D <VoxelInfo> source, Vector3 axis, float radiant) { int width = 0; int height = 0; int length = 0; GridData3D <VoxelInfo> result = new GridData3D <VoxelInfo>(width, height, length); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { for (int z = 0; z < length; z++) { Vector3 afterPos = new Vector3(x, y, z); Vector3 beforePos = Matrix3x3.DotProduct(Matrix3x3.CreateRotation(axis, -radiant), afterPos); VoxelInfo v = source.GetDataAt((int)beforePos.x, (int)beforePos.y, (int)beforePos.z); } } } return(result); }
private static (List <Vector2> points, List <bool> knownWrongPoints) MainOffsetRoutine(Polygon polygon, double offset, bool notMiter, double maxLengthSquared, double tolerance, out int maxNumberOfPolygons, double deltaAngle = double.NaN) { maxNumberOfPolygons = 1; // set up the return list (predict size to prevent re-allocation) and rotation matrix for OffsetRound var numPoints = polygon.Edges.Length; int numFalsesToAdd; var startingListSize = numPoints; var roundCorners = !double.IsNaN(deltaAngle); if (roundCorners) { startingListSize += (int)(2 * Math.PI / deltaAngle); } var offsetSign = Math.Sign(offset); var rotMatrix = roundCorners ? Matrix3x3.CreateRotation(offsetSign * deltaAngle) : Matrix3x3.Null; if (notMiter && !roundCorners) { startingListSize = (int)(1.5 * startingListSize); } var pointsList = new List <Vector2>(startingListSize); var wrongPoints = new List <bool>(startingListSize); // previous line starts at the end of the list and then updates to whatever next line was. In addition to the previous line, we // also want to capture the unit vector pointing outward (which is in the {Y, -X} direction). The prevLineLengthReciprocal was originally // thought to have uses outside of the unit vector but it doesn't. Anyway, slight speed up in calculating it once var prevLine = polygon.Edges[0]; var prevLineLengthReciprocal = 1.0 / prevLine.Length; var prevUnitNormal = new Vector2(prevLine.Vector.Y * prevLineLengthReciprocal, -prevLine.Vector.X * prevLineLengthReciprocal); for (int i = 1; i <= numPoints; i++) { var nextLine = (i == numPoints) ? polygon.Edges[0] : polygon.Edges[i]; var nextLineLengthReciprocal = 1.0 / nextLine.Length; var nextUnitNormal = new Vector2(nextLine.Vector.Y * nextLineLengthReciprocal, -nextLine.Vector.X * nextLineLengthReciprocal); // establish the new offset points for the point connecting prevLine to nextLive. this is stored as "point". var point = nextLine.FromPoint.Coordinates; var cross = prevLine.Vector.Cross(nextLine.Vector); var dot = prevLine.Vector.Dot(nextLine.Vector); // cross/dot is the tan(angle). both dot and cross are quicker than square-root or trigonometric functions // and essentially tan(angle) * offset will be the distance between two points emanating from the polygons edges at // this point. If it is less than the tolerance, then just make one point - it doesn't matter if offset is negative/positive // or if angle is convex or concave. Oh, the 100 is added to account for problems that arise when intersections weren't detected if ((cross * offset / dot).IsNegligible(100 * tolerance)) { if (prevUnitNormal.Dot(nextUnitNormal) > 0) { // if line is practically straight, and going the same direction, then simply offset it without all the complication below pointsList.Add(point + offset * prevUnitNormal); } else { pointsList.Add(point); } } // if the cross is positive and the offset is positive (or there both negative), then we will need to make extra points // let's start with the roundCorners else if (cross * offset > 0) { if ((polygon.IsPositive && offset < 0) || (!polygon.IsPositive && offset > 0)) { maxNumberOfPolygons++; } if (roundCorners) { var firstPoint = point + offset * prevUnitNormal; pointsList.Add(firstPoint); var lastPoint = point + offset * nextUnitNormal; var firstToLastVector = lastPoint - firstPoint; var firstToLastNormal = new Vector2(firstToLastVector.Y, -firstToLastVector.X); // to avoid "costly" call to Math.Sin and Math.Cos, we create the transform matrix that 1) translates to origin // 2) rotates by the angle, and 3) translates back var transform = Matrix3x3.CreateTranslation(-point) * rotMatrix * Matrix3x3.CreateTranslation(point); var nextPoint = firstPoint.Transform(transform); // the challenge with this matrix transform is figuring out when to stop. But we know that all the new points must to on // positive side of the line connecting the first and last points. This is defined by the following dot-product while (offsetSign * firstToLastNormal.Dot(nextPoint - lastPoint) > 0) { pointsList.Add(nextPoint); firstPoint = nextPoint; nextPoint = firstPoint.Transform(transform); } pointsList.Add(lastPoint); } // if the cross is positive and the offset is positive, then we will need to make extra points for the // squaredCorners else if (notMiter) { // find these two points by calling the LineLine2DIntersection function twice. var middleUnitVector = (prevUnitNormal + nextUnitNormal).Normalize(); var middlePoint = point + offset * middleUnitVector; var middleDir = new Vector2(-middleUnitVector.Y, middleUnitVector.X); pointsList.Add(MiscFunctions.LineLine2DIntersection(point + offset * prevUnitNormal, prevLine.Vector, middlePoint, middleDir)); pointsList.Add(MiscFunctions.LineLine2DIntersection(middlePoint, middleDir, point + offset * nextUnitNormal, nextLine.Vector)); } // miter and concave connections are done the same way... else { var intersection = MiscFunctions.LineLine2DIntersection(point + offset * prevUnitNormal, prevLine.Vector, point + offset * nextUnitNormal, nextLine.Vector); // if the corner is too shape the new point will be placed far away (near infinity). This is to rein it in var vectorToCorner = intersection - point; var vectorToCornerLengthSquared = vectorToCorner.LengthSquared(); if (vectorToCornerLengthSquared > maxLengthSquared) { intersection = point + vectorToCorner * Math.Sqrt(maxLengthSquared / vectorToCornerLengthSquared); } pointsList.Add(intersection); } } else { numFalsesToAdd = pointsList.Count - wrongPoints.Count; for (int k = 0; k < numFalsesToAdd; k++) { wrongPoints.Add(false); } wrongPoints.Add(true); wrongPoints.Add(true); pointsList.Add(point + offset * prevUnitNormal); pointsList.Add(point + offset * nextUnitNormal); } prevLine = nextLine; prevUnitNormal = nextUnitNormal; } numFalsesToAdd = pointsList.Count - wrongPoints.Count; for (int k = 0; k < numFalsesToAdd; k++) { wrongPoints.Add(false); } return(pointsList, wrongPoints); }
public (Vector2, float) VirtualMove(Object2D realUser, Object2D virtualUser, Space2D virtualSpace) { Transform2D virtualUserTransform = virtualUser.transform; if (!initializing) { ResetCurrentState(virtualUserTransform); initializing = false; } if (episode.IsNotEnd()) { if (isFirst) { isFirst = false; targetPosition = episode.GetTarget(virtualUserTransform, virtualSpace); initialToTarget = targetPosition - virtualUserTransform.localPosition; float InitialAngle = Vector2.SignedAngle(virtualUserTransform.forward, initialToTarget); float initialDistance = Vector2.Distance(virtualUserTransform.localPosition, targetPosition); virtualTargetDirection = Matrix3x3.CreateRotation(InitialAngle) * virtualUser.transform.forward; // target을 향하는 direction(forward)를 구함 //realTargetDirection = Matrix3x3.CreateRotation(InitialAngle) * realUser.transform.forward; virtualTargetPosition = virtualUser.transform.localPosition + virtualTargetDirection * initialDistance; // target에 도달하는 position을 구함 //realTargetPosition = realUser.transform.localPosition + realTargetDirection * initialDistance; maxRotTime = Mathf.Abs(InitialAngle) / rotationSpeed; maxTransTime = initialDistance / translationSpeed; remainRotTime = 0; remainTransTime = 0; initialAngleDirection = Mathf.Sign(InitialAngle); } float distance = (targetPosition - virtualUserTransform.localPosition).magnitude; float angle = Vector2.SignedAngle(virtualUserTransform.forward, initialToTarget); if (remainRotTime < maxRotTime) { virtualUser.Rotate(initialAngleDirection * rotationSpeed * Time.fixedDeltaTime); remainRotTime += Time.fixedDeltaTime; } else if (remainTransTime < maxTransTime) { if (isFirst2) // 방향을 동기화 { isFirst2 = false; SyncDirection(virtualUser, virtualTargetDirection); } else { virtualUser.Translate(virtualUserTransform.forward * translationSpeed * Time.fixedDeltaTime, Space.World); remainTransTime += Time.fixedDeltaTime; } } else { if (isFirst3) // 위치를 동기화 { isFirst3 = false; SyncPosition(virtualUser, virtualTargetPosition); } else { episode.DeleteTarget(); //Debug.Log(string.Format("realUser: {0}", realUser.transform)); //Debug.Log(string.Format("virtualUser: {0}", virtualUser.transform)); isFirst = true; isFirst2 = true; isFirst3 = true; } } } UpdateCurrentState(virtualUserTransform); return(GetDelta(virtualUserTransform.forward)); }
/// <summary> /// Creates 2D transformation matrix that represents this transform component. /// </summary> /// <returns>2D transformation matrix representing this transform component.</returns> public Matrix3x3 ToMatrix() => Matrix3x3.CreateTranslation(Translation) * Matrix3x3.CreateRotation(Rotation) * Matrix3x3.CreateScale(Scale) * Matrix3x3.Identity;
private static void Run() { #region Near Equality Methods var x = 1.0; var y = 2.0; bool isItTrueThat = x.IsPracticallySame(y); isItTrueThat = x.IsPracticallySame(y); Vector2 v2_1 = new Vector2(1.0, 2.0); Vector2 v2_2 = new Vector2(1.00000000001, 2.000000000002); isItTrueThat = v2_1.IsPracticallySame(v2_2); Vector3 v3_1 = new Vector3(1.0, 2.0, 3.0); Vector3 v3_2 = new Vector3(1.00000000001, 2.000000000002, 3.0); isItTrueThat = v3_1.IsPracticallySame(v3_2); isItTrueThat = x.IsNegligible(); isItTrueThat = v2_1.IsNegligible(); isItTrueThat = v3_1.IsNegligible(); isItTrueThat = x.IsGreaterThanNonNegligible(y); isItTrueThat = x.IsLessThanNonNegligible(y); #endregion #region All Vector2 Methods v2_1 = new Vector2(); Vector2 nullVector2 = Vector2.Null; Vector2 zeroVector2 = Vector2.Zero; Vector2 oneVector2 = Vector2.One; Vector2 unitVector2X = Vector2.UnitX; Vector2 unitVector2Y = Vector2.UnitY; Vector2 copyVector = v2_1.Copy(); double[] coordinates = v2_1.Position; x = v2_1.X; x = v2_1[0]; y = v2_1.Y; y = v2_1[1]; double length = v2_1.Length(); double lengthSquared = v2_1.LengthSquared(); double distance = v2_1.Distance(zeroVector2); double distanceSquared = v2_1.DistanceSquared(zeroVector2); Vector2 normal = v2_1.Normalize(); Vector2 reflect = v2_1.Reflect(unitVector2Y); Vector2 clamp = v2_1.Clamp(zeroVector2, oneVector2); Vector2 lerp = v2_1.Lerp(oneVector2, 0.5); v2_2 = v2_1 + v2_1; v2_2 = v2_1 - v2_1; v2_2 = v2_1 * v2_1; //not dot or cross - basically a //component to component product vector whos terms sum to dot product v2_2 = v2_1 - v2_1; v2_2 = v2_1 / v2_1; v2_2 = v2_1 / new double(); v2_2 = -v2_1; isItTrueThat = v2_1.IsNull(); isItTrueThat = v2_1.IsNegligible(); v2_1.CopyTo(coordinates); isItTrueThat = v2_1 == v2_2; isItTrueThat = v2_1 != v2_2; double dot = v2_1.Dot(v2_2); double cross = v2_1.Cross(v2_2); Vector2 minVector = Vector2.Min(v2_1, v2_2); Vector2 maxVector = Vector2.Max(v2_1, v2_2); Vector2 absVector = Vector2.Abs(v2_1); Vector2 sqrtVector = Vector2.SquareRoot(v2_1); Matrix3x3 m3x3 = new Matrix3x3(); v2_1 = v2_1.Transform(m3x3); v2_1 = v2_1.TransformNoTranslate(m3x3); Matrix4x4 m4x4 = new Matrix4x4(); v2_1 = v2_1.Transform(m4x4); v2_1 = v2_1.TransformNoTranslate(m4x4); v2_1 = v2_1.Transform(new Quaternion()); #endregion #region All Matrix3x3 Methods isItTrueThat = m3x3.IsProjectiveTransform; double value = m3x3.M11; value = m3x3.M12; value = m3x3.M13; value = m3x3.M21; value = m3x3.M22; value = m3x3.M23; value = m3x3.M31; value = m3x3.M32; value = m3x3.M33; m3x3 = Matrix3x3.Identity; m3x3 = Matrix3x3.Null; isItTrueThat = m3x3.IsIdentity(); isItTrueThat = m3x3.IsNull(); Vector2 t = m3x3.Translation; m3x3 = Matrix3x3.CreateTranslation(t); m3x3 = Matrix3x3.CreateTranslation(x, y); m3x3 = Matrix3x3.CreateScale(1.0); m3x3 = Matrix3x3.CreateScale(x, y); m3x3 = Matrix3x3.CreateScale(Vector2.One); m3x3 = Matrix3x3.CreateScale(x, y, v2_2); //vResult is the center of scaling m3x3 = Matrix3x3.CreateSkew(2.0, 2.0); m3x3 = Matrix3x3.CreateSkew(2.0, 2.0, v2_2); //vResult is the center of skewing m3x3 = Matrix3x3.CreateRotation(1.0); //in radians m3x3 = Matrix3x3.CreateRotation(1.0, v2_2); //vResult is the center of rotate m3x3 = m3x3.Transpose(); isItTrueThat = Matrix3x3.Invert(m3x3, out Matrix3x3 invM3x3); var d = m3x3.GetDeterminant(); m3x3 = Matrix3x3.Lerp(m3x3, m3x3, 0.5); m3x3 = -m3x3; var m3x3Another = 4.0 * m3x3; m3x3 = m3x3 + m3x3; m3x3 = m3x3 - m3x3; m3x3 = m3x3 * m3x3; isItTrueThat = m3x3 == m3x3Another; isItTrueThat = m3x3 != m3x3Another; #endregion #region All Vector3 Methods v3_1 = new Vector3(); v3_1 = new Vector3(v2_1, 0.0); Vector3 nullVector3 = Vector3.Null; Vector3 zeroVector3 = Vector3.Zero; Vector3 oneVector3 = Vector3.One; Vector3 unitVector3X = Vector3.UnitX; Vector3 unitVector3Y = Vector3.UnitY; Vector3 unitVector3Z = Vector3.UnitZ; unitVector3X = Vector3.UnitVector(CartesianDirections.XNegative); unitVector3X = Vector3.UnitVector(0); Vector3 copyVector3 = v3_1.Copy(); coordinates = v3_1.Position; x = v3_1.X; x = v3_1[0]; y = v3_1.Y; y = v3_1[1]; double z = v3_1.Z; y = v3_1[2]; length = v3_1.Length(); lengthSquared = v3_1.LengthSquared(); distance = v3_1.Distance(zeroVector3); distanceSquared = v3_1.DistanceSquared(zeroVector3); Vector3 normal3 = v3_1.Normalize(); Vector3 reflect3 = v3_1.Reflect(unitVector3Y); Vector3 clamp3 = v3_1.Clamp(zeroVector3, oneVector3); Vector3 lerp3 = v3_1.Lerp(oneVector3, 0.5); v3_2 = v3_1 + v3_1; v3_2 = v3_1 - v3_1; v3_2 = v3_1 * v3_1; //not dot or cross - basically a //component to component product vector whos terms sum to dot product v3_2 = v3_1 - v3_1; v3_2 = v3_1 / v3_1; v3_2 = v3_1 / new double(); v3_2 = -v3_1; isItTrueThat = v3_1.IsNull(); isItTrueThat = v3_1.IsNegligible(); v3_1.CopyTo(coordinates); isItTrueThat = v3_1 == v3_2; isItTrueThat = v3_1 != v3_2; double dot3 = v3_1.Dot(v3_2); Vector3 cross3 = v3_1.Cross(v3_2); Vector3 minVector3 = Vector3.Min(v3_1, v3_2); Vector3 maxVector3 = Vector3.Max(v3_1, v3_2); Vector3 absVector3 = Vector3.Abs(v3_1); Vector3 sqrtVector3 = Vector3.SquareRoot(v3_1); m3x3 = new Matrix3x3(); v3_1 = v3_1.Multiply(m3x3); m4x4 = new Matrix4x4(); v3_1 = v3_1.Transform(m4x4); v3_1 = v3_1.TransformNoTranslate(m4x4); v3_1 = v3_1.Transform(new Quaternion()); #endregion #region All Matrix4x4 Methods isItTrueThat = m4x4.IsProjectiveTransform; value = m4x4.M11; value = m4x4.M12; value = m4x4.M13; value = m4x4.M14; value = m4x4.M21; value = m4x4.M22; value = m4x4.M23; value = m4x4.M24; value = m4x4.M31; value = m4x4.M32; value = m4x4.M33; value = m4x4.M34; value = m4x4.M41; value = m4x4.M42; value = m4x4.M43; value = m4x4.M44; m4x4 = Matrix4x4.Identity; m4x4 = Matrix4x4.Null; m4x4 = new Matrix4x4(m3x3); isItTrueThat = m4x4.IsIdentity(); isItTrueThat = m4x4.IsNull(); Vector3 t3 = m4x4.TranslationAsVector; m4x4 = Matrix4x4.CreateBillboard(v3_1, v3_1, v3_1, v3_1); m4x4 = Matrix4x4.CreateConstrainedBillboard(v3_1, v3_1, v3_1, v3_1, v3_1); m4x4 = Matrix4x4.CreateTranslation(t3); m4x4 = Matrix4x4.CreateTranslation(x, y, z); m4x4 = Matrix4x4.CreateScale(1.0); m4x4 = Matrix4x4.CreateScale(x, y, z); m4x4 = Matrix4x4.CreateScale(v3_1); m4x4 = Matrix4x4.CreateScale(v3_1, v3_2); //vOther is the center of scaling m4x4 = Matrix4x4.CreateScale(x, y, z, v3_2); //vOther is the center of scaling m4x4 = Matrix4x4.CreateRotationX(1.0); //in radians m4x4 = Matrix4x4.CreateRotationX(1.0, v3_2); //vOther is the center of rotate m4x4 = Matrix4x4.CreateRotationY(1.0); //in radians m4x4 = Matrix4x4.CreateRotationY(1.0, v3_2); //vOther is the center of rotate m4x4 = Matrix4x4.CreateRotationZ(1.0); //in radians m4x4 = Matrix4x4.CreateRotationZ(1.0, v3_2); //vOther is the center of rotate m4x4 = Matrix4x4.CreateFromAxisAngle(v3_2, 1.0); //vOther is the center of rotate m4x4 = Matrix4x4.CreatePerspectiveFieldOfView(1.0, 2.0, 3.0, 4.0); m4x4 = Matrix4x4.CreatePerspective(1.0, 1.0, 1.0, 1.0); m4x4 = Matrix4x4.CreatePerspectiveOffCenter(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); m4x4 = Matrix4x4.CreateOrthographic(1.0, 2.0, 3.0, 4.0); m4x4 = Matrix4x4.CreateOrthographicOffCenter(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); m4x4 = Matrix4x4.CreateLookAt(v3_1, v3_1, v3_2); m4x4 = Matrix4x4.CreateWorld(v3_1, v3_1, v3_2); m4x4 = Matrix4x4.CreateFromYawPitchRoll(1.0, 2.0, 3.0); m4x4 = Matrix4x4.CreateFromQuaternion(new Quaternion()); m4x4 = Matrix4x4.CreateShadow(v3_1, new Plane(d, v3_2)); m4x4 = Matrix4x4.CreateReflection(new Plane(d, v3_2)); m4x4 = m4x4.Transpose(); isItTrueThat = Matrix4x4.Invert(m4x4, out Matrix4x4 invm4x4); d = m4x4.GetDeterminant(); isItTrueThat = m4x4.Decompose(out var scale, out var rotQ, out var trans3); m4x4 = m4x4.Transform(rotQ); m4x4 = Matrix4x4.Lerp(m4x4, m4x4, 0.5); m4x4 = -m4x4; var m4x4Another = 4.0 * m4x4; m4x4 = m4x4 + m4x4; m4x4 = m4x4 - m4x4; m4x4 = m4x4 * m4x4; isItTrueThat = m4x4 == m4x4Another; isItTrueThat = m4x4 != m4x4Another; #endregion #region All Quaternion Methods var quat = new Quaternion(); x = quat.X; y = quat.Y; z = quat.Z; var w = quat.W; var quatOther = new Quaternion(v3_1, w); quat = new Quaternion(x, y, z, w); quat = Quaternion.Identity; isItTrueThat = quat.IsIdentity(); quat = Quaternion.Null; isItTrueThat = quat.IsNull(); length = quat.Length(); length = quat.LengthSquared(); quat = quat.Normalize(); quat = quat.Conjugate(); quat = quat.Inverse(); quat = Quaternion.CreateFromAxisAngle(v3_1, d); quat = Quaternion.CreateFromYawPitchRoll(1.0, 2.0, 3.0); quat = Quaternion.CreateFromRotationMatrix(m4x4); dot = quat.Dot(quat); quat = Quaternion.Lerp(quat, quat, 0.5); quat = Quaternion.Slerp(quat, quat, 0.5); quat = -quat; quat = quat + quat; quat = quat - quat; quat = quat * quat; quat = 4.0 * quat; quat = quat / quat; isItTrueThat = quat == quatOther; isItTrueThat = quat != quatOther; #endregion #region All Plane Methods var plane = new Plane(); plane = new Plane(d, v3_1); var planeOther = new Plane(d, new Vector3(x, y, z)); v3_1 = plane.Normal; d = plane.DistanceToOrigin; plane = Plane.CreateFromVertices(v3_1, unitVector3X, v3_2); plane.Normalize(); plane.Transform(m4x4); plane.Transform(quat); dot = plane.DotCoordinate(v3_1); dot = plane.DotNormal(v3_1); isItTrueThat = plane == planeOther; isItTrueThat = plane != planeOther; #endregion #region IEnumerable<double> Statistics IEnumerable <double> numbers = new[] { 1.1, 2.2, 3.3 }; var mean = numbers.Mean(); var median = numbers.Median(); var nrmse = numbers.NormalizedRootMeanSquareError(); var nthMedian = numbers.NthOrderStatistic(3); var varMean = numbers.VarianceFromMean(mean); var varMedian = numbers.VarianceFromMedian(median); #endregion }