Exportar (0) Imprimir
Expandir todo

Transform (Clase)

Actualización: noviembre 2007

Define la funcionalidad que permite las transformaciones en un plano 2D. Las transformaciones incluyen la rotación (RotateTransform), el ajuste de escala (ScaleTransform), el sesgado (SkewTransform) y la traslación (TranslateTransform). Esta jerarquía de clases difiere de la estructura Matrix porque es una clase y admite la semántica de animación y enumeración.

Espacio de nombres:  System.Windows.Media
Ensamblado:  PresentationCore (en PresentationCore.dll)

[TypeConverterAttribute(typeof(TransformConverter))]
[LocalizabilityAttribute(LocalizationCategory.None, Readability = Readability.Unreadable)]
public abstract class Transform : GeneralTransform
/** @attribute TypeConverterAttribute(TransformConverter) */
/** @attribute LocalizabilityAttribute(LocalizationCategory.None, Readability = Readability.Unreadable) */
public abstract class Transform extends GeneralTransform
public abstract class Transform extends GeneralTransform
Esta clase es abstracta; vea en Jerarquía de herencia las clases derivadas no abstractas utilizables en XAML.

Utilice la clase MatrixTransform para crear transformaciones personalizadas que no proporcionen las clases RotateTransform, ScaleTransform, SkewTransform y TranslateTransform.

Un plano x-y 2D utiliza una matriz de 3x3 para las transformaciones. Puede multiplicar las matrices de transformación afín para formar transformaciones lineales, como la rotación y el sesgado (recorte) seguidos de la traslación.

La columna final de una matriz de transformación afín es igual a (0, 0, 1); por consiguiente, sólo hay que especificar los miembros de las dos primeras columnas.

Un objeto Matrix de Windows Presentation Foundation (WPF) tiene la estructura siguiente:

Los miembros en la última fila, OffsetX y OffsetY, representan los valores de traslación.

Los métodos y propiedades suelen especificar la matriz de transformación como un vector que sólo tiene seis miembros; son éstos:

    (M11, M12, M21, M22, OffsetX, OffsetY)

En este ejemplo se muestra cómo girar un objeto. El ejemplo crea primero un objeto RotateTransform y, a continuación, especifica su propiedad Angle en grados.

En el ejemplo siguiente se gira un objeto Polyline 45 grados sobre su esquina superior izquierda.

<Canvas Height="200" Width="200">

  <!-- Rotates the Polyline 45 degrees about the point (0,0). -->
  <Polyline Points="25,25 0,50 25,75 50,50 25,25 25,0" 
    Stroke="Blue" StrokeThickness="10"
    Canvas.Left="75" Canvas.Top="50">
    <Polyline.RenderTransform>
      <RotateTransform CenterX="0" CenterY="0" Angle="45" />
    </Polyline.RenderTransform>
  </Polyline>
</Canvas>


// Create a Polyline.
Polyline polyline1 = new Polyline();
polyline1.Points.Add(new Point(25, 25));
polyline1.Points.Add(new Point(0, 50));
polyline1.Points.Add(new Point(25, 75));
polyline1.Points.Add(new Point(50, 50));
polyline1.Points.Add(new Point(25, 25));
polyline1.Points.Add(new Point(25, 0));
polyline1.Stroke = Brushes.Blue;
polyline1.StrokeThickness = 10;

// Create a RotateTransform to rotate
// the Polyline 45 degrees about its
// top-left corner.
RotateTransform rotateTransform1 =
    new RotateTransform(45);
polyline1.RenderTransform = rotateTransform1;

// Create a Canvas to contain the Polyline.
Canvas canvas1 = new Canvas();
canvas1.Width = 200;
canvas1.Height = 200;
Canvas.SetLeft(polyline1, 75);
Canvas.SetTop(polyline1, 50);
canvas1.Children.Add(polyline1);


Las propiedades CenterX y CenterY del objeto RotateTransform especifican el punto sobre el que gira el objeto. Este punto central se expresa en el espacio de la coordenada del elemento que se transforma. De forma predeterminada, se aplica la rotación a (0,0) que es la esquina superior izquierda del objeto que se va a transformar.

En el ejemplo siguiente se gira en el sentido de las agujas del reloj un objeto Polyline 45 grados sobre el punto (25,50).

<Canvas Height="200" Width="200">

  <!-- Rotates the Polyline 45 degrees about the point (25,50). -->
  <Polyline Points="25,25 0,50 25,75 50,50 25,25 25,0" 
    Stroke="Blue" StrokeThickness="10"
    Canvas.Left="75" Canvas.Top="50">
    <Polyline.RenderTransform>
      <RotateTransform CenterX="25" CenterY="50" Angle="45" />
    </Polyline.RenderTransform>
  </Polyline>
</Canvas>


// Create a Polyline.
Polyline polyline2 = new Polyline();
polyline2.Points = polyline1.Points;
polyline2.Stroke = Brushes.Blue;
polyline2.StrokeThickness = 10;

// Create a RotateTransform to rotate
// the Polyline 45 degrees about the
// point (25,50).
RotateTransform rotateTransform2 =
    new RotateTransform(45);
rotateTransform2.CenterX = 25;
rotateTransform2.CenterY = 50;
polyline2.RenderTransform = rotateTransform2;

// Create a Canvas to contain the Polyline.
Canvas canvas2 = new Canvas();
canvas2.Width = 200;
canvas2.Height = 200;
Canvas.SetLeft(polyline2, 75);
Canvas.SetTop(polyline2, 50);
canvas2.Children.Add(polyline2);


La ilustración siguiente muestra los resultados de aplicar un objeto Transform a los dos objetos.

Dos objetos que giran 45 grados respecto a diferentes centros de rotación
rotaciones de 45 grados con diferentes centros

El objeto Polyline de los ejemplos anteriores es un objeto UIElement. Al aplicar un objeto Transform a la propiedad RenderTransform de un control UIElement, se puede utilizar la propiedad RenderTransformOrigin para especificar un origen para cada objeto Transform que aplique al elemento. Dado que la propiedad RenderTransformOrigin utiliza coordenadas relativas, se puede aplicar una transformación al centro del elemento aunque no se conozca su tamaño. Para obtener más información y un ejemplo, vea Cómo: Especificar el origen de una transformación utilizando valores relativos.

Para obtener el ejemplo completo, vea Ejemplo 2-D Transforms.

Más código

Cómo: Ajustar la escala de un elementoEn este ejemplo se muestra cómo usar un objeto ScaleTransform para ajustar la escala de un elemento.
Cómo: Sesgar un elementoEn este ejemplo se muestra cómo usar un objeto SkewTransform para sesgar un elemento. Un sesgo, que también se conoce como distorsión, es una transformación que expande el espacio de coordenadas de una manera no uniforme. SkewTransform suele usarse para simular una profundidad 3D en objetos 2D.
Cómo: Trasladar un elementoEn este ejemplo se muestra cómo trasladar (mover) un elemento mediante TranslateTransform.
Cómo: Hacer que un elemento gire en su posiciónEn este ejemplo se muestra cómo hacer girar un elemento mediante una clase RotateTransform y una clase DoubleAnimation.
Cómo: Transformar un pincelEn este ejemplo se muestra cómo transformar objetos Brush utilizando sus dos propiedades de transformación: RelativeTransform y Transform.
Cómo: Aplicar una transformación a un elemento cuando se provoca un eventoEn este ejemplo se muestra cómo aplicar ScaleTransform cuando se provoca un evento. El concepto que se muestra aquí es el mismo que se utiliza para aplicar otros tipos de transformaciones. Para obtener más información sobre los tipos de transformaciones disponibles, vea la clase Transform o la Información general sobre transformaciones.
Cómo: Aplicar una transformación a un BitmapImageEn este ejemplo se muestra cómo aplicar Transform a BitmapImage.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows Vista

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft