Stroke.GetRectangleIntersections, méthode

Article
11/05/2008

Mise à jour : November 2007

Retourne un tableau des structures StrokeIntersection qui indiquent où un objet Stroke croise un Rectangle (page pouvant être en anglais) donné.

Espace de noms : Microsoft.Ink
Assembly : Microsoft.Ink (dans Microsoft.Ink.dll)

Syntaxe

'Déclaration
Public Function GetRectangleIntersections ( _
    intersectRectangle As Rectangle _
) As StrokeIntersection()
'Utilisation
Dim instance As Stroke
Dim intersectRectangle As Rectangle
Dim returnValue As StrokeIntersection()

returnValue = instance.GetRectangleIntersections(intersectRectangle)

public StrokeIntersection[] GetRectangleIntersections(
    Rectangle intersectRectangle
)

public:
array<StrokeIntersection>^ GetRectangleIntersections(
    Rectangle intersectRectangle
)

public StrokeIntersection[] GetRectangleIntersections(
    Rectangle intersectRectangle
)

public function GetRectangleIntersections(
    intersectRectangle : Rectangle
) : StrokeIntersection[]

Paramètres

intersectRectangle
Type : System.Drawing.Rectangle
Structure Rectangle (page pouvant être en anglais), sous forme de coordonnées de l'espace d'entrée manuscrite, qui décrit à la zone de test de positionnement.

Valeur de retour

Type : array<Microsoft.Ink.StrokeIntersection[]
Retourne un tableau des structures StrokeIntersection qui indiquent où un objet Stroke croise le paramètre intersectRectangle.

Notes

Cette méthode retourne zéro ou plusieurs ensembles d'indices qui représentent le début et la fin des segments du trait qui croisent le rectangle. Si un trait traverse simplement un rectangle, en croisant la limite en deux endroits, l'ensemble d'indices est composé des valeurs d'index à virgule flottante de chaque intersection. Si un trait croise un rectangle plus de deux fois, le nombre d'indices augmente en fonction du nombre d'intersections.

Si le trait commence dans le rectangle de test, la propriété BeginIndex du premier élément StrokeIntersection a la valeur -1. Si le trait se termine dans le rectangle de test, la propriété EndIndex du dernier élément StrokeIntersection a la valeur -1. Si la totalité du trait est contenue dans le rectangle, le tableau retourné comprendra une seule structure StrokeIntersection dont les propriétés BeginIndex et EndIndex auront la valeur -1. Si la totalité du trait se trouve à l'extérieur du rectangle de test, un tableau StrokeIntersection vide est retourné.

Par exemple, si un trait commence à l'intérieur du rectangle de test, dépasse les limites du rectangle, y retourne, puis les dépasse de nouveau, la méthode GetRectangleIntersections peut retourner {{-1, 1.4}, {5.5, 10.1}} pour décrire les deux segments du trait qui sont dans le rectangle.

Les structures StrokeIntersection que cette méthode retourne contiennent des paires de valeurs d'index à virgule flottante qui indiquent les emplacements des intersections. L'index à virgule flottante désigne une valeur float qui représente un emplacement situé entre deux points de l'objet Stroke. Par exemple, si 0.0 est le premier point du trait et 1.0 le deuxième, 0.5 est à mi-chemin entre le premier et le deuxième points. De la même façon, une valeur d'index à virgule flottante de 37,25 représente un emplacement qui est situé à 25 % sur la longueur de la ligne entre les points 37 et 38 du trait.

Exemples

Dans cet exemple, tous les segments d'un objet Stroke passé se trouvant à l'intérieur de la structure Rectangle (page pouvant être en anglais) spécifiée sont supprimés. Pour ce faire, les structures StrokeIntersection sont examinées afin de déterminer où fractionner l'objet Stroke passé et les segments à supprimer.

Private Sub DeleteInsideRectangle(ByVal S As Stroke, ByVal R As Rectangle)
    ' get the StrokeIntersection array
    Dim SI() As StrokeIntersection = S.GetRectangleIntersections(R)
    ' examine each StrokeIntersection
    ' must work backwards through the array so that when splitting, 
    ' the remaining intersections are still valid for S
    For k As Integer = SI.Length - 1 To 0 Step -1

        Dim enterRect As Single = SI(k).BeginIndex
        Dim exitRect As Single = SI(k).EndIndex

        ' check if the whole stroke is inside the rectangle
        ' if so, delete the stroke
        If enterRect = -1 And exitRect = -1 Then
            S.Ink.DeleteStroke(S)
            Continue For
        End If

        ' check if a segment enters and exits the rectangle
        ' if so, split and delete the segment inside the rectangle
        If enterRect > 0 And exitRect > 0 Then
            ' the stroke resulting from split() is outside, keep it
            S.Split(exitRect)
            ' the stroke from this split() is inside, delete it
            Dim temp As Stroke = S.Split(enterRect)
            temp.Ink.DeleteStroke(temp)
            Continue For
        End If

        ' check if stroke starts inside the rectangle and goes outside
        ' if so, split and delete the segment inside the rectangle
        If enterRect = -1 And exitRect > 0 Then
            ' the stroke resulting from split() is outside, keep it
            S.Split(exitRect)
            ' delete the remaining segment of the stroke
            S.Ink.DeleteStroke(S)
            Continue For
        End If

        ' check if stroke starts outside the rectangle and ends inside
        ' if so, split and delete the segment inside the rectangle
        If enterRect > 0 And exitRect = -1 Then
            Dim temp2 As Stroke = S.Split(enterRect)
            temp2.Ink.DeleteStroke(temp2)
        End If
    Next
End Sub

private void DeleteInsideRectangle(Stroke S, Rectangle R)
{
    // get the StrokeIntersection array
    StrokeIntersection[] SI = S.GetRectangleIntersections(R);

    // examine each StrokeIntersection
    // must work backwards through the array so that when splitting, 
    // the remaining intersections are still valid for S
    for (int k = SI.Length - 1; k >= 0; k--)
    {
        float enterRect = SI[k].BeginIndex;
        float exitRect = SI[k].EndIndex;

        // check if the whole stroke is inside the rectangle
        // if so, delete the stroke
        if (enterRect == -1 && exitRect == -1)
        {
            S.Ink.DeleteStroke(S);
            continue;
        }

        // check if a segment enters and exits the rectangle
        // if so, split and delete the segment inside the rectangle
        if (enterRect > 0 && exitRect > 0)
        {
            // the stroke resulting from split() is outside, keep it
            S.Split(exitRect);
            // the stroke from this split() is inside, delete it
            Stroke temp = S.Split(enterRect);
            temp.Ink.DeleteStroke(temp);
            continue;
        }

        // check if stroke starts inside the rectangle and goes outside
        // if so, split and delete the segment inside the rectangle
        if (enterRect == -1 && exitRect > 0)
        {
            // the stroke resulting from split() is outside, keep it
            S.Split(exitRect);
            // delete the remaining segment of the stroke
            S.Ink.DeleteStroke(S);
            continue;
        }

        // check if stroke starts outside the rectangle and ends inside
        // if so, split and delete the segment inside the rectangle
        if (enterRect > 0 && exitRect == -1)
        {
            Stroke temp2 = S.Split(enterRect);
            temp2.Ink.DeleteStroke(temp2);
        }
    }
}

Plateformes

Windows Vista

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.