C# Windows.Vector类代码示例

 public TestingCompoundVertexInfo(Vector springForce, Vector repulsionForce, Vector gravityForce, Vector applicationForce)
 {
     SpringForce = springForce;
     RepulsionForce = repulsionForce;
     GravityForce = gravityForce;
     ApplicationForce = applicationForce;
 }

        public NodeViewModel(Node node, Vector location, IControlTypesResolver controlTypesResolver)
        {
            Node = node;
            Title = node.Title;
            Location = new CanvasPoint(location);
            ControlTypesResolver = controlTypesResolver;

            foreach (var pin in node.InputPins)
            {
                AddInputPin(pin);
            }

            foreach (var pin in node.OutputPins)
            {
                AddOutputPin(pin);
            }

            node.Processed += OnNodeProcessed;
            node.PinsChanged += OnNodePinsChanged;

            _disposable = Disposable.Create(() =>
            {
                node.PinsChanged -= OnNodePinsChanged;
                node.Processed -= OnNodeProcessed;
            });
        }

        public void TestBoundingCirclePushBackLeftTop()
        {
            //Preconfig
            int radius = 20;
            Vector position = new Vector(100f, 100f);
            Vector ballPos = new Vector(100, 100);
            Vector hitPoint = new Vector(120 - 14.1421f, 120 - 14.1421f);

            Vector ballSpeed = hitPoint - ballPos;

            Vector expectedPushBack = (radius * 2 / 1.9f) * ((hitPoint - (position + new Vector(radius, radius)))).AsNormalized();

            Vector pushBackVec;

            //Creation
            Bumper parent = new Bumper();
            BoundingCircle bC2 = new BoundingCircle(radius, position);
            BoundingContainer bCont = new BoundingContainer(parent);
            bCont.AddBoundingBox(bC2);

            //Operation
            parent.Location = (new Vector(0, 0));
            pushBackVec = bC2.GetOutOfAreaPush(radius * 2, hitPoint, ballSpeed, ballPos);

            //Assertion
            Assert.AreEqual(expectedPushBack, pushBackVec);
        }

		public override void ApplyFilter(int[] pixels, int width, int height, Vector[,] field)
		{
			double maxLength = Double.NegativeInfinity;
			double minLength = Double.PositiveInfinity;

			for (int ix = 0; ix < width; ix++)
			{
				for (int iy = 0; iy < height; iy++)
				{
					var length = field[ix, iy].Length;
					if (length > maxLength) maxLength = length;
					if (length < minLength) minLength = length;
				}
			}

			for (int i = 0; i < width * height; i++)
			{
				HsbColor color = HsbColor.FromArgb(pixels[i]);

				int ix = i % width;
				int iy = i / width;
				var length = field[ix, iy].Length;

				var ratio = (length - minLength) / (maxLength - minLength);
				if (ratio.IsNaN())
					ratio = 0;

				var paletteColor = Palette.GetColor(ratio).ToHsbColor();

				color.Hue = paletteColor.Hue;
				color.Saturation = paletteColor.Saturation;

				pixels[i] = color.ToArgb();
			}
		}

		public IrregularCell(Vector leftBottom, Vector rightBottom, Vector rightTop, Vector leftTop)
		{
			this.leftBottom = leftBottom;
			this.rightBottom = rightBottom;
			this.rightTop = rightTop;
			this.leftTop = leftTop;
		}

 // Constructor function
 public Vertex(int id, Vector position, HashSet<int> connections)
 {
     this.ID = id;
     this.PositionVector = position;
     this.connectedVertexIDs = connections;
     this.mass = 1;
 }

        /// <summary>
        /// Play with the NonlinearRandom tester to come up with values
        /// </summary>
        public RandomBellArgs(double leftArmLength, double leftArmAngle, double rightArmLength, double rightArmAngle)
        {
            List<Point3D> controlPoints = new List<Point3D>();

            // Arm1
            if (!leftArmLength.IsNearZero())
            {
                Vector arm1 = new Vector(1, 1).ToUnit() * leftArmLength;

                controlPoints.Add(arm1.ToVector3D().GetRotatedVector(new Vector3D(0, 0, -1), leftArmAngle).ToPoint());
            }

            // Arm2
            if (!rightArmLength.IsNearZero())
            {
                Vector arm2 = new Vector(-1, -1).ToUnit() * rightArmLength;

                Vector3D arm2Rotated = arm2.
                    ToVector3D().
                    GetRotatedVector(new Vector3D(0, 0, -1), rightArmAngle);

                controlPoints.Add(new Point3D(1 + arm2Rotated.X, 1 + arm2Rotated.Y, 0));
            }

            // Bezier
            this.Bezier = new BezierSegment3D(0, 1, controlPoints.ToArray(), new[] { new Point3D(0, 0, 0), new Point3D(1, 1, 0) });
        }

 /// <summary>
 /// Initializes a new character instance.
 /// </summary>
 /// <param name="p0">Lower left character position.</param>
 /// <param name="size">Size of the character.</param>
 /// <param name="uiTaskSchedule">Scheduler associated with the UI thread.</param>
 public Character(Point p0, Vector size, TaskScheduler uiTaskSchedule)
     : base(uiTaskSchedule)
 {
     this.Position = new Quadrilateral(p0, size);
     this.Gravity = CharacterGravityState.Down;
     this.Animation = CharacterAnimationState.Down;
 }

        public override Point GetWaypoint()
        {
            // update collided point status
            _me.SetStatus(_mo.X, _mo.Y, MapElementStatus.Collided);

            Vector vector = new Vector(_mo.X - _posX, _mo.Y - _posY);
            
            // opposite direction
            vector.Negate();

            // normalize vector (length = 1)
            vector.Normalize();

            // calculate distances to every border
            double tLeft = (-_posX) / vector.X;
            double tRight = (800 - _posX) / vector.X;
            double tTop = (-_posY) / vector.Y;
            double tBottom = (600 - _posY) / vector.Y;

            vector *= 20;

            _point.X = (int)_posX + (int)vector.X;
            _point.Y = (int)_posY + (int)vector.Y;

            _point.Status = MapElementStatus.Waypoint;

            return _point;
        }

		public void Equals ()
		{
			Vector v = new Vector (4, 5);
			Assert.IsTrue (v.Equals (new Vector (4, 5)));
			Assert.IsFalse (v.Equals (new Vector (5, 4)));
			Assert.IsFalse (v.Equals (new object()));
		}

 /// <summary>
 /// Private constructor.
 /// </summary>
 /// <param name="physicalCenterOffsetFromTag"></param>
 /// <param name="orientationOffsetFromTag"></param>
 private ByteTagDefinition(
     Vector physicalCenterOffsetFromTag,
     double orientationOffsetFromTag)
 {
     this.physicalCenterOffsetFromTag = physicalCenterOffsetFromTag;
     this.orientationOffsetFromTag = orientationOffsetFromTag;
 }

        public Component GetClosestComponent(int x, int y, ComponentFilter cf)
        {
            Component result = null;
            int componentType = cf.Type;
            List<Component> components = m_vComponents[componentType];
            Vector v = new Vector(x,y);
            double maxLengthSquared = 0;

            if (components.Count > 0)
            {
                foreach(var c in components)
                {
                    if(cf.TestComponent(c))
                    {
                        GameObject go = c.GetParent();
                        double lengthSquared = (v - go.GetPosition()).LengthSquared; 
                        if(lengthSquared < maxLengthSquared || result == null)
                        {
                            maxLengthSquared = lengthSquared;
                            result = c;
                        }
                    }
                }
            }
            return result;
        }

        public void TestBoundingLineReflect270Left()
        {
            //Preconfig
            Vector position1 = new Vector(0f, 50f);
            Vector target1 = new Vector(50f, 50f);

            Vector ballSpeed = new Vector(5, 0);
            Vector ballPos = new Vector(-20, 50);

            Vector hitPoint = new Vector(0, 50);
            Vector expectedReflection = -ballSpeed;
            expectedReflection.Normalize();
            Vector reflection;

            //Creation
            Line parent = new Line();
            BoundingContainer bCont = new BoundingContainer(parent);
            BoundingLine bL1 = new BoundingLine(position1, target1);
            bCont.AddBoundingBox(bL1);
            parent.Location = (new Vector(0, 0));

            //Operation
            reflection = bL1.Reflect(ballSpeed, hitPoint, ballPos);
            reflection.Normalize();

            //Assertion
            Assert.AreEqual(expectedReflection, reflection);
        }

 public Physics(GameObject gameObject, double topSpeed, Vector velocity)
 {
     _lastUpdate = DateTime.Now.Ticks;
     GameObject = gameObject;
     _topSpeed = topSpeed;
     Velocity = velocity;
 }

        public static Tuple<Point[], Point[], Point[]> Subdivide(Point[] l1, Point[] l2)
        {
            var allPoints = l1.Concat(l2).ToArray();
            var pcaLine = PCALine.Compute(allPoints);

            var minPoint = allPoints.Minimizer(p => ProjectedLinePosition(p, pcaLine.Item1, pcaLine.Item2)).ProjectOnLine(pcaLine);
            var maxPoint = allPoints.Minimizer(p => -ProjectedLinePosition(p, pcaLine.Item1, pcaLine.Item2)).ProjectOnLine(pcaLine);

            var samples = SampleSegment(minPoint, maxPoint);

            var points1 = new List<Point>();
            var points2 = new List<Point>();
            var centers = new List<Point>();
            var perp = new Vector(-pcaLine.Item2.Y, pcaLine.Item2.X);
            for (int i = 0; i < samples.Length; ++i)
            {
                var p1 = DirectionalProject(samples[i], perp, l1);
                var p2 = DirectionalProject(samples[i], perp, l2);
                if (p1 != null && p2 != null)
                {
                    points1.Add(p1.Value);
                    points2.Add(p2.Value);
                    centers.Add(samples[i]);
                }
            }

            return Tuple.Create(points1.ToArray(), points2.ToArray(), centers.ToArray());
        }