WPF中RotateTransform旋转图片时窗口超出屏幕尺寸问题求助

I get it, this is a common gotcha with LayoutTransform in WPF—when you rotate an element 90° or 270°, its layout dimensions swap, but your initial size calculation only accounts for the original orientation. Let's break down how to fix this without distorting the image.

The Root Cause #

When you apply a RotateTransform via LayoutTransform, WPF recalculates the element's layout bounds after applying the transform. So if your original image is taller than the screen, rotating it 90° swaps its effective width and height—suddenly the "width" of the rotated image is the original height, which exceeds the screen width, pushing the window off-screen.

Your initial size logic only considers the original image dimensions, not the rotated state. Swapping Width and Height directly breaks the aspect ratio because you're not scaling proportionally based on the rotated bounds.

The Fix: Recalculate Size Based on Rotation Angle #

We need to adjust our size calculation logic to account for the current rotation. Here's how to do it:

1. Create a reusable method that calculates the correct image size based on whether we're in a portrait (0°/180°) or landscape (90°/270°) rotated state.
2. Call this method every time we rotate the image to update the size dynamically.

Modified Code Example

First, update your MainWindow.xaml.cs with these changes:

using System;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;

namespace RotateTest
{
    public partial class MainWindow : Window
    {
        int Degrees;

        public MainWindow()
        {
            InitializeComponent();
            ContentRendered += MainWindow_ContentRendered;
            KeyDown += MainWindow_KeyDown;
        }

        private void MainWindow_KeyDown(object sender, KeyEventArgs e)
        {
            switch (e.Key)
            {
                case Key.Up:
                    Rotate(true);
                    break;
                case Key.Down:
                    Rotate(false);
                    break;
            }
        }

        private void MainWindow_ContentRendered(object sender, EventArgs e)
        {
            // Initialize size for 0° rotation
            CalculateImageSize(0);
        }

        void Rotate(int degrees)
        {
            var rt = new RotateTransform { Angle = Degrees = degrees };
            img.LayoutTransform = rt;
            // Recalculate size after rotation
            CalculateImageSize(degrees);
        }

        void Rotate(bool right)
        {
            switch (Degrees)
            {
                case 0:
                    Rotate(right ? 270 : 90);
                    break;
                case 90:
                    Rotate(right ? 0 : 180);
                    break;
                case 180:
                    Rotate(right ? 90 : 270);
                    break;
                case 270:
                    Rotate(right ? 180 : 0);
                    break;
            }
        }

        private void CalculateImageSize(int rotationDegrees)
        {
            int interfaceHeight = 90;
            double originalImgWidth = img.Source.Width;
            double originalImgHeight = img.Source.Height;

            // For 90°/270° rotations, effective display dimensions swap
            bool isRotated90Or270 = rotationDegrees % 180 != 0;
            double effectiveWidth = isRotated90Or270 ? originalImgHeight : originalImgWidth;
            double effectiveHeight = isRotated90Or270 ? originalImgWidth : originalImgHeight;

            // Calculate maximum allowed size based on screen bounds
            double maxAllowedWidth = Math.Min(SystemParameters.PrimaryScreenWidth, effectiveWidth);
            double maxAllowedHeight = Math.Min(SystemParameters.PrimaryScreenHeight - interfaceHeight, effectiveHeight);

            // Get the correct aspect ratio to maintain image proportions
            double aspectRatio = Math.Min(maxAllowedWidth / effectiveWidth, maxAllowedHeight / effectiveHeight);

            // Apply the scaled size to the image
            img.Width = originalImgWidth * aspectRatio;
            img.Height = originalImgHeight * aspectRatio;
        }
    }
}

How This Works #

• Effective Dimensions: When rotated 90°/270°, we treat the original image height as the new "width" and original width as the new "height" for our size calculation.
• Proportional Scaling: We calculate the aspect ratio based on these effective dimensions, ensuring the rotated image fits within the screen without distortion.
• Dynamic Update: Every rotation triggers a recalculation, so the window always adapts to the rotated image's bounds while staying within the screen.

Why This Beats Swapping Width/Height #

Instead of forcing arbitrary width/height values, we scale the image proportionally based on the rotated layout requirements. This keeps the image's aspect ratio intact while ensuring the window never exceeds the screen dimensions.

内容的提问来源于stack exchange，提问作者Ruben2776