C# Media.MatrixTransform类代码示例

        public static List<Point> Generate(int n = 1000, double width = 1.0, double height = 1.0)
        {
            // Probabilities
            double[] p = {0.85, .92, .99, 1.00};

            // Transformations
            var a1 = new MatrixTransform(new Matrix(0.85, -0.04, 0.04, 0.85, 0, 1.6));
            var a2 = new MatrixTransform(new Matrix(0.20, 0.23, -0.26, 0.22, 0, 1.6));
            var a3 = new MatrixTransform(new Matrix(-0.15, 0.26, 0.28, 0.24, 0, 0.44));
            var a4 = new MatrixTransform(new Matrix(0, 0, 0, 0.16, 0, 0));
            var random = new Random();
            var point = new Point(0.5, 0.5);
            var points = new List<Point>();

            // Transformation for [-3,3,0,10] => output coordinates
            var T = new MatrixTransform(new Matrix(width/6.0, 0, 0, -height/10.1, width/2.0, height));

            for (int i = 0; i < n; i++)
            {
                var r = random.NextDouble();

                if (r < p[0])
                    point = a1.Transform(point);
                else if (r < p[1])
                    point = a2.Transform(point);
                else if (r < p[2])
                    point = a3.Transform(point);
                else
                    point = a4.Transform(point);

                points.Add(T.Transform(point));
            }
            return points;
        }

 public CanvasEx()
 	:base()
 {
     ClipToBounds = true;
     _transform = (MatrixTransform)MatrixTransform.Identity;
     _translate = new TranslateTransform(-Offset.X, -Offset.Y);
 }

		public void Set ()
		{
			MatrixTransform mt = new MatrixTransform ();
			mt.Matrix = new Matrix (1, 2, 3, 4, 5, 6);
			MatrixTest.CheckMatrix (mt.Matrix, 1, 2, 3, 4, 5, 6, "custom");
			Assert.IsFalse (mt.Matrix.IsIdentity, "IsNotIdentity");
		}

		public void Value_Matrix (bool refresh)
		{
			MatrixTransform mt = new MatrixTransform ();

			TransformGroup tg = new TransformGroup ();
			tg.Children.Add (mt);
			Assert.AreEqual (1, tg.Children.Count, "Children-1");
			Assert.IsTrue (tg.Value.IsIdentity, "IsIdentity-1");

			mt.Matrix = new Matrix (2.0, 0.0, 0.0, 0.5, 0.0, 0.0);
			Assert.AreEqual (1, tg.Children.Count, "Children-2");
			// update was made inside TransformGroup...
			Assert.IsFalse ((tg.Children [0] as MatrixTransform).Matrix.IsIdentity, "IsIdentity-2");

			if (refresh) {
				// ... but Value is not refreshed if changed "indirectly" ...
				Assert.IsTrue (tg.Value.IsIdentity, "IsIdentity-3");
				Assert.IsFalse (mt.Matrix.Equals (tg.Value), "Matrix-3");
			}

			// ... unless the collection is changed
			tg.Children.Add (new MatrixTransform ());
			Assert.AreEqual (2, tg.Children.Count, "Children-4");
			Assert.IsTrue (mt.Matrix.Equals (tg.Value), "Matrix-4");
		}

        private double                      _baseGuidelineY;            // the Y guideline of the text line.

        /// <summary>
        /// Construct drawing state for full text
        /// </summary>
        internal DrawingState(
            DrawingContext                  drawingContext,
            Point                           lineOrigin,
            MatrixTransform                 antiInversion,
            TextMetrics.FullTextLine        currentLine
            )
        {
            _drawingContext = drawingContext;
            _antiInversion = antiInversion;
            _currentLine = currentLine;            

            if (antiInversion == null)
            {
                _lineOrigin = lineOrigin;
            }
            else
            {
                _vectorToLineOrigin = lineOrigin;
            }

            if (_drawingContext != null)
            {
                // LineServices draws GlyphRun and TextDecorations in multiple 
                // callbacks and GlyphRuns may have different baselines. Pushing guideline
                // for each DrawGlyphRun are too costly. We optimize for the common case where
                // GlyphRuns and TextDecorations in the TextLine share the same baseline. 
                _baseGuidelineY = lineOrigin.Y + currentLine.Baseline;

                _drawingContext.PushGuidelineY1(_baseGuidelineY);
            }
        }

		// ********************************************************************
		// Public Methods
		// ********************************************************************
		#region Public Methods

		/// <summary>
		/// Constructor. Initializes class fields.
		/// </summary>
        public AdornerCursorCoordinateDrawer(XYLineChart xyLineChart, UIElement adornedElement, MatrixTransform shapeTransform)
			: base(adornedElement)
		{
			elementTransform = shapeTransform;
			IsHitTestVisible = false;
		    this.xyLineChart = xyLineChart;
		}

        public WpfMultiChart()
        {
            InitializeComponent();

            LoadImages();

            //do not show no data label by default
            ShowNoDataLabel(false);

            dataSeries = new List<TimeSeriesData>();
            plotSeries = new TimeSeriesData();
            shapeTransform = new MatrixTransform();
            chartClip = new PathGeometry();
            optimalGridLineSpacing = new Point(100, 50);
            adorner = new AdornerCursor2(ChartInteractiveCanvas, shapeTransform);
            adorner.CanvasSize = new Size(ChartInteractiveCanvas.ActualWidth, ChartInteractiveCanvas.ActualHeight);

            adorner.PanCursorImage = panCursor;

            panZoomCalculator = new PanZoomCalculator();

            ChartCanvas.SizeChanged += new SizeChangedEventHandler(ChartCanvas_SizeChanged);
            ChartCanvas.IsVisibleChanged += new DependencyPropertyChangedEventHandler(ChartCanvas_IsVisibleChanged);

            NoDataLabel.MouseMove += new MouseEventHandler(NoDataLabel_MouseMove);
            AttachEventsToCanvas(ChartInteractiveCanvas);

            ResizeChart();
        }

 public static StreamGeometry StreamGeometryFromCurve(Curve curve, MatrixTransform graphToCanvas)
 {
     double[] tempX;
     double[] tempY;
     if (graphToCanvas != null)
     {
         tempX = curve.xTransformed.MultiplyBy(graphToCanvas.Matrix.M11).SumWith(graphToCanvas.Matrix.OffsetX);
         tempY = curve.yTransformed.MultiplyBy(graphToCanvas.Matrix.M22).SumWith(graphToCanvas.Matrix.OffsetY);
     }
     else
     {
         tempX = curve.xTransformed; tempY = curve.yTransformed;
     }
     StreamGeometry streamGeometry = new StreamGeometry();
     StreamGeometryContext context = streamGeometry.Open();
     int lines = 0;
     for (int i = 0; i < curve.x.Count(); ++i)
     {
         if (i == 0)
         {
             context.BeginFigure(new Point(tempX[i], tempY[i]), false, false);
         }
         else
         {
             if (curve.includeLinePoint[i])
             {
                 context.LineTo(new Point(tempX[i], tempY[i]), true, false);
                 lines++;
             }
         }
     }
     context.Close();
     return streamGeometry;
 }

        internal override PathFigureCollection GetTransformedFigureCollection(Transform transform)
        {
            // Combine the transform argument with the internal transform
            Transform combined = new MatrixTransform(GetCombinedMatrix(transform));

            PathFigureCollection result = new PathFigureCollection();
            GeometryCollection children = Children;

            if (children != null)
            {
                for (int i = 0; i < children.Count; i++)
                {
                    PathFigureCollection pathFigures = children.Internal_GetItem(i).GetTransformedFigureCollection(combined);
                    if (pathFigures != null)
                    {
                        int count = pathFigures.Count;
                        for (int j = 0; j < count; ++j)
                        {
                            result.Add(pathFigures[j]);
                        }
                    }
                }
            }

            return result;
        }

        public void ResetTransformations()
        {
            _ImageTransform = new MatrixTransform();
            _ImageControl.RenderTransform = ImageTransform;

            CenterImage();
        }

 public VisualHost(MatrixTransform graphToCanvas)
 {
     this.graphToCanvas = graphToCanvas;
     curveList = new List<Curve>();
     _children = new VisualCollection(this);
     //curveGeometry = curve.ToStreamGeometry();
     //_children.Add(drawingVisual);
 }

 /// <summary>
 /// 取得水平翻转的视频捕获
 /// </summary>
 /// <param name="with"></param>
 /// <param name="height"></param>
 /// <returns></returns>
 public Rectangle GetVideoWithFlipHorizontal(int with, int height)
 {
     Rectangle rctg = GetVideo(with, height);
     MatrixTransform mTransform = new MatrixTransform();
     mTransform.Matrix = new Matrix(-1, 0, 0, 1, with, 0);
     rctg.RenderTransform = mTransform;
     return rctg;
 }

        public static void PositionGeometry(XamlShapes.Shape renderedGeometry, IViewport viewport)
        {
            CounterScaleLineWidth(renderedGeometry, viewport.Resolution);
            var matrixTransform = new XamlMedia.MatrixTransform {Matrix = CreateTransformMatrix1(viewport)};
            renderedGeometry.RenderTransform = matrixTransform;

            if (renderedGeometry.Fill != null)
                renderedGeometry.Fill.Transform = matrixTransform.Inverse as XamlMedia.MatrixTransform;
        }

        protected void Create(UIElement element, bool wantsCache, bool wantsTransform)
        {
            if(wantsTransform)
                element.RenderTransform = transform = new SWM.MatrixTransform();

            if(wantsCache)
                element.CacheMode = new SWM.BitmapCache();

            canvas.Children.Add(element);
        }

 public void InitializeComponent() {
     if (_contentLoaded) {
         return;
     }
     _contentLoaded = true;
     System.Windows.Application.LoadComponent(this, new System.Uri("/Invista.Game2;component/Sprite.xaml", System.UriKind.Relative));
     this.MatrixElement = ((System.Windows.Media.MatrixTransform)(this.FindName("MatrixElement")));
     this.RotationElement = ((System.Windows.Media.RotateTransform)(this.FindName("RotationElement")));
     this.LayoutRoot = ((System.Windows.Controls.Grid)(this.FindName("LayoutRoot")));
     this.ContentElement = ((System.Windows.Controls.ContentPresenter)(this.FindName("ContentElement")));
 }