问当图像不对齐x-y轴时，泛化ScaleTransform (WPF)。

EN

private ImageResizing(Image image)
        {
            if (image == null)
                throw new ArgumentNullException("image");

           _image = image;
            TransformGroup tg = new TransformGroup();

            image.RenderTransformOrigin = new Point(0.5, 0.5);  // All transforms will be based on the center of the rendered element.
            tg.Children.Add(image.RenderTransform);             // Keeps whatever transforms have already been applied.
            image.RenderTransform = tg; 
            _adorner = new MyImageAdorner(image);               // Create the adorner.

            InstallAdorner();                                   // Get the Adorner Layer and add the Adorner.
        }

 public MyImageAdorner(UIElement adornedElement)
      : base(adornedElement)
    {
        visualChildren = new VisualCollection(this);


        // Initialize the Movement and Rotation thumbs.
        BuildAdornerRotate(ref moveHandle, Cursors.SizeAll);
        BuildAdornerRotate(ref rotateHandle, Cursors.Hand);

        // Add handlers for move and rotate.
        moveHandle.DragDelta += new DragDeltaEventHandler(moveHandle_DragDelta);
        moveHandle.DragCompleted += new DragCompletedEventHandler(moveHandle_DragCompleted);
        rotateHandle.DragDelta += new DragDeltaEventHandler(rotateHandle_DragDelta);
        rotateHandle.DragCompleted += new DragCompletedEventHandler(rotateHandle_DragCompleted);


        // Initialize the Resizing (i.e., corner) thumbs with specialized cursors.
        BuildAdornerCorner(ref topLeft, Cursors.SizeNWSE);

        // Add handlers for resizing.
        topLeft.DragDelta += new DragDeltaEventHandler(TopLeft_DragDelta);

        topLeft.DragCompleted += TopLeft_DragCompleted;

        // Put the outline border arround the image. The outline will be moved by the DragDelta's
        BorderTheImage();
    }

  #region [Rotate]
    /// <summary>
    /// Rotate the Adorner Outline about its center point. The Outline rotation will be applied to the image
    /// in the DragCompleted event.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void rotateHandle_DragDelta(object sender, DragDeltaEventArgs e)
    {
        // Get the position of the mouse relative to the Thumb.  (All cooridnates in Render Space)
        Point pos = Mouse.GetPosition(this);

        // Render origin is set at center of the adorned element. (all coordinates are in rendering space).
        double CenterX = AdornedElement.RenderSize.Width / 2;
        double CenterY = AdornedElement.RenderSize.Height / 2;

        double deltaX = pos.X - CenterX;
        double deltaY = pos.Y - CenterY;

        double angle;
        if (deltaY.Equals(0))
        {
            if (!deltaX.Equals(0))
                angle = 90;
            else
                return;

        }
        else
        {
            double tan = deltaX / deltaY;
            angle = Math.Atan(tan);  angle = angle * 180 / Math.PI;
        }

        // If the mouse crosses the vertical center, 
        // find the complementary angle.
        if (deltaY > 0)
            angle = 180 - Math.Abs(angle);

        // Rotate left if the mouse moves left and right
        // if the mouse moves right.
        if (deltaX < 0)
            angle = -Math.Abs(angle);
        else
            angle = Math.Abs(angle);

        if (double.IsNaN(angle))
            return;

        // Apply the rotation to the outline.  All Transforms are set to Render Center.
        rotation.Angle = angle;
        rotation.CenterX = CenterX;
        rotation.CenterY = CenterY;
        outline.RenderTransform = rotation;
    }

    /// Rotates image to the same angle as outline arround the render origin.
    void rotateHandle_DragCompleted(object sender, DragCompletedEventArgs e)
    {
        // Get Rotation Angle from outline. All element rendering is set to rendering center.
        RotateTransform _rt = outline.RenderTransform as RotateTransform;

        // Add RotateTransform to the adorned element.
        TransformGroup gT = AdornedElement.RenderTransform as TransformGroup;
        RotateTransform rT = new RotateTransform(_rt.Angle);
        gT.Children.Insert(0, rT);
        AdornedElement.RenderTransform = gT;

        outline.RenderTransform = Transform.Identity;  // clear transform from outline.
    }
    #endregion  //Rotate


 #region [TopLeft Corner
    // Top Left Corner is being dragged. Anchor is Bottom Right.
    void TopLeft_DragDelta(object sender, DragDeltaEventArgs e)
    {
        ScaleTransform sT = new ScaleTransform(1 - e.HorizontalChange / outline.ActualWidth, 1 - e.VerticalChange / outline.ActualHeight,
            outline.ActualWidth, outline.ActualHeight);

        outline.RenderTransform = sT;   // This will immediately show the new outline without changing the Image.
    }



    /// The resizing outline for the TopLeft is based on the bottom right-corner. The resizing transform for the
    /// element, however, is based on the render origin being in the center. Therefore, the Scale transform 
    /// received from the outling must be recalculated to have the same effect--only from the rendering center.
    /// 
    /// TopLeft_DragCompleted resize the element rendering.
    private void TopLeft_DragCompleted(object sender, DragCompletedEventArgs e)
    {
        // Get new scaling from the Outline.
        ScaleTransform _sT = outline.RenderTransform as ScaleTransform;
        scale.ScaleX *= _sT.ScaleX; scale.ScaleY *= _sT.ScaleY;

        Point Center = new Point(AdornedElement.RenderSize.Width/2, AdornedElement.RenderSize.Height/2);

        TransformGroup gT = AdornedElement.RenderTransform as TransformGroup;

        ScaleTransform sT = new ScaleTransform( _sT.ScaleX, _sT.ScaleY, Center.X, Center.Y);
        gT.Children.Insert(0, sT);

        AdornedElement.RenderTransform = gT;
        outline.RenderTransform = Transform.Identity;           // Clear outline transforms. (Same as null).
    }
    #endregion