Overzicht van geometrie
In dit overzicht wordt beschreven hoe u de WPF-Geometry -klassen (Windows Presentation Foundation) gebruikt om vormen te beschrijven. Dit onderwerp vergelijkt ook de verschillen tussen Geometry objecten en Shape elementen.
Wat is een geometrie?
Met de Geometry-klasse en de klassen die hieraan zijn afgeleid, zoals EllipseGeometry, PathGeometryen CombinedGeometry, kunt u de geometrie van een 2D-vorm beschrijven. Deze geometrische beschrijvingen hebben veel toepassingen, zoals het definiëren van een vorm om te schilderen op het scherm of het definiëren van hit-test- en clipgebieden. U kunt zelfs een geometrie gebruiken om een animatiepad te definiëren.
Geometry objecten kunnen eenvoudig zijn, zoals rechthoeken en cirkels, of samengesteld, die zijn gemaakt op basis van twee of meer geometrieobjecten. Complexere geometrieën kunnen worden gemaakt met behulp van de klassen PathGeometry en StreamGeometry, waarmee u bogen en curven kunt beschrijven.
Omdat een Geometry een type Freezableis, bieden Geometry objecten verschillende speciale functies: ze kunnen worden gedeclareerd als resources, gedeeld tussen meerdere objecten, als alleen-lezen gemaakt om de prestaties te verbeteren, gekloond, en draadveilig gemaakt. Zie voor meer informatie over de verschillende functies van Freezable objecten het Overzicht van bevriesbare objecten.
Geometrieën versus shapes
De Geometry- en Shape-klassen lijken erop dat ze allebei 2D-shapes beschrijven (bijvoorbeeld EllipseGeometry en Ellipse vergelijken), maar er zijn belangrijke verschillen.
Voor één wordt de Geometry-klasse overgenomen van de Freezable-klasse terwijl de Shape-klasse wordt overgenomen van FrameworkElement. Omdat het elementen zijn, kunnen Shape objecten zichzelf weergeven en deelnemen aan het indelingssysteem, terwijl Geometry objecten niet kunnen.
Hoewel Shape objecten beter bruikbaar zijn dan Geometry objecten, zijn Geometry objecten veelzijdiger. Hoewel een Shape object wordt gebruikt om 2D-afbeeldingen weer te geven, kan een Geometry object worden gebruikt om het geometrische gebied voor 2D-afbeeldingen te definiëren, een regio te definiëren voor knipsels of een regio te definiëren voor het testen van treffers, bijvoorbeeld.
De padvorm
Een Shape, de Path klasse, maakt daadwerkelijk gebruik van een Geometry om de inhoud ervan te beschrijven. Door de eigenschap Data van de Path in te stellen met een Geometry en de Fill- en Stroke-eigenschappen in te stellen, kunt u een Geometryweergeven.
Algemene eigenschappen die een geometrie aannemen
In de voorgaande secties werd vermeld dat geometrieobjecten kunnen worden gebruikt met andere objecten voor verschillende doeleinden, zoals het tekenen van vormen, animaties en knippen. De volgende tabel bevat verschillende klassen met eigenschappen die een Geometry-object hebben.
| Typ | Eigendom |
|---|---|
| DoubleAnimationUsingPath | PathGeometry |
| DrawingGroup | ClipGeometry |
| GeometryDrawing | Geometry |
| Path | Data |
| UIElement | Clip |
Eenvoudige geometrietypen
De basisklasse voor alle geometrieën is de abstracte klasse Geometry. De klassen die zijn afgeleid van de Geometry klasse kunnen grofweg worden gegroepeerd in drie categorieën: eenvoudige geometrieën, padgeometrieën en samengestelde geometrieën.
Eenvoudige geometrieklassen omvatten LineGeometry, RectangleGeometryen EllipseGeometry en worden gebruikt om eenvoudige geometrische vormen te maken, zoals lijnen, rechthoeken en cirkels.
Een LineGeometry wordt gedefinieerd door het beginpunt van de lijn en het eindpunt op te geven.
Een RectangleGeometry wordt gedefinieerd met een Rect structuur die de relatieve positie en de hoogte en breedte aangeeft. U kunt een afgeronde rechthoek maken door de eigenschappen RadiusX en RadiusY in te stellen.
Een EllipseGeometry wordt gedefinieerd door een middelpunt, een x-radius en een y-radius. In de volgende voorbeelden ziet u hoe u eenvoudige geometrieën kunt maken voor rendering en voor knipsels.
Dezelfde vormen, evenals complexere vormen, kunnen worden gemaakt met behulp van een PathGeometry of door geometrieobjecten te combineren, maar deze klassen bieden een eenvoudiger middel voor het produceren van deze eenvoudige geometrische vormen.
In het volgende voorbeeld ziet u hoe u een LineGeometrymaakt en weergeeft. Zoals eerder is aangegeven, kan een Geometry object niet tekenen, dus in het voorbeeld wordt een Path vorm gebruikt om de lijn weer te geven. Omdat een regel geen gebied heeft, heeft het instellen van de eigenschap Fill van de Path geen effect; In plaats daarvan worden alleen de eigenschappen Stroke en StrokeThickness opgegeven. In de volgende afbeelding ziet u de uitvoer uit het voorbeeld.
Een LineGeometrie van (10.20) tot (100.130)
<Path Stroke="Black" StrokeThickness="1" >
<Path.Data>
<LineGeometry StartPoint="10,20" EndPoint="100,130" />
</Path.Data>
</Path>
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;
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
In het volgende voorbeeld ziet u hoe u een EllipseGeometrymaakt en weergeeft. De voorbeelden stellen de Center van de EllipseGeometry in op het punt 50,50 en de x-radius en de y-radius zijn beide ingesteld op 50, waardoor een cirkel met een diameter van 100 wordt gemaakt. Het interieur van de ellips wordt gekleurd door een waarde toe te wijzen aan de eigenschap Fill van het Path-element, in dit geval Gold. In de volgende afbeelding ziet u de uitvoer uit het voorbeeld.
Een ellipsgeometrie getekend bij (50,50)
<Path Fill="Gold" Stroke="Black" StrokeThickness="1">
<Path.Data>
<EllipseGeometry Center="50,50" RadiusX="50" RadiusY="50" />
</Path.Data>
</Path>
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;
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
In het volgende voorbeeld ziet u hoe u een RectangleGeometrymaakt en weergeeft. De positie en de afmetingen van de rechthoek worden gedefinieerd door een Rect structuur. De positie is 50,50 en de hoogte en breedte zijn beide 25, waardoor een vierkant ontstaat. In de volgende afbeelding ziet u de uitvoer uit het voorbeeld.
Een Rechthoekige Geometrie getekend bij 50,50
<Path Fill="LemonChiffon" Stroke="Black" StrokeThickness="1">
<Path.Data>
<RectangleGeometry Rect="50,50,25,25" />
</Path.Data>
</Path>
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;
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
In het volgende voorbeeld ziet u hoe u een EllipseGeometry gebruikt als het clipgebied voor een afbeelding. Een Image-object wordt gedefinieerd met een Width van 200 en een Height van 150. Een EllipseGeometry met een RadiusX waarde van 100, een RadiusY waarde van 75 en een Center waarde van 100,75 is ingesteld op de eigenschap Clip van de afbeelding. Alleen het deel van de afbeelding dat zich binnen het gebied van het beletselteken bevindt, wordt weergegeven. In de volgende afbeelding ziet u de uitvoer uit het voorbeeld.
Een EllipseGeometry die wordt gebruikt om een Afbeelding-besturingselement uit te snijden
<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.
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;
' 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
Padgeometrieën
De PathGeometry klasse en het lichtgewicht equivalent, de StreamGeometry klasse, bieden de middelen om meerdere complexe afbeeldingen te beschrijven die bestaan uit boogs, curven en lijnen.
Het hart van een PathGeometry is een verzameling van PathFigure objecten, zo genoemd omdat elke figuur een discrete vorm in de PathGeometrybeschrijft. Elke PathFigure bestaat uit een of meer PathSegment objecten, die elk een segment van de afbeelding beschrijven.
Er zijn veel soorten segmenten.
| Segmenttype | Beschrijving | Voorbeeld |
|---|---|---|
| ArcSegment | Hiermee maakt u een elliptische boog tussen twee punten. | Een elliptische boog maken. |
| BezierSegment | Hiermee maakt u een kubieke Bezier-curve tussen twee punten. | Een kubieke bezier-curve maken. |
| LineSegment | Hiermee maakt u een lijn tussen twee punten. | Een LineSegment maken in een PathGeometry |
| PolyBezierSegment | Hiermee maakt u een reeks kubieke Bezier-curven. | Zie de pagina PolyBezierSegment type. |
| PolyLineSegment | Maakt een reeks lijnen. | Zie de pagina PolyLineSegment type. |
| PolyQuadraticBezierSegment | Hiermee maakt u een reeks kwadratische Bezier-curven. | Zie de pagina PolyQuadraticBezierSegment. |
| QuadraticBezierSegment | Hiermee maakt u een kwadratische Bezier-curve. | Kwadratische Bézier-curve maken. |
De segmenten binnen een PathFigure worden gecombineerd tot één geometrische vorm, waarbij het eindpunt van elk segment het beginpunt van het volgende segment is. De eigenschap StartPoint van een PathFigure geeft het punt aan van waaruit het eerste segment wordt getekend. Elk volgend segment begint op het eindpunt van het vorige segment. Een verticale lijn van 10,50 naar 10,150 kan bijvoorbeeld worden gedefinieerd door de eigenschap StartPoint in te stellen op 10,50 en een LineSegment te maken met een eigenschapsinstelling van Point van 10,150.
In het volgende voorbeeld wordt een eenvoudige PathGeometry gemaakt die bestaat uit één PathFigure met een LineSegment en wordt deze weergegeven met behulp van een Path element. De StartPoint van het PathFigure-object is ingesteld op 10,20 en een LineSegment wordt gedefinieerd met een eindpunt op 100,130. In de volgende afbeelding ziet u de PathGeometry die in dit voorbeeld is gemaakt.
Een PathGeometry die één LineSegment bevat
<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).
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;
' 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
Het is de moeite waard om dit voorbeeld te contrasteren met het voorgaande LineGeometry voorbeeld. De syntaxis die wordt gebruikt voor een PathGeometry is veel uitgebreider dan de syntaxis die wordt gebruikt voor een eenvoudige LineGeometry, en het kan zinvoler zijn om in dit geval de LineGeometry klasse te gebruiken, maar de uitgebreide syntaxis van de PathGeometry maakt uiterst ingewikkelde en complexe geometrische gebieden mogelijk.
Complexere geometrieën kunnen worden gemaakt met behulp van een combinatie van PathSegment objecten.
In het volgende voorbeeld wordt een BezierSegment, een LineSegmenten een ArcSegment gebruikt om een shape te maken. In het voorbeeld wordt eerst een kubieke Bezier-curve gemaakt door vier punten te definiëren: een beginpunt, het eindpunt van het vorige segment, een eindpunt (Point3) en twee besturingspunten (Point1 en Point2). De twee controlepunten van een kubieke Bezier-curve gedragen zich als magneten, die delen aantrekken van wat anders een rechte lijn naar zichzelf zou zijn, waardoor een curve ontstaat. Het eerste controlepunt, Point1, beïnvloedt het begingedeelte van de curve; het tweede besturingspunt, Point2, beïnvloedt het eindgedeelte van de curve.
In het voorbeeld wordt vervolgens een LineSegmenttoegevoegd, die wordt getekend tussen het eindpunt van de voorafgaande BezierSegment en het punt dat is gespecificeerd door de eigenschap LineSegment.
In het voorbeeld wordt vervolgens een ArcSegmenttoegevoegd, die wordt getekend vanaf het eindpunt van de voorgaande LineSegment aan het punt dat is opgegeven door de eigenschap Point. In het voorbeeld wordt ook de x- en y-radius van de boog (Size), een draaihoek (RotationAngle), een vlag opgegeven die aangeeft hoe groot de hoek van de resulterende boog moet zijn (IsLargeArc), en een waarde die aangeeft in welke richting de boog wordt getekend (SweepDirection). In de volgende afbeelding ziet u de vorm die in dit voorbeeld is gemaakt.
Een 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.
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;
' 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
Nog complexere geometrieën kunnen worden gemaakt met behulp van meerdere PathFigure objecten binnen een PathGeometry.
In het volgende voorbeeld wordt een PathGeometry gemaakt met twee PathFigure objecten, die elk meerdere PathSegment objecten bevatten. De PathFigure uit het bovenstaande voorbeeld en een PathFigure met een PolyLineSegment en een QuadraticBezierSegment worden gebruikt. Een PolyLineSegment wordt gedefinieerd met een matrix met punten en de QuadraticBezierSegment wordt gedefinieerd met een besturingspunt en een eindpunt. In de volgende afbeelding ziet u de vorm die in dit voorbeeld is gemaakt.
Een PathGeometry met meerdere afbeeldingen
<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>
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;
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
StreamGeometry
Net als de PathGeometry klasse definieert een StreamGeometry een complexe geometrische vorm die curven, bogen en lijnen kan bevatten. In tegenstelling tot een PathGeometrybiedt de inhoud van een StreamGeometry geen ondersteuning voor gegevensbinding, animatie of wijziging. Gebruik een StreamGeometry wanneer u een complexe geometrie moet beschrijven, maar niet de overhead van ondersteunende gegevensbinding, animatie of wijziging wilt. Vanwege de efficiëntie is de StreamGeometry class een goede keuze voor het beschrijven van versieringen.
Zie Een shape maken met een StreamGeometry-voor een voorbeeld.
Padopmaaksynthaxis
De PathGeometry- en StreamGeometry-typen ondersteunen de syntaxis van het kenmerk Extensible Application Markup Language (XAML) met behulp van een speciale reeks opdrachten voor verplaatsen en tekenen. Zie padmarkeringssyntaxisvoor meer informatie.
Samengestelde geometrieën
Samengestelde geometrieobjecten kunnen worden gemaakt met behulp van een GeometryGroup, een CombinedGeometryof door de statische Geometry methode Combineaan te roepen.
Het CombinedGeometry-object en de methode Combine voert een Booleaanse bewerking uit om het gebied te combineren dat is gedefinieerd door twee geometrieën. Geometry objecten zonder oppervlakte worden verwijderd. Slechts twee Geometry objecten kunnen worden gecombineerd (hoewel deze twee geometrieën ook samengestelde geometrieën kunnen zijn).
De GeometryGroup klasse maakt een samenvoeging van de Geometry objecten die deze bevat zonder hun gebied te combineren. Een willekeurig aantal Geometry objecten kan worden toegevoegd aan een GeometryGroup. Zie Een samengestelde vorm makenvoor een voorbeeld.
Omdat ze geen combinatiebewerking uitvoeren, biedt het gebruik van GeometryGroup objecten prestatievoordelen ten opzichte van het gebruik van CombinedGeometry objecten of de methode Combine.
Gecombineerde geometrieën
In de voorgaande sectie is vermeld dat het object CombinedGeometry en de methode Combine het gebied combineren dat is gedefinieerd door de geometrieën die ze bevatten. De opsomming GeometryCombineMode geeft aan hoe de geometrieën worden gecombineerd. De mogelijke waarden voor de eigenschap GeometryCombineMode zijn: Union, Intersect, Excludeen Xor.
In het volgende voorbeeld wordt een CombinedGeometry gedefinieerd met een combinatiemodus van Union. Zowel Geometry1 als Geometry2 worden gedefinieerd als cirkels van dezelfde straal, maar met middenpunten verschoven met 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>
In het volgende voorbeeld wordt een CombinedGeometry gedefinieerd met een combinatiemodus van Xor. Zowel Geometry1 als Geometry2 worden gedefinieerd als cirkels met dezelfde straal, maar met middelpunten die 50 eenheden zijn verschoven.
<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>
Zie Een samengestelde vorm maken en Een gecombineerde geometrie makenvoor meer voorbeelden.
Invriesbare functies
Omdat deze wordt overgenomen van de Freezable-klasse, biedt de Geometry klasse verschillende speciale functies: Geometry objecten kunnen worden gedeclareerd als XAML-resources, gedeeld tussen meerdere objecten, gemaakt met het kenmerk Alleen-lezen om de prestaties te verbeteren, gekloond en thread-veilig gemaakt. Zie voor meer informatie over de verschillende kenmerken van Freezable-objecten het overzicht Freezable Objects Overview.
Andere geometriekenmerken
De Geometry-klasse biedt ook nuttige hulpprogrammamethoden, zoals de volgende:
FillContains - Bepaalt of de geometrie een andere Geometrybevat.
StrokeContains - Bepaalt of de lijn van een Geometry een opgegeven punt bevat.
Zie de Geometry-klasse voor een volledige lijst met methoden.
Zie ook
.NET Desktop feedback