Información general sobre geometría
En esta información general se describe cómo utilizar las clases Windows Presentation Foundation (WPF)Geometry para describir formas. En este tema también se contrastan las diferencias entre los objetos Geometry y los elementos Shape.
Este tema contiene las secciones siguientes.
- ¿Qué es una geometría?
- Comparación entre geometrías yformas
- Propiedades comunes que aceptan un objeto de geometría
- Tipos de geometría simples
- Geometrías de trazado
- Geometrías compuestas
- Geometrías combinadas
- Características de elementos Freezable
- Otras características de las geometrías
- Temas relacionados
¿Qué es una geometría?
La clase Geometry y las clases que derivan de ella, como EllipseGeometry, PathGeometry y CombinedGeometry, permiten describir la geometría de una forma 2D. Estas descripciones geométricas tienen muchos usos, tales como la definición de una forma para pintarla en la pantalla o la definición de pruebas de posicionamiento y de zonas de recorte. Incluso puede utilizar una geometría para definir un trazado de animación.
Los objetos Geometry pueden ser simples, tales como rectángulos y círculos, o bien compuestos, creados a partir de dos o más objetos de geometría. Se pueden crear geometrías más complejas utilizando las clases PathGeometry y StreamGeometry, que permiten describir arcos y curvas.
Dado que Geometry es un tipo de Freezable, los objetos Geometry proporcionan varias características especiales: pueden declararse como recursos, compartirse entre varios objetos, convertirse en objetos de sólo lectura para mejorar el rendimiento, clonarse y convertirse en seguros para subprocesos. Para obtener más información sobre las diferentes características que proporcionan los objetos Freezable, consulte Información general sobre objetos Freezable.
Comparación entre geometrías yformas
Las clases Geometry y Shape parecen similares porque ambas describen formas 2D (compare EllipseGeometry y Ellipse, por ejemplo), pero hay diferencias importantes.
En primer lugar, la clase Geometry hereda de la clase Freezable, mientras que la clase Shape hereda de FrameworkElement. Dado que son elementos, los objetos Shape se pueden representar y participar en el sistema del diseño, mientras que los objetos Geometry no pueden.
Aunque los objetos Shape se pueden utilizar de un modo más directo que los objetos Geometry, los objetos Geometry son más versátiles. Aunque un objeto Shape se utiliza para representar gráficos 2D, un objeto Geometry se puede utilizar para definir el área geométrica para gráficos 2D, definir una zona de recorte o definir un área para pruebas de posicionamiento, por ejemplo.
Forma del trazado
Una forma (Shape), la clase Path, en realidad utiliza una geometría (Geometry) para describir su contenido. Estableciendo la propiedad Data de Path con Geometry y estableciendo sus propiedades Fill y Stroke, puede representar Geometry.
Propiedades comunes que aceptan un objeto de geometría
En las secciones anteriores se ha mencionado que los objetos de geometría se pueden utilizar con otros objetos para diversos propósitos, tales como dibujar formas, realizar animaciones o recortar. En la tabla siguiente se muestra una lista con varias clases que tienen propiedades que aceptan un objeto Geometry.
Tipo |
Propiedad |
|---|---|
Tipos de geometría simples
La clase base para todas las geometrías es la clase abstracta Geometry. Las clases que se derivan de la clase Geometry se pueden agrupar a grandes rasgos en tres categorías: geometrías simples, geometrías de trazado y geometrías compuestas.
Las clases de geometrías simples incluyen LineGeometry, RectangleGeometry y EllipseGeometry, y se utilizan para crear las formas geométricas básicas, como líneas, rectángulos y círculos.
Una LineGeometry se define especificando los puntos inicial y final de la línea.
Una RectangleGeometry se define con una estructura Rect que especifica su posición relativa, así como su alto y ancho. Puede crear un rectángulo redondeado estableciendo las propiedades RadiusX y RadiusY.
Una EllipseGeometry se define mediante un punto central, un radio X y un radio Y. En los ejemplos siguientes se muestra cómo crear geometrías simples con fines de representación y recorte.
Estas mismas formas, así como otras más complejas, se pueden crear utilizando una PathGeometry o combinando objetos de geometría entre sí, pero estas clases proporcionan un medio más sencillo de generar estas formas geométricas básicas.
En el ejemplo siguiente se muestra cómo crear y representar una LineGeometry. Como se ha indicado previamente, un objeto Geometry no puede dibujarse a sí mismo, por lo que en el ejemplo se utiliza una forma Path para representar la línea. Dado que una línea no tiene área, establecer la propiedad Fill de Path no tendría ningún efecto; en su lugar, se especifican sólo las propiedades Stroke y StrokeThickness. En la siguiente ilustración se muestra el resultado del ejemplo.
Objeto LineGeometry dibujado desde (10,20) hasta (100,130)
.gif "LineGeometry")
<Path Stroke="Black" StrokeThickness="1" >
<Path.Data>
<LineGeometry StartPoint="10,20" EndPoint="100,130" />
</Path.Data>
</Path>
Dim myLineGeometry As New LineGeometry()
myLineGeometry.StartPoint = New Point(10,20)
myLineGeometry.EndPoint = New Point(100,130)
Dim myPath As New Path()
myPath.Stroke = Brushes.Black
myPath.StrokeThickness = 1
myPath.Data = myLineGeometry
LineGeometry myLineGeometry = new LineGeometry();
myLineGeometry.StartPoint = new Point(10,20);
myLineGeometry.EndPoint = new Point(100,130);
Path myPath = new Path();
myPath.Stroke = Brushes.Black;
myPath.StrokeThickness = 1;
myPath.Data = myLineGeometry;
En el ejemplo siguiente se muestra cómo crear y representar un objeto EllipseGeometry. En los ejemplos se establece el Center de EllipseGeometry en el punto 50,50 y el radio X y el radio Y se establecen ambos en 50, lo que da lugar a un círculo con un diámetro de 100. El interior de la elipse se pinta asignando un valor a la propiedad Fill del elemento Path, en este caso, Gold. En la siguiente ilustración se muestra el resultado del ejemplo.
Objeto EllipseGeometry dibujado en (50,50)
.gif "EllipseGeometry")
<Path Fill="Gold" Stroke="Black" StrokeThickness="1">
<Path.Data>
<EllipseGeometry Center="50,50" RadiusX="50" RadiusY="50" />
</Path.Data>
</Path>
Dim myEllipseGeometry As New EllipseGeometry()
myEllipseGeometry.Center = New Point(50, 50)
myEllipseGeometry.RadiusX = 50
myEllipseGeometry.RadiusY = 50
Dim myPath As New Path()
myPath.Fill = Brushes.Gold
myPath.Stroke = Brushes.Black
myPath.StrokeThickness = 1
myPath.Data = myEllipseGeometry
EllipseGeometry myEllipseGeometry = new EllipseGeometry();
myEllipseGeometry.Center = new Point(50, 50);
myEllipseGeometry.RadiusX = 50;
myEllipseGeometry.RadiusY = 50;
Path myPath = new Path();
myPath.Fill = Brushes.Gold;
myPath.Stroke = Brushes.Black;
myPath.StrokeThickness = 1;
myPath.Data = myEllipseGeometry;
En el ejemplo siguiente se muestra cómo crear y representar una RectangleGeometry. Una estructura Rect define la posición y las dimensiones del rectángulo. La posición es 50,50; por su parte, el alto y el ancho son ambos 25, con lo que se crea un cuadrado. En la siguiente ilustración se muestra el resultado del ejemplo.
Objeto RectangleGeometry dibujado en 50,50
.gif "RectangleGeometry")
<Path Fill="LemonChiffon" Stroke="Black" StrokeThickness="1">
<Path.Data>
<RectangleGeometry Rect="50,50,25,25" />
</Path.Data>
</Path>
Dim myRectangleGeometry As New RectangleGeometry()
myRectangleGeometry.Rect = New Rect(50,50,25,25)
Dim myPath As New Path()
myPath.Fill = Brushes.LemonChiffon
myPath.Stroke = Brushes.Black
myPath.StrokeThickness = 1
myPath.Data = myRectangleGeometry
RectangleGeometry myRectangleGeometry = new RectangleGeometry();
myRectangleGeometry.Rect = new Rect(50,50,25,25);
Path myPath = new Path();
myPath.Fill = Brushes.LemonChiffon;
myPath.Stroke = Brushes.Black;
myPath.StrokeThickness = 1;
myPath.Data = myRectangleGeometry;
En el ejemplo siguiente se muestra cómo utilizar EllipseGeometry como zona de recorte de una imagen. Un objeto Image se define con un ancho (Width) de 200 y un alto (Height) de 150. Un objeto EllipseGeometry, con un valor de radio X (RadiusX) de 100, un valor de radio Y (RadiusY) de 75 y un valor de centro (Center) de 100,75, se establece en la propiedad Clip de la imagen. Únicamente se muestra la parte de la imagen que está dentro del área de la elipse. En la siguiente ilustración se muestra el resultado del ejemplo.
Objeto EllipseGeometry utilizado para recortar un control de imagen
.png "Image con y sin recorte")
<Image
Source="sampleImages\Waterlilies.jpg"
Width="200" Height="150" HorizontalAlignment="Left">
<Image.Clip>
<EllipseGeometry
RadiusX="100"
RadiusY="75"
Center="100,75"/>
</Image.Clip>
</Image>
' Create the image to clip.
Dim myImage As New Image()
Dim imageUri As New Uri("C:\\Documents and Settings\\All Users\\Documents\My Pictures\\Sample Pictures\\Water lilies.jpg", UriKind.Relative)
myImage.Source = New BitmapImage(imageUri)
myImage.Width = 200
myImage.Height = 150
myImage.HorizontalAlignment = HorizontalAlignment.Left
' Use an EllipseGeometry to define the clip region.
Dim myEllipseGeometry As New EllipseGeometry()
myEllipseGeometry.Center = New Point(100, 75)
myEllipseGeometry.RadiusX = 100
myEllipseGeometry.RadiusY = 75
myImage.Clip = myEllipseGeometry
// Create the image to clip.
Image myImage = new Image();
Uri imageUri =
new Uri(@"C:\\Documents and Settings\\All Users\\Documents\My Pictures\\Sample Pictures\\Water lilies.jpg", UriKind.Relative);
myImage.Source = new BitmapImage(imageUri);
myImage.Width = 200;
myImage.Height = 150;
myImage.HorizontalAlignment = HorizontalAlignment.Left;
// Use an EllipseGeometry to define the clip region.
EllipseGeometry myEllipseGeometry = new EllipseGeometry();
myEllipseGeometry.Center = new Point(100, 75);
myEllipseGeometry.RadiusX = 100;
myEllipseGeometry.RadiusY = 75;
myImage.Clip = myEllipseGeometry;
Geometrías de trazado
La clase PathGeometry y su equivalente ligera, la clase StreamGeometry, proporcionan recursos para describir varias figuras complejas compuestas de arcos, curvas y líneas.
En el núcleo de PathGeometry hay una colección de objetos PathFigure, que se denominan así porque cada figura describe una forma discreta de PathGeometry. Cada PathFigure, a su vez, está compuesta de uno o varios objetos PathSegment, cada uno de los cuales describe un segmento de la figura.
Existen muchos tipos de segmentos.
Tipo de segmento |
Descripción |
Ejemplo |
|---|---|---|
Crea un arco elíptico entre dos puntos. |
||
Crea una curva Bézier cúbica entre dos puntos. |
||
Crea una línea entre dos puntos. |
||
Crea una serie de curvas Bézier cúbicas. |
Consulte la página del tipo PolyBezierSegment. |
|
Crea una serie de líneas. |
Consulte la página del tipo PolyLineSegment. |
|
Crea una serie de curvas Bézier cuadráticas. |
Consulte la página de PolyQuadraticBezierSegment. |
|
Crea una curva Bézier cuadrática. |
Los segmentos de PathFigure se combinan en una sola forma geométrica donde el punto final de cada segmento es el punto inicial del segmento siguiente. La propiedad StartPoint de PathFigure especifica el punto desde el que se dibuja el primer segmento. Cada segmento posterior comienza en el punto final del segmento anterior. Por ejemplo, para definir una línea vertical de 10,50 a 10,150 se establece la propiedad StartPoint en 10,50 y se crea un LineSegment con un valor de 10,150 para la propiedad Point.
En el ejemplo siguiente se crea un objeto PathGeometry simple compuesto de una sola PathFigure con un LineSegment y se muestra mediante un elemento Path. La propiedad StartPoint del objeto PathFigure se establece en 10,20 y LineSegment se define con un punto final de 100,130. En la ilustración siguiente se muestra el PathGeometry creado por este ejemplo.
Objeto PathGeometry que contiene un solo elemento LineSegment
<Path Stroke="Black" StrokeThickness="1">
<Path.Data>
<PathGeometry>
<PathGeometry.Figures>
<PathFigure StartPoint="10,20">
<PathFigure.Segments>
<LineSegment Point="100,130"/>
</PathFigure.Segments>
</PathFigure>
</PathGeometry.Figures>
</PathGeometry>
</Path.Data>
</Path>
' Create a figure that describes a
' line from (10,20) to (100,130).
Dim myPathFigure As New PathFigure()
myPathFigure.StartPoint = New Point(10,20)
myPathFigure.Segments.Add(New LineSegment(New Point(100,130), True)) ' IsStroked
''' Create a PathGeometry to contain the figure.
Dim myPathGeometry As New PathGeometry()
myPathGeometry.Figures.Add(myPathFigure)
' Display the PathGeometry.
Dim myPath As New Path()
myPath.Stroke = Brushes.Black
myPath.StrokeThickness = 1
myPath.Data = myPathGeometry
// Create a figure that describes a
// line from (10,20) to (100,130).
PathFigure myPathFigure = new PathFigure();
myPathFigure.StartPoint = new Point(10,20);
myPathFigure.Segments.Add(
new LineSegment(new Point(100,130),
true /* IsStroked */ ));
/// Create a PathGeometry to contain the figure.
PathGeometry myPathGeometry = new PathGeometry();
myPathGeometry.Figures.Add(myPathFigure);
// Display the PathGeometry.
Path myPath = new Path();
myPath.Stroke = Brushes.Black;
myPath.StrokeThickness = 1;
myPath.Data = myPathGeometry;
Es interesante comparar este ejemplo con el anterior, de LineGeometry. La sintaxis utilizada para un objeto PathGeometry es mucho más detallada que la utilizada para un objeto LineGeometry simple y, en este caso, puede ser más lógico utilizar la clase LineGeometry; no obstante la sintaxis detallada de PathGeometry permite utilizar áreas geométricas sumamente intrincadas y complejas.
Puede crear geometrías más complejas utilizando una combinación de objetos PathSegment.
En el ejemplo siguiente se utiliza un BezierSegment, un LineSegment y un ArcSegment para crear una forma. En el ejemplo, se crea primero una curva Bézier cúbica definiendo cuatro puntos: un punto inicial, que es el punto final del segmento anterior, un punto final (Point3) y dos puntos de control (Point1 y Point2). Los dos puntos de control de una curva Bézier cúbica se comportan como imanes: atraen hacia sí los segmentos que, de otra forma, serían una línea recta, con lo que se crea una curva. El primer punto de control, Point1, afecta a la parte inicial de la curva; el segundo punto de control, Point2, afecta a la parte final de la curva.
A continuación, en el ejemplo se agrega un LineSegment, que se dibuja entre el punto final del BezierSegment anterior que lo precede y el punto especificado por su propiedad LineSegment.
Luego, en el ejemplo se agrega un ArcSegment, que se dibuja desde el punto final del LineSegment anterior hasta el punto especificado por su propiedad Point. En el ejemplo se especifican asimismo los radios X e Y (Size), un ángulo de rotación (RotationAngle), un marcador que indica la amplitud que deberá tener el ángulo del arco resultante (IsLargeArc), y un valor que indica la dirección en que se dibuja el arco (SweepDirection). En la ilustración siguiente se muestra la forma creada por este ejemplo.
Objeto PathGeometry
.gif "PathGeometry")
<Path Stroke="Black" StrokeThickness="1" >
<Path.Data>
<PathGeometry>
<PathGeometry.Figures>
<PathFigure StartPoint="10,50">
<PathFigure.Segments>
<BezierSegment
Point1="100,0"
Point2="200,200"
Point3="300,100"/>
<LineSegment Point="400,100" />
<ArcSegment
Size="50,50" RotationAngle="45"
IsLargeArc="True" SweepDirection="Clockwise"
Point="200,100"/>
</PathFigure.Segments>
</PathFigure>
</PathGeometry.Figures>
</PathGeometry>
</Path.Data>
</Path>
' Create a figure.
Dim myPathFigure As New PathFigure()
myPathFigure.StartPoint = New Point(10,50)
myPathFigure.Segments.Add(New BezierSegment(New Point(100,0), New Point(200,200), New Point(300,100), True)) ' IsStroked
myPathFigure.Segments.Add(New LineSegment(New Point(400,100), True)) ' IsStroked
myPathFigure.Segments.Add(New ArcSegment(New Point(200,100), New Size(50,50), 45, True, SweepDirection.Clockwise, True)) ' IsStroked - IsLargeArc
''' Create a PathGeometry to contain the figure.
Dim myPathGeometry As New PathGeometry()
myPathGeometry.Figures.Add(myPathFigure)
' Display the PathGeometry.
Dim myPath As New Path()
myPath.Stroke = Brushes.Black
myPath.StrokeThickness = 1
myPath.Data = myPathGeometry
// Create a figure.
PathFigure myPathFigure = new PathFigure();
myPathFigure.StartPoint = new Point(10,50);
myPathFigure.Segments.Add(
new BezierSegment(
new Point(100,0),
new Point(200,200),
new Point(300,100),
true /* IsStroked */ ));
myPathFigure.Segments.Add(
new LineSegment(
new Point(400,100),
true /* IsStroked */ ));
myPathFigure.Segments.Add(
new ArcSegment(
new Point(200,100),
new Size(50,50),
45,
true, /* IsLargeArc */
SweepDirection.Clockwise,
true /* IsStroked */ ));
/// Create a PathGeometry to contain the figure.
PathGeometry myPathGeometry = new PathGeometry();
myPathGeometry.Figures.Add(myPathFigure);
// Display the PathGeometry.
Path myPath = new Path();
myPath.Stroke = Brushes.Black;
myPath.StrokeThickness = 1;
myPath.Data = myPathGeometry;
Se pueden crear geometrías aún más complejas utilizando varios objetos PathFigure dentro de un PathGeometry.
En el ejemplo siguiente se crea un objeto PathGeometry con dos objetos PathFigure, cada uno de los cuales contiene varios objetos PathSegment. Se utilizan la PathFigure del ejemplo anterior y una PathFigure con un PolyLineSegment y un QuadraticBezierSegment. PolyLineSegment se define con una matriz de puntos y QuadraticBezierSegment se define con un punto de control y un punto final. En la ilustración siguiente se muestra la forma creada por este ejemplo.
Objeto PathGeometry con varias figuras
.gif "PathGeometry")
<Path Stroke="Black" StrokeThickness="1" >
<Path.Data>
<PathGeometry>
<PathGeometry.Figures>
<PathFigure StartPoint="10,50">
<PathFigure.Segments>
<BezierSegment
Point1="100,0"
Point2="200,200"
Point3="300,100"/>
<LineSegment Point="400,100" />
<ArcSegment
Size="50,50" RotationAngle="45"
IsLargeArc="True" SweepDirection="Clockwise"
Point="200,100"/>
</PathFigure.Segments>
</PathFigure>
<PathFigure StartPoint="10,100">
<PathFigure.Segments>
<PolyLineSegment Points="50,100 50,150" />
<QuadraticBezierSegment Point1="200,200" Point2="300,100"/>
</PathFigure.Segments>
</PathFigure>
</PathGeometry.Figures>
</PathGeometry>
</Path.Data>
</Path>
Dim myPathGeometry As New PathGeometry()
' Create a figure.
Dim pathFigure1 As New PathFigure()
pathFigure1.StartPoint = New Point(10,50)
pathFigure1.Segments.Add(New BezierSegment(New Point(100,0), New Point(200,200), New Point(300,100), True)) ' IsStroked
pathFigure1.Segments.Add(New LineSegment(New Point(400,100), True)) ' IsStroked
pathFigure1.Segments.Add(New ArcSegment(New Point(200,100), New Size(50,50), 45, True, SweepDirection.Clockwise, True)) ' IsStroked - IsLargeArc
myPathGeometry.Figures.Add(pathFigure1)
' Create another figure.
Dim pathFigure2 As New PathFigure()
pathFigure2.StartPoint = New Point(10,100)
Dim polyLinePointArray() As Point = { New Point(50, 100), New Point(50, 150)}
Dim myPolyLineSegment As New PolyLineSegment()
myPolyLineSegment.Points = New PointCollection(polyLinePointArray)
pathFigure2.Segments.Add(myPolyLineSegment)
pathFigure2.Segments.Add(New QuadraticBezierSegment(New Point(200,200), New Point(300,100), True)) ' IsStroked
myPathGeometry.Figures.Add(pathFigure2)
' Display the PathGeometry.
Dim myPath As New Path()
myPath.Stroke = Brushes.Black
myPath.StrokeThickness = 1
myPath.Data = myPathGeometry
PathGeometry myPathGeometry = new PathGeometry();
// Create a figure.
PathFigure pathFigure1 = new PathFigure();
pathFigure1.StartPoint = new Point(10,50);
pathFigure1.Segments.Add(
new BezierSegment(
new Point(100,0),
new Point(200,200),
new Point(300,100),
true /* IsStroked */ ));
pathFigure1.Segments.Add(
new LineSegment(
new Point(400,100),
true /* IsStroked */ ));
pathFigure1.Segments.Add(
new ArcSegment(
new Point(200,100),
new Size(50,50),
45,
true, /* IsLargeArc */
SweepDirection.Clockwise,
true /* IsStroked */ ));
myPathGeometry.Figures.Add(pathFigure1);
// Create another figure.
PathFigure pathFigure2 = new PathFigure();
pathFigure2.StartPoint = new Point(10,100);
Point[] polyLinePointArray =
new Point[]{ new Point(50, 100), new Point(50, 150)};
PolyLineSegment myPolyLineSegment = new PolyLineSegment();
myPolyLineSegment.Points =
new PointCollection(polyLinePointArray);
pathFigure2.Segments.Add(myPolyLineSegment);
pathFigure2.Segments.Add(
new QuadraticBezierSegment(
new Point(200,200),
new Point(300,100),
true /* IsStroked */ ));
myPathGeometry.Figures.Add(pathFigure2);
// Display the PathGeometry.
Path myPath = new Path();
myPath.Stroke = Brushes.Black;
myPath.StrokeThickness = 1;
myPath.Data = myPathGeometry;
StreamGeometry
Al igual que la clase PathGeometry, StreamGeometry define una forma geométrica compleja que puede contener curvas, arcos y líneas. A diferencia de PathGeometry, el contenido de StreamGeometry no admite el enlace de datos, la animación ni la modificación. Utilice un objeto StreamGeometry cuando necesite describir una geometría compleja pero no desee la sobrecarga que implica la compatibilidad con el enlace de datos, la animación o la modificación. Debido a su eficacia, la clase StreamGeometry es una buena opción para describir adornos.
Para obtener un ejemplo, vea Cómo: Crear una forma utilizando StreamGeometry.
Sintaxis de marcado de trazados
Los tipos PathGeometry y StreamGeometry admiten una sintaxis de atributo de Extensible Application Markup Language (XAML) mediante una serie especial de comandos de movimiento y de dibujo. Para obtener más información, consulte Sintaxis de marcado de trazados.
Geometrías compuestas
Los objetos de geometrías compuestas se pueden crear mediante GeometryGroup, que es un objeto CombinedGeometry, o llamando al método del objeto Geometry estático, Combine.
El objeto CombinedGeometry y el método Combine realizan una operación de tipo Boolean para combinar el área definida por dos geometrías. Se descartan los objetos Geometry que no tienen área. Únicamente es posible combinar dos objetos Geometry (aunque estas dos geometrías también pueden ser geometrías compuestas).
La clase GeometryGroup crea una fusión de los objetos Geometry que contiene sin combinar su área. Se puede agregar cualquier número de objetos Geometry a un GeometryGroup. Para obtener un ejemplo, vea Cómo: Crear una forma compuesta.
Dado que no realizan una operación de combinación, el uso de objetos GeometryGroup proporciona ventajas de rendimiento con respecto al uso de objetos CombinedGeometry o del método Combine.
Geometrías combinadas
En la sección anterior se menciona que el objeto CombinedGeometry y el método Combine combinan el área definida por las geometrías que contienen. La enumeración GeometryCombineMode especifica cómo se combinan las geometrías. Los valores posibles para la propiedad GeometryCombineMode son: Union, Intersect, Exclude y Xor.
En el ejemplo siguiente, se define una CombinedGeometry con el modo de combinación Union. Tanto Geometry1 como Geometry2 se definen como círculos del mismo radio, pero con los centros desplazados en 50.
<Path Stroke="Black" StrokeThickness="1" Fill="#CCCCFF">
<Path.Data>
<!-- Combines two geometries using the union combine mode. -->
<CombinedGeometry GeometryCombineMode="Union">
<CombinedGeometry.Geometry1>
<EllipseGeometry RadiusX="50" RadiusY="50" Center="75,75" />
</CombinedGeometry.Geometry1>
<CombinedGeometry.Geometry2>
<EllipseGeometry RadiusX="50" RadiusY="50" Center="125,75" />
</CombinedGeometry.Geometry2>
</CombinedGeometry>
</Path.Data>
</Path>
.png "Resultados del modo de combinación Union")
En el ejemplo siguiente, se define una CombinedGeometry con el modo de combinación Xor. Tanto Geometry1 como Geometry2 se definen como círculos del mismo radio, pero con los centros desplazados en 50.
<Path Stroke="Black" StrokeThickness="1" Fill="#CCCCFF">
<Path.Data>
<!-- Combines two geometries using the XOR combine mode. -->
<CombinedGeometry GeometryCombineMode="Xor">
<CombinedGeometry.Geometry1>
<EllipseGeometry RadiusX="50" RadiusY="50" Center="75,75" />
</CombinedGeometry.Geometry1>
<CombinedGeometry.Geometry2>
<EllipseGeometry RadiusX="50" RadiusY="50" Center="125,75" />
</CombinedGeometry.Geometry2>
</CombinedGeometry>
</Path.Data>
</Path>
.png "Resultados del modo de combinación Xor")
Para obtener otros ejemplos, vea Cómo: Crear una forma compuesta y Cómo: Crear una geometría combinada.
Características de elementos Freezable
Como hereda de la clase Freezable, la clase Geometry proporciona varias características especiales: los objetos Geometry se pueden declarar como Información general sobre recursos, se pueden compartir entre varios objetos, se puede hacer que sean de sólo lectura para mejorar el rendimiento, se pueden clonar y se pueden hacer seguros para subprocesos. Para obtener más información sobre las diferentes características que proporcionan los objetos Freezable, consulte Información general sobre objetos Freezable.
Otras características de las geometrías
La clase Geometry también proporciona métodos de utilidad prácticos, como los siguientes:
FillContains: determina si la geometría contiene otra Geometry.
StrokeContains: determina si el trazo de una Geometry contiene un punto especificado.
Consulte la clase Geometry para obtener una lista completa de sus métodos.
Vea también
Referencia
Conceptos
Optimizar el rendimiento: Imágenes y gráficos 2D
Sintaxis de marcado de trazados
Información general sobre animaciones
Información general sobre formas y dibujo básico en WPF
Información general sobre objetos Drawing