Freigeben über

Übersicht über die Geometrie

  • Artikel

In dieser Übersicht wird beschrieben, wie die Geometry-Klassen von Windows Presentation Foundation (WPF) verwendet werden, um Formen zu beschreiben. In diesem Thema werden auch die Unterschiede zwischen Geometry-Objekten und Shape-Elementen verglichen.

Dieses Thema enthält folgende Abschnitte.

  • Was ist eine Geometrie?
  • Geometrien im Vergleich zuFormen
  • Allgemeine Eigenschaften, die eine Geometrie übernehmen
  • Einfache geometrische Typen
  • Pfadgeometrien
  • Zusammengesetzte Geometrien
  • Kombinierte Geometrien
  • Features von Freezable
  • Andere Geometriefeatures
  • Verwandte Abschnitte

Was ist eine Geometrie?

Anhand der Geometry-Klasse und der davon abgeleiteten Klassen, z. B. EllipseGeometry, PathGeometry und CombinedGeometry, können Sie die Geometrie einer 2D-Form beschreiben. Diese geometrischen Beschreibungen haben viele Verwendungszwecke. Sie dienen beispielsweise zum Definieren einer am Bildschirm zu zeichnenden Form oder zum Definieren von Treffertest- und Clipbereichen. Sie können mithilfe einer Geometrie sogar einen Animationspfad definieren.

Bei Geometry-Objekten kann es sich um einfache Formen wie Rechtecke und Kreise oder um aus einem oder mehreren geometrischen Objekten zusammengesetzte Formen handeln. Mithilfe der PathGeometry-Klasse und der StreamGeometry-Klasse, mit denen Sie Bögen und Kurven beschreiben können, lassen sich komplexere Geometrien erstellen.

Da eine Geometry ein Typ von Freezable ist, stellen Geometry-Objekte mehrere spezielle Features bereit: Sie können als Ressourcen deklariert, von mehreren Objekten gleichzeitig verwendet, zur Leistungsoptimierung als schreibgeschützt definiert, geklont sowie als threadsicher festgelegt werden. Weitere Informationen über die verschiedenen von Freezable-Objekten bereitgestellten Features finden Sie unter Übersicht über Freezable-Objekte.

Geometrien im Vergleich zuFormen

Die Geometry-Klasse und die Shape-Klasse sind scheinbar ähnlich, da sie beide 2D-Formen beschreiben (vergleichen Sie z. B. EllipseGeometry und Ellipse). Sie weisen aber wichtige Unterschiede auf.

Zum einen erbt die Geometry-Klasse von der Freezable-Klasse, wohingegen die Shape-Klasse von FrameworkElement erbt. Da es sich bei Shape-Objekten um Elemente handelt, können sie sich selbst rendern und zu Komponenten des Layoutsystems werden. Bei Geometry-Objekten ist dies dagegen nicht möglich.

Shape-Objekte lassen sich zwar leichter verwenden als Geometry-Objekte, doch Geometry-Objekte sind vielseitiger. Mithilfe eines Shape-Objekts werden 2D-Grafiken gerendert. Ein Geometry-Objekt hingegen kann beispielsweise verwendet werden, um den geometrischen Bereich für 2D-Grafiken, einen Bereich für das Clipping oder einen Bereich für Treffertests zu definieren.

Die Form "Path"

Eine Shape, die Path-Klasse, verwendet zur Beschreibung des Inhalts eine Geometry. Wenn Sie die Data-Eigenschaft von Path mit einer Geometry festlegen und die zugehörige Fill-Eigenschaft und Stroke-Eigenschaft festlegen, können Sie eine Geometry rendern.

Allgemeine Eigenschaften, die eine Geometrie übernehmen

In den vorangegangenen Abschnitten wurde erwähnt, dass Geometry-Objekte zu verschiedenen Zwecken mit anderen Objekten verwendet werden können, z. B. zum Zeichnen von Formen, zum Animieren und für das Clipping. In der folgenden Tabelle sind mehrere Klassen mit Eigenschaften aufgeführt, die ein Geometry-Objekt übernehmen.

Typ

Eigenschaft

DoubleAnimationUsingPath

PathGeometry

DrawingGroup

ClipGeometry

GeometryDrawing

Geometry

Path

Data

UIElement

Clip

Einfache geometrische Typen

Die Basisklasse für alle Geometrien ist die abstrakte Geometry-Klasse. Die von der Geometry-Klasse abgeleiteten Klassen lassen sich grob in drei Kategorien unterteilen: einfache Geometrien, Pfadgeometrien und zusammengesetzte Geometrien.

Zu den Klassen der einfachen Geometrie zählen LineGeometry, RectangleGeometry und EllipseGeometry. Sie werden zum Erstellen von grundlegenden geometrischen Formen wie Linien, Rechtecken und Kreisen verwendet.

  • Eine LineGeometry wird durch die Festlegung des Anfangs- und Endpunkts der Linie definiert.

  • Eine RectangleGeometry wird mit einer Rect-Struktur definiert, die die relative Position sowie die Höhe und Breite festlegt. Sie können ein abgerundetes Rechteck erstellen, indem Sie die RadiusX-Eigenschaft und die RadiusY-Eigenschaft festlegen.

  • Eine EllipseGeometry wird durch einen Mittelpunkt, einen x-Radius und einen y-Radius definiert. Die folgenden Beispiele veranschaulichen die Erstellung einfacher Geometrien für das Rendering und das Clipping.

Diese Formen sowie komplexere Formen können mit einer PathGeometry oder durch Kombinieren von geometrischen Objekten erstellt werden. Allerdings stellen diese Klassen einfachere Methoden zum Erstellen dieser grundlegenden geometrischen Formen bereit.

Im folgenden Beispiel wird das Erstellen und Rendern einer LineGeometry veranschaulicht. Wie schon erwähnt, kann ein Geometry-Objekt sich nicht selbst zeichnen. Daher wird in diesem Beispiel zum Rendern der Linie eine Path-Form verwendet. Da eine Linie keinen Bereich aufweist, hätte das Festlegen der Fill-Eigenschaft von Path keine Auswirkung. Stattdessen werden daher nur die Stroke-Eigenschaft und die StrokeThickness-Eigenschaft festgelegt. Die folgende Abbildung zeigt die Ausgabe des Codebeispiels.

LineGeometry, gezeichnet von (10,20) bis (100,130)

Eine 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;

Im nächsten Beispiel wird das Erstellen und Rendern einer EllipseGeometry veranschaulicht. In den Beispielen wird der Center von EllipseGeometry auf den Punkt 50,50 festgelegt. Außerdem werden der x-Radius und der y-Radius auf 50 festgelegt, wodurch ein Kreis mit einem Durchmesser von 100 erstellt wird. Das Innere der Ellipse wird gezeichnet, indem der Fill-Eigenschaft des Path-Elements ein Wert zugewiesen wird, in diesem Fall Gold. Die folgende Abbildung zeigt die Ausgabe des Codebeispiels.

EllipseGeometry, gezeichnet bei (50,50)

Eine 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;

Im folgenden Beispiel wird das Erstellen und Rendern einer RectangleGeometry veranschaulicht. Die Position und die Abmessungen des Rechtecks werden durch eine Rect-Struktur definiert. Die Position lautet 50,50. Die Höhe und die Breite betragen jeweils 25, wodurch ein Quadrat erstellt wird. Die folgende Abbildung zeigt die Ausgabe des Codebeispiels.

RectangleGeometry, gezeichnet bei 50,50

Eine 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;

Im folgenden Beispiel wird die Verwendung einer EllipseGeometry als Clipbereich für ein Bild veranschaulicht. Ein Image-Objekt wird mit einer Width von 200 und einer Height von 150 erstellt. Eine EllipseGeometry mit einem RadiusX-Wert von 100, einem RadiusY-Wert von 75 und einem Center-Wert von 100,75 wird auf die Clip-Eigenschaft des Bilds festgelegt. Es wird nur der Teil des Bilds angezeigt, der innerhalb des Bereichs der Ellipse liegt. Die folgende Abbildung zeigt die Ausgabe des Codebeispiels.

EllipseGeometry zum Beschneiden eines Image-Steuerelements

Ein Bild mit und ohne Clipping

<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;

Pfadgeometrien

Die PathGeometry-Klasse und deren Lightweight-Entsprechung, die StreamGeometry-Klasse, ermöglichen die Beschreibung mehrerer komplexer Figuren, die aus Bögen, Kurven und Linien zusammengesetzt sind.

Eine PathGeometry besteht im Wesentlichen aus einer Auflistung von PathFigure-Objekten. Diese Objekte werden so genannt, da jede Figur eine eigenständige Form in der PathGeometry beschreibt. Jede PathFigure besteht aus mindestens einem PathSegment-Objekt, das einen Abschnitt der Figur beschreibt.

Es gibt viele verschiedene Arten von Segmenten.

Segmenttyp

Beschreibungen

Beispiel

ArcSegment

Erstellt einen elliptischen Bogen zwischen zwei Punkten.

Gewusst wie: Erstellen eines elliptischen Bogens.

BezierSegment

Erstellt eine kubische Bezierkurve zwischen zwei Punkten.

Gewusst wie: Erstellen einer kubischen Bézierkurve.

LineSegment

Erstellt eine Linie zwischen zwei Punkten.

Gewusst wie: Erstellen eines LineSegment in einer PathGeometry

PolyBezierSegment

Erstellt eine Reihe von kubischen Bezierkurven.

Siehe die PolyBezierSegment-Typseite.

PolyLineSegment

Erstellt eine Reihe von Zeilen.

Siehe die PolyLineSegment-Typseite.

PolyQuadraticBezierSegment

Erstellt eine Reihe von quadratischen Bezierkurven.

Siehe die PolyQuadraticBezierSegment-Seite.

QuadraticBezierSegment

Erstellt eine quadratische Bezierkurve.

Gewusst wie: Erstellen einer quadratischen Bézierkurve.

Die Segmente innerhalb einer PathFigure werden zu einer einzelnen geometrischen Form zusammengesetzt. Dabei bildet der Endpunkt jedes Segments den Startpunkt des nächsten Segments. Die StartPoint-Eigenschaft einer PathFigure gibt den Punkt an, an dem die Zeichnung des ersten Segments beginnt. Jedes nachfolgende Segment beginnt am Endpunkt des vorherigen Segments. Beispielsweise kann eine vertikale Linie von 10,50 nach 10,150 definiert werden, indem die StartPoint-Eigenschaft auf 10,50 festgelegt und ein LineSegment erstellt wird, dessen Point-Eigenschaft auf 10,150 festgelegt ist.

Im folgenden Beispiel wird eine einfache PathGeometry aus einer einzelnen PathFigure mit einem LineSegment erstellt und mithilfe eines Path-Elements angezeigt. Der StartPoint des PathFigure-Objekts ist auf 10,20 festgelegt. Darüber hinaus wurde ein LineSegment mit dem Endpunkt 100,130 definiert. Die folgende Abbildung zeigt die durch dieses Beispiel erstellte PathGeometry.

PathGeometry, die ein einzelnes LineSegment enthält

Eine LineGeometry

<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;

Ein Vergleich dieses Beispiels mit dem vorangehenden LineGeometry-Beispiel lohnt sich. Die für eine PathGeometry verwendete Syntax ist wesentlich ausführlicher als die Syntax für eine einfache LineGeometry, und es ist möglicherweise sinnvoller, in diesem Fall die LineGeometry-Klasse zu verwenden. Die ausführliche Syntax von PathGeometry ermöglicht jedoch äußerst komplizierte und komplexe geometrische Bereiche.

Komplexere Geometrien können mithilfe einer Kombination von PathSegment-Objekten erstellt werden.

Im nächsten Beispiel werden zum Erstellen einer Form ein BezierSegment, ein LineSegment und ein ArcSegment verwendet. Im Beispiel wird zunächst eine kubische Bézierkurve erstellt, indem vier Punkte definiert werden: ein Anfangspunkt, der den Endpunkt des vorherigen Segments bildet, ein Endpunkt (Point3) sowie zwei Kontrollpunkte (Point1 und Point2). Das Verhalten der beiden Kontrollpunkte einer kubischen Bézierkurve ist mit Magneten vergleichbar, die Abschnitte einer Geraden anziehen, sodass sich eine Krümmung ergibt. Der erste Kontrollpunkt Point1 wirkt sich auf den Anfangsabschnitt der Kurve aus, und der zweite Kontrollpunkt Point2 wirkt sich auf den Endabschnitt der Kurve aus.

Anschließend wird im Beispiel ein LineSegment hinzugefügt, das zwischen dem Endpunkt für das vorangehende BezierSegment und dem von der zugehörigen LineSegment-Eigenschaft festgelegten Punkt gezeichnet wird.

Danach wird ein ArcSegment hinzugefügt, das vom Endpunkt für das vorangehende LineSegment bis zu dem von der zugehörigen Point-Eigenschaft festgelegten Punkt gezeichnet wird. Darüber hinaus werden im Beispiel der x- und y-Radius des Bogens (Size), ein Drehwinkel (RotationAngle), ein Kennzeichen zur Angabe der erforderlichen Größe des resultierenden Bogens (IsLargeArc) und ein Wert festgelegt, der angibt, in welche Richtung der Bogen gezeichnet wird (SweepDirection). Die folgende Abbildung zeigt die durch dieses Beispiel erstellte Form.

PathGeometry

Eine 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;

Durch die Verwendung mehrerer PathFigure-Objekte in einer PathGeometry können noch komplexere Geometrien erstellt werden.

Im folgenden Beispiel wird eine PathGeometry mit zwei PathFigure-Objekten erstellt, von denen jedes mehrere PathSegment-Objekte enthält. Dabei werden die PathFigure aus dem obigen Beispiel und eine PathFigure mit einem PolyLineSegment und einem QuadraticBezierSegment verwendet. Ein PolyLineSegment wird mit einem Array von Punkten definiert, und das QuadraticBezierSegment wird mit einem Kontrollpunkt und einem Endpunkt definiert. Die folgende Abbildung zeigt die durch dieses Beispiel erstellte Form.

PathGeometry mit mehreren Figuren

Eine 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

Wie die PathGeometry-Klasse definiert auch StreamGeometry eine komplexe geometrische Form, die Kurven, Bögen und Linien enthalten kann. Im Gegensatz zu einer PathGeometry bietet der Inhalt einer StreamGeometry keine Unterstützung für eine Datenbindung, Animation oder Änderung. Verwenden Sie StreamGeometry, wenn Sie eine komplexe Geometrie beschreiben müssen, aber ohne den Verwaltungsaufwand zur Unterstützung von Datenbindung, Animation oder Änderungen auskommen möchten. Aufgrund ihrer Effizienz ist die StreamGeometry-Klasse eine gute Wahl zum Beschreiben von Adornern.

Ein Beispiel finden Sie unter Gewusst wie: Erstellen einer Form mithilfe von StreamGeometry.

Pfadmarkupsyntax

Der PathGeometry-Typ und der StreamGeometry-Typ unterstützen eine Extensible Application Markup Language (XAML)-Attributsyntax. Hierzu wird eine spezielle Kombination von Befehlen zum Verschieben und Zeichnen verwendet. Weitere Informationen finden Sie unter Pfadmarkupsyntax.

Zusammengesetzte Geometrien

Zusammengesetzte geometrische Objekte können durch die Verwendung von GeometryGroup, CombinedGeometry oder den Aufruf der statischen Geometry-Methode Combine erstellt werden.

Da bei GeometryGroup-Objekten keine Kombination stattfindet, lässt sich durch ihre Verwendung eine bessere Leistung erzielen als bei der Verwendung von CombinedGeometry-Objekten oder der Combine-Methode.

Kombinierte Geometrien

Im vorherigen Abschnitt wurde erwähnt, dass das CombinedGeometry-Objekt und die Combine-Methode den durch die enthaltenen Geometrien definierten Bereich kombinieren. Die GeometryCombineMode-Enumeration legt fest, wie die Geometrien kombiniert werden. Die möglichen Werte für die GeometryCombineMode-Eigenschaft sind Union, Intersect, Exclude und Xor.

Im folgenden Beispiel wird eine CombinedGeometry definiert, wobei der Kombinationsmodus auf Union festgelegt ist. Sowohl Geometry1 als auch Geometry2 werden als Kreise mit identischem Radius definiert, deren Mittelpunkte jedoch um den Wert 50 versetzt sind.

<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>

Ergebnisse des Union-Kombinationsmodus

Im folgenden Beispiel wird eine CombinedGeometry definiert, wobei der Kombinationsmodus auf Xor festgelegt ist. Sowohl Geometry1 als auch Geometry2 werden als Kreise mit identischem Radius definiert, deren Mittelpunkte jedoch um den Wert 50 versetzt sind.

<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>

Ergebnisse des Xor-Kombinationsmodus

Weitere Beispiele finden Sie unter Gewusst wie: Erstellen einer zusammengesetzten Form und unter Gewusst wie: Erstellen von kombinierten Geometrien.

Features von Freezable

Da die Geometry-Klasse von der Freezable-Klasse erbt, bietet sie mehrere spezielle Features: Geometry-Objekte können als Übersicht über Ressourcen deklariert, von mehreren Objekten gleichzeitig verwendet, zur Leistungsoptimierung als schreibgeschützt definiert, geklont sowie als threadsicher festgelegt werden. Weitere Informationen über die verschiedenen von Freezable-Objekten bereitgestellten Features finden Sie unter Übersicht über Freezable-Objekte.

Andere Geometriefeatures

Die Geometry-Klasse stellt auch nützliche Dienstprogrammmethoden bereit. Hierzu zählen beispielsweise:

In der Geometry-Klasse finden Sie eine vollständige Liste der zugehörigen Methoden.

Siehe auch

Referenz

Geometry

PathGeometry

Path

GeometryDrawing

Konzepte

Optimieren der Leistung: 2D-Grafiken und Bildverarbeitung

Pfadmarkupsyntax

Übersicht über Animationen

Übersicht über Formen und die grundlegenden Funktionen zum Zeichnen in WPF

Übersicht über Zeichnungsobjekte

Weitere Ressourcen

Gewusst-wie-Themen zu Geometrien