示例#1
0
 public GridIndexTriangle(int index1, int index2, int index3, ref GridVector2[] pointArray)
 {
     i1 = index1;
     i2 = index2;
     i3 = index3;
     this.points = pointArray;
 }
示例#2
0
        public static GridCircle CircleFromThreePoints(GridVector2 One, GridVector2 Two, GridVector2 Three)
        {
            if (One.X == Two.X && Two.X == Three.X)
            {
                throw new ArgumentException("Circle from three points with three points on a vertical line");
            }

            double A = Two.X - One.X;
            double B = Two.Y - One.Y;
            double C = Three.X - One.X;
            double D = Three.Y - One.Y;
            double E = A * (One.X + Two.X) + B * (One.Y + Two.Y);
            double F = C * (One.X + Three.X) + D * (One.Y + Three.Y);
            double G = 2 * (A * (Three.Y - Two.Y) - B * (Three.X - Two.X));

            //Check for colinear
               //         Debug.Assert(false == (G <= double.Epsilon && G >= -double.Epsilon));
            if (G <= double.Epsilon && G >= -double.Epsilon)
            {
                throw new ArgumentException("Circle from three points with three points on a line");
            }

            GridVector2 Center = new GridVector2();
            Center.X = (D * E - B * F) / G;
            Center.Y = (A * F - C * E) / G;

            return new GridCircle(Center, GridVector2.Distance(Center, One));
        }
示例#3
0
        public void QuadTreeTestOne()
        {
            GridVector2[] points = new GridVector2[] { new GridVector2(0,0),
                                                       new GridVector2(1,1),
                                                       new GridVector2(-10,-10),
                                                       new GridVector2(-7.5, 2.5),
                                                       new GridVector2(8.5, -1.5),
                                                       new GridVector2(3.5, -6.5),
                                                       new GridVector2(1.5, -8.5),
                                                       new GridVector2(10, 10)};
            int[] values = new int[] {0,1,2,3,4,5,6,7};
            GridRectangle border = GridVector2.Border(points);
            QuadTree<int> tree = new QuadTree<int>(points, values, border);

            //Start with a basic test ensuring we can find all the existing points
            for(int i = 0; i < points.Length; i++)
            {
                double distance;
                int RetValue;
                RetValue = tree.FindNearest(points[i], out distance);

                Debug.Assert(RetValue == i);
                Debug.Assert(distance == 0);
            }

            //Check to see if we can find nearby points
            GridVector2[] nearpoints = new GridVector2[] { new GridVector2(.25,.25),
                                                       new GridVector2(.5,.51),
                                                       new GridVector2(-7.5,-7.5),
                                                       new GridVector2(-7.5, -1.5),
                                                       new GridVector2(8.5, -5.5),
                                                       new GridVector2(4.5, -7.75),
                                                       new GridVector2(1, -8.75),
                                                       new GridVector2(11, 11)}; //Out of original boundaries

            for (int i = 0; i < nearpoints.Length; i++)
            {
                double distance;
                int RetValue;
                RetValue = tree.FindNearest(nearpoints[i], out distance);

                Debug.Assert(RetValue == i);
                Debug.Assert(distance == GridVector2.Distance(points[i], nearpoints[i]));
            }

            //Check to see if we can return all points in a rectangle
            GridRectangle gridRect = new GridRectangle(0,15, 0,15);
            List<GridVector2> intersectPoints;
            List<int> intersectValues;
            tree.Intersect(gridRect, out intersectPoints, out intersectValues);
            Debug.Assert(intersectValues.Contains(0));
            Debug.Assert(intersectValues.Contains(1));
            Debug.Assert(intersectValues.Contains(7));

            Debug.Assert(false == intersectValues.Contains(2));
            Debug.Assert(false == intersectValues.Contains(3));
            Debug.Assert(false == intersectValues.Contains(4));
            Debug.Assert(false == intersectValues.Contains(5));
            Debug.Assert(false == intersectValues.Contains(6));
        }
        public LinkStructureToParentCommand(Viking.UI.Controls.SectionViewerControl parent,
                                               Structure structure, 
                                               Location_CanvasViewModel location)
            : base(parent)
        {
            this.putativeStruct = structure;
            this.putativeLoc = location;

            StructureType LocType = this.putativeStruct.Type;
            if (LocType != null)
            {
                linecolor = new Microsoft.Xna.Framework.Color(LocType.Color.R,
                    LocType.Color.G,
                    LocType.Color.B,
                    128);
            }
            else
            {
                linecolor = Microsoft.Xna.Framework.Color.Green;
            }

            //Transform the location position to the correct coordinates
            transformedPos = parent.SectionToVolume(new GridVector2(putativeLoc.X, putativeLoc.Y));

            parent.Cursor = Cursors.Cross;
        }
示例#5
0
 public GridCircle(GridVector2 center, double radius)
 {
     this.Center = center;
     this.Radius = radius;
     this.RadiusSquared = radius * radius;
     _HashCode = new int?();
 }
示例#6
0
        private static List<int> FindExtremes(GridVector2[] points)
        {
            int iMinX = 0;
            int iMinY = 0;
            int iMaxX = 0;
            int iMaxY = 0;

            for(int iPoint = 0; iPoint < points.Length; iPoint++)
            {
                GridVector2 point = points[iPoint];
                if (point.X < points[iMinX].X)
                    iMinX = iPoint;
                if (point.X > points[iMaxX].X)
                    iMaxX = iPoint;
                if (point.Y < points[iMinY].Y)
                    iMinX = iPoint;
                if (point.Y > points[iMaxY].Y)
                    iMaxY = iPoint;
            }

            List<int> ListExtremes = new List<int>( new int[]{ iMinX, iMinY, iMaxX, iMaxY} );
            ListExtremes.Sort();
            for(int iPoint = 1; iPoint < ListExtremes.Count; iPoint++)
            {
                if(ListExtremes[iPoint] == ListExtremes[iPoint-1])
                {
                    ListExtremes.RemoveAt(iPoint);
                    iPoint--;
                }
            }

            return ListExtremes;
        }
示例#7
0
 public GridRectangle(GridVector2 position, double width, double height)
 {
     Left = position.X;
     Bottom = position.Y;
     Top = Bottom + height;
     Right = Left + width;
     _HashCode = new int?();
     Debug.Assert(Left <= Right && Bottom <= Top, "Grid Rectable argument error");
 }
示例#8
0
        public GridRectangle(GridVector2 position, double radius)
        {
            Left = position.X - radius;
            Bottom = position.Y - radius;
            Top = position.Y + radius;
            Right = position.X + radius;
            _HashCode = new int?();

            Debug.Assert(Left <= Right && Bottom <= Top, "Grid Rectable argument error");
        }
示例#9
0
文件: Delaunay.cs 项目: abordt/Viking
 public static int[] Triangulate(GridVector2[] points, GridRectangle bounds)
 {
     double WidthMargin = bounds.Width;
     double HeightMargin = bounds.Height;
     GridVector2[] BoundingPoints = new GridVector2[] { new GridVector2(bounds.Left - WidthMargin, bounds.Bottom - HeightMargin),
                                                        new GridVector2(bounds.Right + WidthMargin, bounds.Bottom - HeightMargin),
                                                        new GridVector2(bounds.Left - WidthMargin, bounds.Top +  HeightMargin),
                                                        new GridVector2(bounds.Right + WidthMargin, bounds.Top + HeightMargin)};
     return Delaunay.Triangulate(points, BoundingPoints);
 }
示例#10
0
        public void TestCircleFromPoints()
        {
            //
            // TODO: Add test logic	here
            //
            GridVector2[] points = new GridVector2[]  {new GridVector2(5, 0),
                                                        new GridVector2(0, 5),
                                                        new GridVector2(-5,0)};

            GridCircle circle = Utilities.GridCircle.CircleFromThreePoints(points);
            Debug.Assert(circle.Center.X == 0.0 && circle.Center.Y == 0.0);
            Debug.Assert(circle.Radius == 5.0);

            points = new GridVector2[]  {new GridVector2(0,-5),
                                                        new GridVector2(0, 5),
                                                        new GridVector2(Math.Cos(-0.5) * 5, Math.Sin(-0.5) * 5)};

            circle = Utilities.GridCircle.CircleFromThreePoints(points);
            Debug.Assert(GridVector2.Distance(circle.Center, new GridVector2(0, 0)) < Utilities.Global.Epsilon);
            Debug.Assert(circle.Radius > 5.0 - Utilities.Global.Epsilon && circle.Radius < 5.0 + Utilities.Global.Epsilon);

            points = new GridVector2[]  {new GridVector2(5,0),
                                                        new GridVector2(10, 5),
                                                        new GridVector2(5, 10)};

            circle = Utilities.GridCircle.CircleFromThreePoints(points);
            Debug.Assert(GridVector2.Distance(circle.Center, new GridVector2(5, 5)) < Utilities.Global.Epsilon);
            Debug.Assert(circle.Radius > 5.0 - Utilities.Global.Epsilon && circle.Radius < 5.0 + Utilities.Global.Epsilon);

            points = new GridVector2[]  {new GridVector2(5,0),
                                                        new GridVector2(5, 10),
                                                        new GridVector2(10, 5)};

            circle = Utilities.GridCircle.CircleFromThreePoints(points);
            Debug.Assert(GridVector2.Distance(circle.Center, new GridVector2(5, 5)) < Utilities.Global.Epsilon);
            Debug.Assert(circle.Radius > 5.0 - Utilities.Global.Epsilon && circle.Radius < 5.0 + Utilities.Global.Epsilon);

            points = new GridVector2[]  {new GridVector2(Math.Cos(0.5) * 5, Math.Sin(0.5) * 5),
                                                        new GridVector2(5, 0),
                                                        new GridVector2(Math.Cos(-0.5) * 5, Math.Sin(-0.5) * 5)};

            circle = Utilities.GridCircle.CircleFromThreePoints(points);
            Debug.Assert(GridVector2.Distance(circle.Center, new GridVector2(0,0)) < Utilities.Global.Epsilon);
            Debug.Assert(circle.Radius > 5.0 - Utilities.Global.Epsilon && circle.Radius < 5.0 + Utilities.Global.Epsilon);

            points = new GridVector2[]  {new GridVector2((Math.Cos(0.5) * 5) + 5, (Math.Sin(0.5) * 5) + 5),
                                                        new GridVector2(10, 5),
                                                        new GridVector2((Math.Cos(-0.5) * 5)+5, (Math.Sin(-0.5) * 5)+5)};

            circle = Utilities.GridCircle.CircleFromThreePoints(points);
            Debug.Assert(GridVector2.Distance(circle.Center, new GridVector2(5, 5)) < Utilities.Global.Epsilon);
            Debug.Assert(circle.Radius > 5.0 - Utilities.Global.Epsilon && circle.Radius < 5.0 + Utilities.Global.Epsilon);
        }
示例#11
0
        protected override void OnMouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            GridVector2 NewPosition = Parent.ScreenToWorld(e.X, e.Y);

            //Figure out if we are starting a rectangle
            if (e.Button == MouseButtons.Left)
            {
                bookmarkPosition = Parent.ScreenToWorld(e.X, e.Y);
                Execute();
            }

            base.OnMouseDown(sender, e);
        }
示例#12
0
        public ResizeLocationCommand(Viking.UI.Controls.SectionViewerControl parent)
            : base(parent)
        {
            selected = Viking.UI.State.SelectedObject as Location_CanvasViewModel;
            Debug.Assert(selected != null);

            LocType = selected.Parent.Type;

            SectionLocationsViewModel sectionAnnotations = AnnotationOverlay.GetAnnotationsForSection(Parent.Section.Number);
            if (sectionAnnotations == null)
                return;

            Origin = sectionAnnotations.GetPositionForLocation(selected);
            parent.Cursor = Cursors.SizeAll;
            SaveToDB = true;
        }
示例#13
0
        protected override void OnMouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            //            GridVector2 NewPosition = Parent.ScreenToWorld(e.X, e.Y);

            //Figure out if we are starting a rectangle
            if (e.Button == MouseButtons.Left)
            {
                Origin = Parent.ScreenToWorld(e.X, e.Y);
                this.CommandActive = true;
            }

            if (e.Button == MouseButtons.Right)
                this.Execute();

            base.OnMouseDown(sender, e);
        }
示例#14
0
文件: LineTest.cs 项目: abordt/Viking
        public void GridLineIntersects()
        {
            //
            // TODO: Add test logic	here
            //

            GridLine lineA = new GridLine(new GridVector2(-5, 0),
                                                        new GridVector2(-10, 0));
            GridLine lineB = new GridLine(new GridVector2(0, 5),
                                                        new GridVector2(0, -5));

            GridVector2 intersect = new GridVector2();
            bool result = lineA.Intersects(lineB, out intersect);
            Debug.Assert(result == true);
            Debug.Assert(intersect.X == 0 && intersect.Y == 0);
        }
示例#15
0
        public ResizeLocationCommand(Viking.UI.Controls.SectionViewerControl parent, 
                                     StructureType type, 
                                     Location_CanvasViewModel loc)
            : base(parent)
        {
            selected = loc;
            LocType = type;
            this.SaveToDB = false;

            SectionLocationsViewModel sectionAnnotations = AnnotationOverlay.GetAnnotationsForSection(Parent.Section.Number);
            if (sectionAnnotations == null)
                return;

            //Origin = sectionAnnotations.GetPositionForLocation(selected);
            Origin = selected.VolumePosition;
            parent.Cursor = Cursors.SizeAll;
             //           CreationTime = DateTime.Now;
        }
示例#16
0
        public static GridCircle CircleFromThreePoints(GridVector2[] points)
        {
            if (points == null)
            {
                throw new ArgumentNullException("points");

            }

            Debug.Assert(points.Length == 3);
            if (points.Length != 3)
                throw new ArgumentException("GridCircle: Expected an array with three elements");

            GridVector2 A = points[0];
            GridVector2 B = points[1];
            GridVector2 C = points[2];

            return CircleFromThreePoints(A, B, C);
        }
示例#17
0
文件: GridLine.cs 项目: abordt/Viking
        public bool Intersects(GridLine seg, out GridVector2 Intersection)
        {
            //Function for each line
            //Ax + By = C
            Intersection = new GridVector2();

            if (seg == null)
                throw new ArgumentNullException("seg");

            if (this.Direction == seg.Direction)
                return false;

            GridVector2 A = Origin;
            GridVector2 B = Origin + Direction;

            GridVector2 segA = seg.Origin;
            GridVector2 segB = seg.Origin + seg.Direction;

            double A1 = B.Y - A.Y;
            double A2 = segB.Y - segA.Y;

            double B1 = A.X - B.X;
            double B2 = segA.X - segB.X;

            double C1 = A1 * A.X + B1 * A.Y;
            double C2 = A2 * segA.X + B2 * segA.Y;

            double det = A1 * B2 - A2 * B1;
            //Check if lines are parallel
            if (det == 0)
            {

                return false;
            }
            else
            {
                double x = (B2 * C1 - B1 * C2) / det;
                double y = (A1 * C2 - A2 * C1) / det;

                Intersection = new GridVector2(x, y);
                return true;
            }
        }
示例#18
0
        public void TestAngle()
        {
            GridVector2 A = new GridVector2(5, 0);
            GridVector2 B = new GridVector2(2.5, 2.5);

            double angle = GridVector2.Angle(A,B);
            Debug.Assert(angle - Global.Epsilon < Math.PI / 4 &&
                         angle + Global.Epsilon > Math.PI / 4);

            A = new GridVector2(5, 0);
            B = new GridVector2(2.5, -2.5);

            angle = GridVector2.Angle(A,B);
            Debug.Assert(angle - Global.Epsilon < -Math.PI / 4 &&
                         angle + Global.Epsilon > -Math.PI / 4);

            //
            // TODO: Add test logic	here
            //
        }
示例#19
0
        public IUIObjectBasic GetNearestLink(int SectionNumber, GridVector2 WorldPosition, out double distance)
        {
            //            double minDistance = double.MaxValue;
            distance = double.MaxValue;
            GridVector2 NearestIntersection;
            //            IUIObjectBasic FoundLink = null;
            LineSearchGrid<LocationLink> searchGrid = GetSearchGrid(SectionNumber);

            if (searchGrid == null)
                return null;

            LocationLink locLinkObj = searchGrid.GetNearest(WorldPosition, out NearestIntersection, out distance);
            if (locLinkObj != null)
            {
                if (distance > locLinkObj.Radius)
                {
                    locLinkObj = null;
                }
                else
                {
                    //minDistance = distance;
                    //FoundLink = locLinkObj as IUIObjectBasic;
                }
            }

            return locLinkObj;

            /*
            StructureLink structLinkObj = StructureLinksSearch.GetNearest(WorldPosition, out NearestIntersection, out distance);
            if (structLinkObj != null && distance < minDistance)
            {
                if (distance <= structLinkObj.Radius && distance < minDistance)
                {
                    FoundLink = structLinkObj as IUIObjectBasic;
                    minDistance = distance;
                }
            }
            distance = minDistance;
            return FoundLink;
             */
        }
示例#20
0
        public void TestDelaunay()
        {
            GridVector2[] points = new GridVector2[]{ new GridVector2(50, 50),
                                                      new GridVector2(50, 100),
                                                      new GridVector2(50, 150),
                                                       new GridVector2(150, 50),
                                                      new GridVector2(150, 100),
                                                      new GridVector2(150, 150)};

            int[] iTriangles = Delaunay.Triangulate(points);
            int[] iExpected = new int[] {0,1,4,0,3,4,1,2,5,1,4,5};

            Debug.WriteLine(iTriangles.ToString());
            Debug.Assert(iTriangles.Length / 3 == 4); //We should find four triangles
            for(int i = 0; i < iExpected.Length; i++)
            {
                Debug.Assert(iExpected[i] == iTriangles[i]);
            }

            points = new GridVector2[]{ new GridVector2(50, 50),
                                                      new GridVector2(50, 100),
                                                      new GridVector2(50, 150),
                                                      new GridVector2(150, 50),
                                                      new GridVector2(150, 100),
                                                      new GridVector2(150, 150),
                                                      new GridVector2(250, 50),
                                                      new GridVector2(250, 100),
                                                      new GridVector2(250, 150)};

            iTriangles = Delaunay.Triangulate(points);
            iExpected = new int[] {3,4,7,3,6,7,4,5,8,4,7,8,0,1,4,0,3,4,1,2,5,1,4,5};

            Debug.WriteLine(iTriangles.ToString());
            Debug.Assert(iTriangles.Length / 3 == 8); //We should find four triangles

            for (int i = 0; i < iExpected.Length; i++)
            {
                Debug.Assert(iExpected[i] == iTriangles[i]);
            }
        }
示例#21
0
        /*
        static public void DrawCircle(GraphicsDevice graphicsDevice,
                BasicEffect basicEffect,
                GridVector2 Pos,
                double Radius,
                Microsoft.Xna.Framework.Color color)
        {
            basicEffect.Begin();
            foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
            {
                pass.Begin();
                DrawCircle(Pos, Radius, color);
                pass.End();
            }
            basicEffect.End() ;
        }
         */
        /*
        static public void DrawCircle(
                SpriteBatch spriteBatch,
                GridVector2 Pos,
                double Radius,
                Microsoft.Xna.Framework.Color color)
        {
            int Diameter = (int)Math.Round(Radius * 2);
            if (Diameter < 1)
                return;

            int X = (int)Math.Round((Pos.X - Radius));
            int Y = (int)Math.Round((Pos.Y - Radius));

            spriteBatch.Begin(SpriteBlendMode.Additive | SpriteBlendMode.AlphaBlend);
            Microsoft.Xna.Framework.Rectangle DestRect = new Microsoft.Xna.Framework.Rectangle(X, Y, Diameter, Diameter);
            spriteBatch.Draw(CircleTexture, DestRect, color);
            spriteBatch.End();
            return;
        }
         */
        public static void DrawCircle(GraphicsDevice graphicsDevice,
                BasicEffect basicEffect, 
                GridVector2 Pos,
                double Radius,
                Microsoft.Xna.Framework.Color color)
        {
            //A better way to implement this is to just render a circle texture and add color using lighting, but
            //this will work for now

            VertexPositionColorTexture[] verts;

            //Can't populate until we've referenced CircleVerts
            int[] indicies;
            //int[] lineIndicies;
            float radius = (float)Radius;

            //Figure out if we should draw triangles instead
            verts = new VertexPositionColorTexture[GlobalPrimitives.SquareVerts.Length];
            GlobalPrimitives.SquareVerts.CopyTo(verts, 0);

            indicies = GlobalPrimitives.SquareIndicies;

            //Scale and color the verticies
            for (int i = 0; i < verts.Length; i++)
            {
                verts[i].Position.X *= radius;
                verts[i].Position.Y *= radius;

                verts[i].Position.X += (float)Pos.X;
                verts[i].Position.Y += (float)Pos.Y;
                verts[i].Color = color;
            }

            //PORT XNA 4
            /*
            VertexDeclaration oldVertexDeclaration = graphicsDevice.VertexDeclaration;
            if (VertexPositionColorTextureDecl == null)
            {
                VertexPositionColorTextureDecl = new VertexDeclaration(graphicsDevice, VertexPositionColorTexture.VertexElements);
            }

            graphicsDevice.VertexDeclaration = VertexPositionColorTextureDecl;
            graphicsDevice.RenderState.PointSize = 5.0f;
            */
            basicEffect.Texture = GlobalPrimitives.CircleTexture;
            basicEffect.TextureEnabled = true;
            basicEffect.VertexColorEnabled = true;
            basicEffect.LightingEnabled = false;
            //basicEffect.Alpha = 0.5f;
            //PORT XNA 4
            //basicEffect.CommitChanges();

            //PORT XNA 4
            //basicEffect.Begin();

             foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
             {
                 //PORT XNA 4
                 //pass.Begin();
                 pass.Apply();

                 graphicsDevice.DrawUserIndexedPrimitives<VertexPositionColorTexture>(PrimitiveType.TriangleList,
                                                                               verts,
                                                                               0,
                                                                               verts.Length,
                                                                               indicies,
                                                                               0,
                                                                               2);

                 //PORT XNA 4
                 //pass.End();
             }

             //PORT XNA 4
             //basicEffect.End();

             //PORT XNA 4
             //graphicsDevice.VertexDeclaration = oldVertexDeclaration;
             basicEffect.TextureEnabled = false;
             basicEffect.VertexColorEnabled = false;
            //PORT XNA 4
            //basicEffect.CommitChanges();
        }
示例#22
0
 public abstract bool TryTransform(GridVector2 Point, out GridVector2 v);
示例#23
0
 /// <summary>
 /// Adjust the output of the transform by the following vector
 /// </summary>
 /// <param name="vector"></param>
 public abstract void Translate(GridVector2 vector);
示例#24
0
 public abstract GridVector2 Transform(GridVector2 Point);
示例#25
0
 public abstract GridVector2 InverseTransform(GridVector2 Point);
示例#26
0
 public abstract bool CanTransform(GridVector2 Point);
示例#27
0
文件: LineTest.cs 项目: abordt/Viking
        public void GridLineSegmentDistanceToPoint()
        {
            //Check edge conditions for a horizontal line
            {
                GridLineSegment lineA = new GridLineSegment(new GridVector2(-5, 3),
                                                            new GridVector2(5, 3));

                //Check edge conditions for a horizontal line
                GridVector2 PointOnLine = new GridVector2(2, 3);
                double Distance;
                GridVector2 Intersection;
                Distance = lineA.DistanceToPoint(PointOnLine, out Intersection);
                Debug.Assert(Distance == 0);
                Debug.Assert(Intersection == PointOnLine);

                //Check if we go past the line in X axis
                GridVector2 PointLeftOfLine = new GridVector2(-10, 3);
                GridVector2 PointRightOfLine = new GridVector2(10, 3);
                Distance = lineA.DistanceToPoint(PointLeftOfLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == lineA.A);

                Distance = lineA.DistanceToPoint(PointRightOfLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == lineA.B);

                //Check if we go above or below line
                GridVector2 PointAboveLine = new GridVector2(3, 8);
                GridVector2 PointBelowLine = new GridVector2(3, -2);
                Distance = lineA.DistanceToPoint(PointAboveLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == new GridVector2(3, 3));

                Distance = lineA.DistanceToPoint(PointBelowLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == new GridVector2(3, 3));
            }

            //Check edge conditions for a vertical line
            {
                GridLineSegment lineB = new GridLineSegment(new GridVector2(3, -5),
                                                               new GridVector2(3, 5));

                GridVector2 PointOnLine = new GridVector2(3, 2);
                double Distance;
                GridVector2 Intersection;
                Distance = lineB.DistanceToPoint(PointOnLine, out Intersection);
                Debug.Assert(Distance == 0);
                Debug.Assert(Intersection == PointOnLine);

                //Check if we go above or below line
                GridVector2 PointAboveLine = new GridVector2(3, 10);
                GridVector2 PointBelowLine = new GridVector2(3, -10);
                Distance = lineB.DistanceToPoint(PointAboveLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == lineB.B);

                Distance = lineB.DistanceToPoint(PointBelowLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == lineB.A);

                //Check if we go left or right of line
                GridVector2 PointLeftOfLine = new GridVector2(-2, 4);
                GridVector2 PointRightOfLine = new GridVector2(8, 4);
                Distance = lineB.DistanceToPoint(PointLeftOfLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == new GridVector2(3, 4));

                Distance = lineB.DistanceToPoint(PointRightOfLine, out Intersection);
                Debug.Assert(Distance == 5);
                Debug.Assert(Intersection == new GridVector2(3, 4));
            }

            {   //Check the diagonal line through the axis center
                GridLineSegment lineC = new GridLineSegment(new GridVector2(-5, -5),
                                                               new GridVector2(5, 5));

                GridVector2 PointOnLine = new GridVector2(0, 0);
                double Distance;
                GridVector2 Intersection;
                Distance = lineC.DistanceToPoint(PointOnLine, out Intersection);
                Debug.Assert(Distance == 0);
                Debug.Assert(Intersection == PointOnLine);

                GridVector2 PointOffLine = new GridVector2(-5, 5);
                Distance = lineC.DistanceToPoint(PointOffLine, out Intersection);
                Debug.Assert(Distance == Math.Sqrt(Math.Pow(5, 2) + Math.Pow(5,2)));
                Debug.Assert(Intersection == new GridVector2(0,0));

                GridVector2 PointPastEdge = new GridVector2(-10, 0);
                Distance = lineC.DistanceToPoint(PointPastEdge, out Intersection);
                Debug.Assert(Distance == Math.Sqrt(Math.Pow(5, 2) + Math.Pow(5,2)));
                Debug.Assert(Intersection == new GridVector2(-5,-5));
            }

            {   //Check the diagonal line through the axis center
                GridLineSegment lineD = new GridLineSegment(new GridVector2(-6, -4),
                                                               new GridVector2(4, 6));

                GridVector2 PointOnLine = new GridVector2(-1, 1);
                double Distance;
                GridVector2 Intersection;
                Distance = lineD.DistanceToPoint(PointOnLine, out Intersection);
                Debug.Assert(Distance == 0);
                Debug.Assert(Intersection == PointOnLine);

                GridVector2 PointOffLine = new GridVector2(-6, 6);
                Distance = lineD.DistanceToPoint(PointOffLine, out Intersection);
                Debug.Assert(Distance == Math.Sqrt(Math.Pow(5, 2) + Math.Pow(5, 2)));
                Debug.Assert(Intersection == new GridVector2(-1, 1));

                GridVector2 PointPastEdge = new GridVector2(9, 1);
                Distance = lineD.DistanceToPoint(PointPastEdge, out Intersection);
                Debug.Assert(Distance == Math.Sqrt(Math.Pow(5, 2) + Math.Pow(5, 2)));
                Debug.Assert(Intersection == new GridVector2(4, 6));
            }
        }
示例#28
0
 /// <summary>
 /// Maps a point from section space into the volume space
 /// </summary>
 /// <param name="?"></param>
 /// <returns></returns>
 public override bool TrySectionToVolume(GridVector2 P, out GridVector2 transformedP)
 {
     return this.VolumeTransform.TryTransform(P, out transformedP);
 }
示例#29
0
 /// <summary>
 /// Maps a point from volume space into the section space
 /// </summary>
 /// <param name="?"></param>
 /// <returns></returns>
 public override bool TryVolumeToSection(GridVector2 P, out GridVector2 transformedP)
 {
     return this.VolumeTransform.TryInverseTransform(P, out transformedP);
 }
示例#30
0
文件: LineTest.cs 项目: abordt/Viking
        public void GridLineSegmentIntersects()
        {
            //
            // TODO: Add test logic	here
            //

            GridLineSegment lineA = new GridLineSegment(new GridVector2(-5,3),
                                                        new GridVector2(5,3));
            GridLineSegment lineB = new GridLineSegment(new GridVector2(3,-5),
                                                        new GridVector2(3,5));
            GridLineSegment lineC = new GridLineSegment(new GridVector2(-6, -5),
                                                        new GridVector2(-6, 5));
            GridLineSegment lineD = new GridLineSegment(new GridVector2(-9, 8),
                                                        new GridVector2(1, -8));
            GridLineSegment lineE = new GridLineSegment(new GridVector2(-9, 8),
                                                        new GridVector2(1, -2));

            GridVector2 intersect = new GridVector2();
            bool result = lineA.Intersects(lineB, out intersect);
            Debug.Assert(result == true);
            Debug.Assert(intersect.X == 3 && intersect.Y == 3);

            result = lineA.Intersects(lineC, out intersect);
            Debug.Assert(result == false);

            result = lineA.Intersects(lineD, out intersect);
            Debug.Assert(result == false);
              //      Debug.Assert(intersect.X == -4 && intersect.Y == 3);

            result = lineA.Intersects(lineE, out intersect);
            Debug.Assert(result == true);
            Debug.Assert(intersect.X == -4 && intersect.Y == 3);
        }