Cenni preliminari sulle classi Geometry

Aggiornamento: novembre 2007

In questi cenni preliminari viene descritto come utilizzare le classi Geometry di Windows Presentation Foundation (WPF) per descrivere le forme. In questo argomento vengono confrontate le differenze tra gli oggetti Geometry e gli elementi Shape.

Nel presente argomento sono contenute le seguenti sezioni.

• Definizione di Geometry
• Oggetti Geometry e forme a confronto
• Proprietà comuni che richiedono un oggetto Geometry
• Tipi di geometrie semplici
• Geometrie di percorso
• Geometrie composte
• Geometrie combinate
• Funzionalità dell'oggetto Freezable
• Ulteriori funzionalità degli oggetti Geometry
• Argomenti correlati

Definizione di Geometry

La classe Geometry e le classi che ne derivano, come EllipseGeometry, PathGeometry e CombinedGeometry, consentono di descrivere la geometria di una forma 2D. Queste descrizioni geometriche hanno molti impieghi, come la definizione di una forma da disegnare sullo schermo o la definizione delle aree dell'hit test e di ritaglio. È persino possibile utilizzare un oggetto Geometry per definire un percorso di animazione.

Gli oggetti Geometry possono essere semplici, come rettangoli e cerchi, oppure composti e creati con due o più oggetti Geometry. Oggetti Geometry più complessi possono essere creati mediante le classi PathGeometry e StreamGeometry, che consentono di descrivere archi e curve.

Poiché Geometry è un tipo di oggetto Freezable, gli oggetti Geometry forniscono diverse funzionalità speciali: gli oggetti possono essere dichiarati come risorse, condivisi tra più oggetti, impostati in sola lettura per migliorare le prestazioni, duplicati e resi thread-safe. Per ulteriori informazioni sulle diverse funzionalità disponibili per gli oggetti Freezable, vedere Cenni preliminari sugli oggetti Freezable.

Oggetti Geometry e forme a confronto

Le classi Geometry e Shape sembrano simili in quanto descrivono entrambe le forme 2D (confrontare ad esempio EllipseGeometry e Ellipse), ma esistono differenze importanti.

Innanzitutto la classe Geometry eredita dalla classe Freezable mentre la classe Shape eredita dalla classe FrameworkElement. Poiché si tratta di elementi, è possibile eseguire il rendering degli oggetti Shape stessi che possono anche partecipare al sistema di layout, al contrario degli oggetti Geometry.

Anche se gli oggetti Shape possono essere utilizzati più prontamente rispetto agli oggetti Geometry, gli oggetti Geometry sono più versatili. Mentre un oggetto Shape viene utilizzato per il rendering di elementi grafici 2D, un oggetto Geometry può essere ad esempio utilizzato per definire l'area geometrica per gli elementi grafici 2D, un'area per il ritaglio o un'area per l'hit test.

La forma del percorso

Un oggetto Shape, la classe Path, utilizza in realtà un oggetto Geometry per descriverne il contenuto. Impostando la proprietà Data della classe Path con un oggetto Geometry e impostandone le proprietà Fill e Stroke, è possibile eseguire il rendering di un oggetto Geometry.

Proprietà comuni che richiedono un oggetto Geometry

Nelle sezioni precedenti è stato menzionato che gli oggetti Geometry possono essere utilizzati con altri oggetti per scopi diversi, come disegnare forme, animare e ritagliare. Nella tabella riportata di seguito vengono elencate numerose classi che dispongono di proprietà che richiedono un oggetto Geometry.

Tipi di geometrie semplici

La classe base per tutti gli oggetti Geometry è la classe astratta Geometry. Le classi che derivano dalla classe Geometry possono essere approssimativamente raggruppate in tre categorie, geometrie semplici, geometrie di percorso e geometrie composte.

Tra le classi di geometrie semplici sono comprese LineGeometry, RectangleGeometry e EllipseGeometry e sono utilizzate per creare forme geometriche di base, come linee, rettangoli e cerchi.

• Un oggetto LineGeometry viene definito specificando il punto iniziale della linea e il punto finale.

• Un oggetto RectangleGeometry viene definito con una struttura Rect che specifica la posizione relativa, l'altezza e la larghezza. È possibile creare un rettangolo arrotondato impostando le proprietà RadiusX e RadiusY.

• Un oggetto EllipseGeometry viene definito da un punto centrale, un raggio x e un raggio y. Negli esempi riportati di seguito viene spiegato come creare semplici geometrie per il rendering e per il ritaglio.

Queste stesse forme, oltre a forme più complesse, possono essere create mediante un oggetto PathGeometry o combinando oggetti Geometry, ma queste classi forniscono un mezzo più semplice di creare queste forme geometriche di base.

Nell'esempio riportato di seguito viene illustrato come creare ed eseguire il rendering di LineGeometry. Come indicato in precedenza, è impossibile che un oggetto Geometry disegni se stesso, pertanto l'esempio utilizza una forma Path per il rendering della linea. Dato che una linea non ha un'area, l'impostazione della proprietà Fill dell'oggetto Path non avrebbe alcun effetto. Al contrario vengono specificate solo le proprietà Stroke e StrokeThickness. Nella figura riportata di seguito viene illustrato l'output dell'esempio.

Un oggetto LineGeometry tracciato da (10,20) a (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;

Nell'esempio successivo viene illustrato come creare ed eseguire il rendering di un oggetto EllipseGeometry. L'esempio fa sì che l'oggetto Center di EllipseGeometry sia impostato al punto 50,50 e che il raggio x e il raggio y siano entrambi impostati su 50, per creare un cerchio con un diametro pari a 100. La parte interna dell'ellisse viene disegnata assegnando un valore alla proprietà Fill dell'elemento Path, in questo caso Gold. Nella figura riportata di seguito viene illustrato l'output dell'esempio.

Un oggetto EllipseGeometry tracciato a (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;

Nell'esempio riportato di seguito viene illustrato come creare ed eseguire il rendering di RectangleGeometry. La posizione e le dimensioni del rettangolo vengono definite da una struttura Rect. La posizione è 50,50 e l'altezza e la larghezza sono entrambi 25, valori che consentono la creazione di un quadrato. Nella figura riportata di seguito viene illustrato l'output dell'esempio.

Un oggetto RectangleGeometry tracciato a 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;

Nell'esempio riportato di seguito viene illustrato come utilizzare un oggetto EllipseGeometry come area di ritaglio per un'immagine. Un oggetto Image viene definito con un valore di Width pari a 200 e un valore di Height pari a 150. Un oggetto EllipseGeometry con un valore di RadiusX pari a 100, un valore di RadiusY pari a 75 e un valore di Center pari a 100,75 viene impostato sulla proprietà Clip dell'immagine. Verrà visualizzata solo la parte dell'immagine che rientra nell'area dell'ellisse. Nella figura riportata di seguito viene illustrato l'output dell'esempio.

Un oggetto EllipseGeometry utilizzato per ritagliare un controllo Image

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

Geometrie di percorso

La classe PathGeometry e l'equivalente più semplice, vale a dire la classe StreamGeometry, forniscono il mezzo per descrivere figure più complesse costituite da archi, curve e linee.

L'oggetto PathGeometry è basato su un insieme di oggetti PathFigure, denominati in questo modo perché ogni figura descrive una forma discreta nell'oggetto PathGeometry. Ciascun oggetto PathFigure è a sua volta composto da uno o più oggetti PathSegment, ognuno dei quali descrive un segmento della figura.

Esistono diversi tipi di segmento.

I segmenti all'interno di una classe PathFigure vengono combinati in una singola forma geometrica, che utilizza il punto finale di ciascun segmento come punto iniziale del segmento successivo. La proprietà StartPoint di PathFigure specifica il punto da cui viene tracciato il primo segmento. Ogni segmento successivo inizia dal punto finale di quello precedente. Ad esempio, una linea verticale da 10,50 a 10,150 può essere definita impostando la proprietà StartPoint su 10,50 e creando un oggetto LineSegment con la proprietà Point impostata su 10,150.

Nell'esempio riportato di seguito viene creata una classe PathGeometry semplice costituita da un singolo oggetto PathFigure con un oggetto LineSegment e viene visualizzata mediante un elemento Path. L'oggetto StartPoint dell'oggetto PathFigure viene impostato su 10,20 e LineSegment viene definito con un punto finale di 100,130. Nella figura riportata di seguito viene illustrato l'oggetto PathGeometry creato da questo esempio.

Un oggetto PathGeometry che contiene un singolo 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).
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;

È utile confrontare questo esempio con il precedente esempio relativo a LineGeometry. La sintassi utilizzata per PathGeometry è molto più dettagliata di quella utilizzata per la classe LineGeometry semplice e potrebbe essere più vantaggioso utilizzare la classe LineGeometry in questo caso, ma la sintassi dettagliata di PathGeometry consente aree geometriche estremamente intricate e complesse.

Si possono creare geometrie più complesse mediante una combinazione di oggetti PathSegment.

Nell'esempio successivo vengono utilizzate le classi BezierSegment, LineSegment e ArcSegment per creare la forma. L'esempio consente innanzitutto di creare una curva di Bezier cubica definendo quattro punti, vale a dire un punto iniziale, che rappresenta il punto finale del segmento precedente, un punto finale (Point3) e due punti di controllo (Point1 e Point2). I due punti di controllo di una curva di Bezier cubica si comportano come magneti, ovvero attraggono determinate parti della linea che sarebbe altrimenti una linea retta producendo una curva. Il primo punto di controllo, Point1, influisce sulla parte iniziale della curva, mentre il secondo punto di controllo, Point2, interessa la parte finale della curva.

Nell'esempio viene quindi aggiunto LineSegment, che viene tracciato tra il punto finale dell'oggetto BezierSegment precedente e il punto specificato dalla proprietà LineSegment.

Nell'esempio viene quindi aggiunto ArcSegment, che viene tracciato dal punto finale dell'oggettoLineSegment precedente al punto specificato dalla proprietà Point. Nell'esempio vengono inoltre specificati i raggi x e y dell'arco (Size), un angolo di rotazione (RotationAngle), un flag che indica l'ampiezza dell'angolo dell'arco risultante (IsLargeArc) e un valore che indica in quale direzione viene tracciato l'arco (SweepDirection). Nella figura riportata di seguito viene illustrata la forma creata da questo esempio.

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

Si possono creare geometrie ancora più complesse utilizzando più oggetti PathFigure all'interno di PathGeometry.

Nell'esempio riportato di seguito viene creato un oggetto PathGeometry con due oggetti PathFigure, ciascuno contenente più oggetti PathSegment. Vengono utilizzati l'oggetto PathFigure dell'esempio precedente e un oggetto PathFigure con PolyLineSegment e QuadraticBezierSegment. PolyLineSegment viene definito con una matrice di punti e QuadraticBezierSegment è definito da un punto di controllo e da un punto finale. Nella figura riportata di seguito viene illustrata la forma creata da questo esempio.

Un oggetto PathGeometry con più figure

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

StreamGeometry

Come la classe PathGeometry, StreamGeometry definisce una forma geometrica complessa che potrebbe contenere curve, archi e linee. A differenza di PathGeometry, il contenuto di StreamGeometry non supporta l'associazione dati, l'animazione o la modifica. Utilizzare StreamGeometry per descrivere una geometria complessa senza il sovraccarico dovuto al supporto dell'associazione dati, dell'animazione o della modifica. Grazie alla sua efficienza, la classe StreamGeometry rappresenta una scelta ottimale per la descrizione degli strumenti decorativi visuali.

Per un esempio, vedere Procedura: creare forme tramite un oggetto StreamGeometry.

Sintassi di markup del percorso

I tipi PathGeometry e StreamGeometry supportano la sintassi dell'attributo Extensible Application Markup Language (XAML) mediante una serie speciale di comandi di spostamento e di disegno. Per ulteriori informazioni, vedere Sintassi di markup del percorso.

Geometrie composte

Gli oggetti Geometry composti possono essere creati utilizzando GeometryGroup, CombinedGeometry o richiamando il metodo statico Combine dell'oggetto Geometry.

• L'oggetto CombinedGeometry e il metodo Combine consentono di eseguire un'operazione booleana per combinare l'area definita da due geometrie. Gli oggetti Geometry che non dispongono di alcuna area vengono ignorati. Solo due oggetti Geometry possono essere combinati (anche se queste due geometrie possono anche essere composte).

• La classe GeometryGroup consente di creare una combinazione degli oggetti Geometry in essa contenuti senza combinarne l'area. È possibile aggiungere qualsiasi numero di oggetti Geometry a GeometryGroup. Per un esempio, vedere Procedura: creare una forma composta.

Poiché non viene eseguita un'operazione di combinazione, l'utilizzo degli oggetti GeometryGroup fornisce vantaggi in termini di prestazioni rispetto all'utilizzo degli oggetti CombinedGeometry o del metodo Combine.

Geometrie combinate

Nella sezione precedente è stato spiegato che l'oggetto CombinedGeometry e il metodo Combine combinano l'area definita dalle geometrie in essi contenute. L'enumerazione GeometryCombineMode specifica come vengono combinate le geometrie. Tra i possibili valori per la proprietà GeometryCombineMode sono compresi Union, Intersect, Exclude e Xor.

Nell'esempio riportato di seguito viene definito un oggetto CombinedGeometry con una modalità di combinazione di unione. Entrambi gli oggetti Geometry1 e Geometry2 sono definiti come cerchi dello stesso raggio, ma con un offset dei centri di 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>

Nell'esempio riportato di seguito viene definito un oggetto CombinedGeometry con una modalità di combinazione Xor. Entrambi gli oggetti Geometry1 e Geometry2 sono definiti come cerchi dello stesso raggio, ma con offset dei centri di 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>

Per ulteriori esempi, vedere Procedura: creare una forma composta e Procedura: creare una geometria combinata.

Funzionalità dell'oggetto Freezable

Poiché eredita dalla classe Freezable, la classe Geometry fornisce numerose funzionalità speciali: gli oggetti Geometry possono essere dichiarati come Cenni preliminari sulle risorse, condivisi tra più oggetti, impostati in sola lettura per migliorare le prestazioni, duplicati e resi thread-safe. Per ulteriori informazioni sulle diverse funzionalità disponibili per gli oggetti Freezable, vedere Cenni preliminari sugli oggetti Freezable.

Ulteriori funzionalità degli oggetti Geometry

La classe Geometry fornisce inoltre metodi dell'utilità vantaggiosi, come i seguenti:

• GetArea - Ottiene l'area dell'oggetto Geometry.

• FillContains - Consente di determinare se l'oggetto Geometry contiene un altro oggetto Geometry.

• StrokeContains - Consente di determinare se il tratto dell'oggetto Geometry contiene un punto specificato.

Per un elenco completo dei metodi, vedere la classe Geometry.

Vedere anche

Concetti

Ottimizzazione delle prestazioni: grafica bidimensionale e creazione di immagini

Sintassi di markup del percorso

Cenni preliminari sull'animazione

Cenni preliminari sugli oggetti Shape e sulle funzionalità di disegno di base di WPF

Cenni preliminari sugli oggetti Drawing

Riferimenti

Geometry

PathGeometry

Path

GeometryDrawing

Altre risorse

Procedure relative agli oggetti Geometry

Esempi relativi agli oggetti Geometry