Home

Dessin de Courbes

 

Introduction aux courbes

 

Introduction

Une courbe est une ligne qui relie deux points ou plus. Si seulement deux points sont impliqués, la ligne se joindrait à eux mais la ligne n'est pas droite. S'il y a trois points A, B et C, la ligne démarrerait sur le premier point A, traverserait le deuxième point B et s'arrêterait au dernier point C. Si plus de trois points sont impliqués, la ligne commencerait sur le premier, traverserait le deuxième et le troisième de chaque ligne avant de s'arrêter sur la dernière. Les points d'une courbe ne doivent pas être alignés.

En fait, l'idée de dessiner une courbe est d'avoir une ligne non droite qui relie les différents points non alignés. Cela peut être illustré avec les trois courbes suivantes intitulées C1, C2 et C3 :


La première courbe, C1, inclut seulement deux points. La seconde, C2 comprend trois points. La troisième, C3, comprend quatre points.

La section entre deux points est appelée un segment. Cela signifie également qu'une courbe peut être distinguée par le nombre de segments qu'elle a. Si une courbe est constituée uniquement de deux points, cela signifie qu'elle n'a qu'un seul segment de la première à la seconde, qui est le dernier point. Si une courbe comprend trois points, elle a deux segments. Le premier segment s'étend du premier point au deuxième point, et le deuxième segment s'étend depuis le deuxième point pour le troisième point. Sur cette base, le nombre de segments d'une courbe est égal au nombre de ses points - 1.

Une courbe peut être tirée dans GDI + à l'aide de la méthode de Curve() Graphics.Draw. Lorsque vous dessinez une courbe, vous devez spécifier combien de points pourraient être impliqués. Cela signifie que vous pouvez tout d'abord déclarer un tableau de valeurs de point ou PointF. Car il est laissé à vous de décider sur cette question, la classe Graphics fournit les syntaxes suivantes de la méthode DrawCurve() :

public void DrawCurve(Pen pen, Point[] points);  
public void DrawCurve(Pen pen, PointF[] points);

Cette version de la méthode prend un tableau de valeurs de point ou PointF comme arguments. Le nombre de membres de la batterie dépend de vous. Voici un exemple qui utilise quatre points pour dessiner une courbe avec trois segments :

using System;  
using System.Drawing;  
using System.Windows.Forms;    
 
 
public class Exercise : Form  
{      
	public Exercise()      
	{          
		InitializeComponent();      
	}        
 
 
	void InitializeComponent()      
	{          
		Paint += new PaintEventHandler(Exercise_Paint);      
	}        
 
 
	private void Exercise_Paint(object sender, PaintEventArgs e)      
	{          
		Pen penCurrent = new Pen(Color.Blue);          
		Point[] pt = { new Point( 40,  42),  	              
					  new Point(188, 246),                                
					  new Point(484, 192),  	              
					  new Point(350,  48) };            
 
 
		e.Graphics.DrawCurve(penCurrent, pt);      
	}  
}    
 
 
public class Program  
{      
	 public static int Main()      
	 {          
		 Application.Run(new Exercise());            
		 
		 return 0;      
	}  
}

Cela donnerait :

Curve

Comme vous pouvez le voir, lorsque la courbe est dessinée, une ligne tordue traverse les points intermédiaires entre le premier et le dernier. Pour rendre les lignes non droites, le compilateur utilise une valeur appelée tension utilisée pour la ligne de pliage. Si vous le souhaitez, vous pouvez spécifier le facteur de pliage qui doit être appliqué. Pour ce faire, vous utiliseriez la version suivante de la méthode DrawCurve() :

public void DrawCurve(Pen pen,     		      
					   Point[]points,   		      
					   float tension);  
public void DrawCurve(Pen pen,   		      
					   PointF[] points,   		      
					   float tension);

Le montant de pliage à appliquer est transmis comme argument de la tension. Il peut être passé comme une valeur décimale > = 0,00. Si cette valeur est transmise comme 0,00, les lignes seraient tirées directement. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
	Point[] pt = { new Point(40,  42),  	              
		   new Point(188, 246),                                
			new Point(484, 192),  	              
		   new Point(350,  48) };            
		 
	e.Graphics.DrawCurve(penCurrent, pt, 0.00F);  
}

Curve

Cela signifie que, si vous souhaitez une courbe réelle, soit vous ne transmettez pas l'argument de la tension et utilisez la première version de la méthode ou vous transmettez l'argument de tension comme une valeur supérieure à 0,00. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
        Point[] pt = { new Point(40,  42),  	              
			   new Point(188, 246),                                
			   new Point(484, 192),  	              
			   new Point(350,  48) };            
		 
	e.Graphics.DrawCurve(penCurrent, pt, 2.15F);  
}

Cela donnerait :

A curve with a tension value of 2.15

Les deux versions de la méthode DrawCurve() que nous avons utilisées permettent de démarrer la courbe sur le premier point. Prenons l'exemple suivant qui dessine une courbe de cinq points résultant dans quatre secteurs :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
	PointF[] pt = { new PointF(20.00F,  322.00F),  		
			 new PointF(124, 24),  	            	
			 new PointF(214, 242),   		
			 new PointF(275,  28),           	    	
			 new PointF(380.00F,  322.00F) };            
		
 	e.Graphics.DrawCurve(penCurrent, pt);  
}

Cela donnerait :

Curve

Si vous le souhaitez, vous pouvez démarrer la courbe sur n'importe quel point au lieu du premier. Pour cela, la classe Graphics fournit la version suivante de la méthode DrawCurve() :

public void DrawCurve(Pen pen,   	           
		      PointF[] points,   	           
		      int offset,   	           
		      int numberOfSegments);

L'argument offset vout permet de spécifier combien de points doivent être ignorés avant de commencer à dessiner. La première conclusion est que la valeur offset doit être égale ou supérieure à 0. Si vous transmettez cet argument avec la valeur 0, la courbe serait prélevée sur le premier point. Si vous transmettez cet argument comme 1, le premier point ne serait pas considéré dans la courbe. Cela signifie que le dessin de la courbe commencerait sur le second point et ainsi de suite. Si vous lui transmettez comme 2, le premier et le deuxième point ne feraient pas partie de la courbe, ce qui signifie que la courbe commencerait sur le troisième point.

Après le démarrage de la courbe au point que vous spécifiez à l'aide de l'argument Offset, vous pouvez ensuite spécifier combien de segments de la courbe devraient être tirés. Ce numéro doit être inférieur au nombre de segments disponibles, c'est-à-dire après soustraction de la valeur Offset du nombre total de segments de la baie. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	 Pen penCurrent = new Pen(Color.Blue);          
	 PointF[] pt = { new PointF(20.00F,  322.00F),  			   
				new PointF(124, 24),  	            	   
				new PointF(214, 242),  			   
				new PointF(275,  28),                      	   
				new PointF(380.00F,  322.00F) };            
 
	 e.Graphics.DrawCurve(penCurrent, pt, 1, 2);  
}

Cela donnerait :

A curve with an offset value and a limited number of segments


Une fois de plus, le compilateur s'organise pour appliquer une tension lors de l'élaboration de la courbe. Si vous préférez utiliser des lignes droites ou appliquer une tension différente de celle par défaut, vous pouvez utiliser la version suivante de la méthode de Curve() Graphics.Draw :

public void DrawCurve(Pen pen,   		   
			Point[] points,   		   
			int offset,   		   
			int numberOfSegments,   		   
			float tension);  
public void DrawCurve(Pen pen,   		   
			PointF[] points,   		   
			int offset,   		   
			int numberOfSegments,   		   
			float tension);

Cette fois, vous pouvez passer la valeur de la tension comme 0 pour obtenir des lignes droites :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
	PointF[] pt = { new PointF(20.00F,  322.00F),  			   
			new PointF(124, 24),  	                   
			new PointF(214, 242),  			   
			new PointF(275,  28),                  	   
			new PointF(380.00F,  322.00F) };            
 
	 e.Graphics.DrawCurve(penCurrent, pt, 0, 4, 0);  
}

Cela donnerait :

Curve


Ou vous pouvez transmettre les tensions avec n'importe quelle valeur positive de votre choix. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
	PointF[] pt = { new PointF(20.00F, 322.00F),                          
			 new PointF(124, 24),  	                
			 new PointF(214, 242),  	                
			 new PointF(275, 28),                      	
			 new PointF(380.00F, 322.00F) };            
 
	 e.Graphics.DrawCurve(penCurrent, pt, 1, 3, 1.750F);  
}

Cela donnerait :

Curve

 

Une courbe de Bézier

Une courbe de bézier est une ligne continue qui est dessinée à l'aide de quatre points qui ne sont pas nécessairement alignés. Elle peut être illustrée comme suit :

Bezier


Pour dessiner la ligne (avec quatre points), le compilateur attire une courbe du premier point au quatrième point. Puis il plierait la courbe en apportant, de chaque còté (demi-centre) du milieu près deça alos deuxième et troisième points respectivement sans toucher les second et troisième points. Par exemple, la courbe de bézier ci-dessus pourrait avoir été tracée à l'aide des quatre points suivants :

Bezier Illustration


Pour dessiner une courbe de bézier, la classe Graphics fournit la méthode DrawBezier() qui est surchargée en trois versions dont les syntaxes sont :

public void DrawBezier(Pen pen,                         
			Point pt1,                         
			Point pt2,                         
			Point pt3,                         
			Point pt4);  
public void DrawBezier(Pen pen,                         
			PointF pt1,                         
			PointF pt2,                         
			PointF pt3,                         
			PointF pt4);  
public void DrawBezier(Pen pen,                         
			float x1,                         
			float y1,                         
			float x2,                         
			float y2,                         
			float x3,                         
			float y3,                         
			float x4,                         
			float y4);

Basé sur ce point, pour dessiner une ligne de bézier, vous pouvez utiliser quatre valeurs de point ou PointF ou les coordonnées des quatre points. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
	Point pt1 = new Point(20, 12),                      
	      pt2 = new Point(88, 246),                      
	      pt3 = new Point(364, 192),                      
		 pt4 = new Point(250, 48);            
 
 	 e.Graphics.DrawBezier(penCurrent, pt1, pt2, pt3, pt4);  
}

Cela donnerait :

Bezier Curve

Une série de courbes de Bézier

La méthode Graphics.DrawBezier() est utilisée pour dessiner une courbe de bézier. Si vous souhaitez dessiner plusieurs courbes de bézier, vous pouvez appeler la méthode Graphics.Draw Bezier qui est surchargée en deux versions comme suit :

public void DrawBeziers(Pen pen, Point[] points);  
public void DrawBeziers(Pen pen, PointF[] points);

La méthode DrawBeziers() requiert un tableau du point de valeurs PointF. Lorsque vous travaillez avec seulement quatre coordonnées, la méthode DrawBeziers() fonctionne exactement comme DrawBezier(), la différence est que, tandis que DrawBezier() prévoit quatre points ou quatre valeurs PointF, DrawBeziers() attend un tableau de valeurs PointF ou Point. En utilisant DrawBeziers(), la courbe de bézier ci-dessus peut être établie comme suit et produire le même résultat :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
    Pen penCurrent = new Pen(Color.Blue);          
    Point[] pt = { new Point(20,  12), new Point(88, 246),  		          
		  new Point(364, 192), new Point(250,  48) };           
 
    e.Graphics.DrawBeziers(penCurrent, pt);  
}
Cela donnerait :
 
    Curve 

Une caractéristique de l'utilisation DrawBeziers() est qu'il permet de dessiner une courbe de bézier à l'aide des valeurs de point ou PointF 7. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
        Point[] pt = { new Point( 10,  5), new Point(340, 60),                            
			  new Point(320, 148), new Point(150, 120),  	                  
			  new Point(24, 220), new Point(250, 150),  	                  
			  new Point(304, 240) };            
 

     e.Graphics.DrawBeziers(penCurrent, pt);  
}

Cela donnerait :

Beziers
 

Une Courbe Fermée

Si vous utilisez DrawLines(), DrawBezier() ou les méthodes DrawBeziers(), vous obtiendrez une ligne continue ou une série de lignes qui a un début et une fin.

également, GDI + vous permet de dessiner une série de lignes mais se joindre à la fin de la dernière ligne au début de la première ligne d'avoir une forme fermée. Pour dessiner ce chiffre, vous pouvez appeler la méthode ClosedCurve() Graphics.Draw qui est surchargée en quatre versions. Deux d'entre elles ont des syntaxes suivantes :

public void DrawBeziers(Pen pen, Point[] points);  
public void DrawClosedCurve(Pen pen, PointF[] points);

Ces deux versions sont les plus faciles à utiliser. Elles permettent de fournir un tableau de quatre points ou quatre valeurs PointF. Lors de l'exécution, chacune de ces méthodes dessine une courbe qui traverse chaque coordonnée et ferme la courbe en rejoignant le point final à la première, à moins que les deux points soient les mêmes. Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Blue);          
	Point[] pt = { new Point(40,  42), new Point(188, 246),                            
			  new Point(484, 192), new Point(350,  48) };            
 
     e.Graphics.DrawClosedCurve(penCurrent, pt);  
}

Cela donnerait :

Closed Curve

Les deux premières versions sont utilisées pour dessiner les lignes mais les courber afin que la forme apparaisse lisse. Si vous le souhaitez, vous pouvez dessiner les lignes droites d'un point à l'autre sans les courber. En utilisant ce scénario, la forme ci-dessus apparaitrait comme suit :

Closed Shape With Straight Lines

Pour dessiner ce type de forme à l'aide de la méthode DrawClosedCurve(), vous pouvez utiliser une des versions suivantes de la méthode :

public void DrawClosedCurve(Pen pen,   			 
			    Point[] points,   			 
			    float tension,   			 
			    FillMode fillmode);  
public void DrawClosedCurve(Pen pen,   			 
			    PointF[] points,   			 
			    float tension,   			 
			    FillMode fillmode);

Ces versions vous permettent d'indiquer la tension et le mode de remplissage. Le facteur de tension vous permet d'indiquer combien de courbes seraient appliquées. Si cette valeur est transmise comme 0,00, les points pourraient être rejoints avec des lignes droites. Dans le cas contraire, vous pouvez appliquer une tension à l'aide d'une valeur décimale appropriée.

Le facteur fillmode détermine comment l'intérieur de la courbe devrait être rempli. Il est contròlé par le biais de l'énumérateur FillMode qui est défini dans l'espace de noms System.Drawing.Drawing2D. L'énumérateur FillMode a deux membres : Alternate et Winding. Voici un exemple :

using System;  
using System.Drawing;  
using System.Windows.Forms;  
using System.Drawing.Drawing2D;    
 
 
public class Exercise : Form  
{      
	 public Exercise()      
	 {          
		 InitializeComponent();      
	 }        
 
 
	 void InitializeComponent()      
	 {          
		Paint += new PaintEventHandler(Exercise_Paint);      
	 }        
 
 
	 private void Exercise_Paint(object sender, PaintEventArgs e)      
	 {          
		 Pen penCurrent = new Pen(Color.Red);          
		 Point[] pt = { new Point(40,  42), new Point(188, 246),                            
				new Point(484, 192), new Point(350,  48) };            
 
 
	 	 e.Graphics.DrawClosedCurve(penCurrent, pt, 0.75F,                       
				 	  FillMode.Winding);      
	}  
}    
 
 
public class Program  
{      
	 public static int Main()      
	 {          
		 Application.Run(new Exercise());           
 
 
		 return 0;      
	}  
}

Cela donnerait :

Closed Curve

N'oubliez pas que plus haute est la tension, plus nets sont les coins. Si vous souhaitez que la forme affiche les lignes droites, transmettez une tension de 0.00F.

Les Tartes

Un secteur est une fraction d'une ellipse délimitée par un angle de départ et un angle qui constitue la partie voulue pour faire un secteur. Il peut être illustré comme suit :

Pie Illustration

Pour tracer un graphique, vous pouvez utiliser la méthode Graphics.DrawPie() qui vient dans différentes versions comme suit :

public void DrawPie(Pen pen,                   
		    Rectangle rect,                   
		    float startAngle,                   
		    float sweepAngle);  
public void DrawPie(Pen pen,                   
		    RectangleF rect,                   
		  float startAngle,                   
		  float sweepAngle);  
public void DrawPie(Pen pen,                   
		  int x,                   
		  int y,                   
		  int width,                   
		  int height,                   
		  int startAngle,                   
		  int sweepAngle);  
public void DrawPie(Pen pen,                   
		  float x,                   
		  float y,                   
		  float width,                   
		  float height,                   
		  float startAngle,                   
		  float sweepAngle);

Un secteur repose sur une ellipse (comme un arc). L'ellipse s'adapte dans un rectangle transmis comme argument rect. Le rectangle peut également être spécifié par son emplacement (x, y) et ses dimensions (largeur et hauteur).

à l'intérieur du rectangle parent dans lequel une ellipse pourrait être dessinée, vous définissez un angle de départ. Cet angle est mesuré de 0 en haut compté dans le sens des aiguilles d'une montre (comme les numéros d'une horloge analogique). Cela signifie qu'un angle de 90 représente 6 heures et pas 12 heures. Cet angle de départ est transmis comme argument startAngle.

Après avoir spécifié l'angle de départ, vous devez spécifier la quantité d'angle couvert par le graphique. Cela est aussi mesuré dans le sens des aiguilles d'une montre. Cette valeur est transmise en tant qu'argument sweepAngle.

Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
		 Pen penCurrent = new Pen(Color.Red);          
		 e.Graphics.DrawPie(penCurrent, 20, 20, 200, 100, 45, 255);  
}

Cela donnerait :

Pie

ApplicationApplication : Dessin d'une ellipse

  1. Démarrez Microsoft Visual c# et créez une nouvelle Application Windows nommée SchoolEnrolment1
  2. Concevez le formulaire comme suit :
     

    School Enrolment

    Control

    Name

    Text

    Label

    Label

     

    Enrolment / Program ___________________________

    Label

    Label

     

    Graduates

    Label

    Label

     

    Undergraduates

    Label

    Label

     

    Certificates

    TextBox

    TextBox

    txtGraduates

    0

    TextBox

    TextBox

    txtUndergraduates

    0

    TextBox

    TextBox

    txtCertificates

    0

    Button

    Button

    btnCreateChart

    Create Chart

    PictureBox

    PictureBox

    pbxChart

     

    Label

    Label

     

    ____Legend____

    Label

    Label

    lblGraduates

    Graduates

    Label

    Label

    lblUndergraduates

    Undergraduates

    Label

    Label

    lblCertificates

    Certificates

    Button

    Button

    btnClose

    Close

  3. Cliquez droit sur le formulaire, puis cliquez sur Afficher le code
  4. Déclarez les trois variables comme suit :
    using System;  
    using System.Collections.Generic;  
    using System.ComponentModel;  
    using System.Data;  
    using System.Drawing;  
    using System.Linq;  
    using System.Text;  
    using System.Windows.Forms;    
     
     
    namespace SchoolEnrolment1  
    {      
        public partial class Form1 : Form      
        {          
            float Graduates;          
            float Undergraduates;          
            float Certificates;            
     
     
            public Form1()          
            {              
                InitializeComponent();          
            }      
        }  
    }
  5. Retournez à l'écran et cliquez sur une zone libre de son corps
  6. Dans la fenêtre Propriétés, cliquez sur le bouton événements Events
  7. Double-cliquez sur le champ de la peinture et exécutez l'événement comme suit :
    private void Form1_Paint(object sender, PaintEventArgs e)  
    {              
    	pbxChart.CreateGraphics().DrawEllipse(new Pen(Color.Red),                                
    					  new Rectangle(0,  0, 260, 200));              
    	pbxChart.CreateGraphics().DrawPie(new Pen(Color.Blue),                                        
    				  0.0F, 0.0F, 260.0F, 200.0F, 0.0F, Graduates);              
    	pbxChart.CreateGraphics().DrawPie(new Pen(Color.Green),                                        
    						  0.0F, 0.0F, 260.0F,                          
    					200.0F, Graduates, Undergraduates);              
    	pbxChart.CreateGraphics().DrawPie(new Pen(Color.Fuchsia),                                        
    					  0.0F, 0.0F, 260.0F,                            
    					  200.0F, Graduates + Undergraduates,                                
    					  Certificates);                
     
    	e.Graphics.DrawEllipse(new Pen(Color.Blue),                                    
    				  new Rectangle(lblGraduates.Left,                                  
    				lblGraduates.Top + 20,                          
    				lblUndergraduates.Width,                          
    				20));                
     
    	e.Graphics.DrawEllipse(new Pen(Color.Green),                                    
    			  new Rectangle(lblUndergraduates.Left,                                  
    			lblUndergraduates.Top + 20,                          
    			lblUndergraduates.Width,                          
    			20));                
     
    	e.Graphics.DrawEllipse(new Pen(Color.Fuchsia),                                    
    				  new Rectangle(lblCertificates.Left,                                  
    				lblCertificates.Top + 20,                          
    				lblUndergraduates.Width,                              
    				20));  
    }
  8. Retournez à l'écran et cliquez sur la zone de l'image
  9. Dans la section Evénements de la fenêtre Propriétés, double-cliquez sur la peinture et exécutez son événement comme suit :
    private void pbxChart_Paint(object sender, PaintEventArgs e)  
    {              
    	Invalidate();  
    }
  10. Retournez à l'écran et cliquez deux fois sur le bouton Créer un graphique
  11. Mettez en œuvre l'événement comme suit :
    private void btnCreateChart_Click(object sender, EventArgs e)  
    {              
    	float grad = 0.00F,                    
    		under = 0.00F,                    
    		cert = 0.00F,                    
    		total = 0.00F;              
    	float percentGraduates,                
    		percentUndergraduates,                
    		percentCertificates;                
     
         try              
    	  {                  
    	 grad = float.Parse(txtGraduates.Text);              
         }              
         catch (FormatException)              
         {                  
    	  MessageBox.Show("Invalid graduate value");              
         }                
     
         try              
         {                  
    	 under = float.Parse(txtUndergraduates.Text);              
         }              
         catch (FormatException)              
         {                  
    	  MessageBox.Show("Invalid graduate value");              
         }                
     
         try              
         {                  
    	  cert = float.Parse(txtCertificates.Text);              
         }              
         catch (FormatException)              
         {                  
    	  MessageBox.Show("Invalid graduate value");              
         }                
     
         total = grad + under + cert;              
         percentGraduates = (grad / total) * 100;              
         percentUndergraduates = (under / total) * 100;              
         percentCertificates = (cert / total) * 100;                
     
         Graduates = (360 * percentGraduates) / 100;              
         Undergraduates = (360 * percentUndergraduates) / 100;              
         Certificates = (360 * percentCertificates) / 100;                
    			  
         pbxChart.Invalidate();  
    }
  12. Exécutez l'application et testez le formulaire.
     
     School Enrolment
  13. Après utilisation, fermez le formulaire.

Les Arcs

Un arc est une partie ou segment d'une ellipse, ce qui signifie qu'un arc est une ellipse non complète. Si un secteur est une forme fermée, un arc ne l'est pas : il utilise uniquement une partie de la ligne qui définit une ellipse. Parce qu'un arc doit confirmer la forme d'une ellipse, elle est définie comme si elle s'intègre dans un rectangle et peut être illustré comme suit :

Arc

Pour prendre en charge les arcs, la classe Graphics est équipée de la méthode DrawArc() qui est fournie dans les quatre versions dont les syntaxes sont :

public void DrawArc(Pen pen,                   
		    Rectangle rect,                   
		    float startAngle, float sweepAngle); 
public void DrawArc(Pen pen,                   
		    RectangleF rect,                   
		    float startAngle, float sweepAngle);  
public void DrawArc(Pen pen,                   
		    int x, int y, int width, int height,                   
		    int startAngle, int sweepAngle);  
public void DrawArc(Pen pen,                   
		    float x, float y, float width, float height,                   
		    float startAngle, float sweepAngle);

L'ellipse qui contiendrait l'arc doit être établie dans un rectangle ou un RectangleF rect. Vous pouvez également définir cette ellipse par les coordonnées de son rectangle inscrit x, y et ses dimensions Largeur, hauteur. Outre les frontières du rectangle dans lequel l'arc se forme, un arc doit spécifier son angle de départ, startAngle, mesuré dans le sens des aiguilles d'une montre des x-axis son point de départ. Un arc doit également déterminer son angle de balayage mesuré dans le sens des aiguilles d'une montre du paramètre startAngle à la fin de l'arc. Ces deux valeurs suivent les mêmes définitions que nous avons examinées pour la méthode Graphics.Pie().

Voici un exemple :

private void Exercise_Paint(object sender, PaintEventArgs e)  
{          
	Pen penCurrent = new Pen(Color.Red);          
	e.Graphics.DrawArc(penCurrent, 20, 20, 200, 150, 225, 200);  
}

Arc

 
 
 
 

Précédent Copyright © 2009-2011, yevol.com Suivant