Comment dessiner un rectangle avec les coins arrondis

Dutch French Spanish Portuguese Italian German Japanese Chinese Korean Russian Arabic Bookmark and Share this Article Original English article
  

Vous voulez dessiner un rectangle avec des coins arrondis, un excentrage, ou rotation.Create une méthode de la coutume MovieClip.drawRectangle() en utilisant l'api de dessin et l'appelez sur une agrafe de film.

La méthode de drawSimpleRectangle() est, car le nom suggère, tout à fait simple. Créons une version plus complexe qui aussi :

  • Dessine un rectangle avec un angle indiqué de rotation
  • Vous indiquons les coordonnées du centre de rectangle
  • Peut dessiner un rectangle avec les coins arrondis

La méthode de drawRectangle() accepte six paramètres :

largeur
La largeur du rectangle en Pixel

taille
La taille du rectangle en Pixel

rond
Le rayon (en Pixel) de l'arc qui est employé à rond les coins. Si la valeur est non définie ou 0, les coins demeurent place.

rotation
La rotation dans le sens des aiguilles d'une montre à s'appliquer au rectangle en degrés. Si éliminé, le rectangle n'est pas tourné.

X
X du point central pour le rectangle. Si éliminé, le rectangle est centré à x = 0.

y
Y du point central pour le rectangle. Si éliminé, le rectangle est centré à y = 0.

Voici notre méthode augmentée de drawRectangle(), définie sur MovieClip.prototype, ainsi elle est disponible à tous les exemples d'agrafe de film :

//incluez la bibliothèque de maths faite sur commande 
pour accéder à Math.degToRad(). # incluez "Math.as"
MovieClip.prototype.drawRectangle = fonction 
(largeur, taille, ronde, rotation, x, y) {// s'assurent que le 
rectangle est au moins aussi large et grand que les coins arrondis. 
si (largeur < (* 2)) {largeur = rond * 2 ronds ; } si 
(taille < (* 2)) {taille = rond * 2 ronds ; }
 //converti la rotation des degrés à la rotation 
de radians = Math.degToRad(rotation) ;
 //calculez la distance du centre du rectangle à un des 
coins (ou de// où le coin serait dans des rectangles 
arrondir-acculés). variété r = Math.sqrt(Math.pow(width/2, 2)
+ Math.pow(height/2, 2)) ;
 //calculez la distance du centre du rectangle au bord 
supérieur du// coin arrondi fond-droit. Quand/rond/est 0, le rx
est égal au rx de variété de R. = au Math.sqrt(Math.pow(width/2, 2)
+ Math.pow((height/2) - rond, 2)) ;
 //calculez la distance du centre du rectangle au bord 
inférieur du// coin arrondi fond-droit. Quand/rond/est 0, le 
relais est égal à la variété de R. relais = 
Math.sqrt(Math.pow((width/2) - rond, 2) + Math.pow(height/2, 2)) ;
 //calculez les angles que le r1Angle est l'angle entre 
l'axe de X que les courses par// centre du rectangle et de la ligne 
rx. r2Angle est l'angle entre le rx et/de r./r3Angle est l'angle 
entre r et relais. Et r4Angle est l'angle entre et de relais// 
axe de Y qui court à travers centre de rectangle variété r1Angle = 
Math.abronzage(((height/2) -) rond/(width/2)) ; variété 
r2Angle = Math.abronzage((height/2)/(width/2)) - r1Angle ; 
variété r4Angle = Math.abronzage(((width/2) -) 
rond/(height/2)) ; variété r3Angle = (Math.PI/2) - r1Angle - 
r2Angle - r4Angle ;
 //calculez la distance du point de commande du// de centre
d'arc pour le ctrlDist de variété de coins = le Math.sqrt(2 arrondis
* Math.pow(round, 2)) ;
 //déclarez les variables locales employées pour calculer
le ctrlX de variété de point de commande, ctrlY ;
 //calculez où commencer à dessiner le segment du premier
côté et puis le dessiner rotation + = r1Angle + r2Angle + r3Angle 
; variété x1 = x + relais * Math.cos(rotation) ; 
variété y1 = y + relais * Math.sin(rotation) ; 
this.moveTo(x1, y1) ; rotation + = 2 * r4Angle ; x1
= x + relais * Math.cos(rotation) ; y1 = y + relais * 
Math.sin(rotation) ; this.lineTo(x1, y1) ;
 //rotation réglée au point de départ pour le prochain 
segment latéral et calculez/de x/et la rotation de y + = r3Angle + 
r2Angle ; x1 = x + rx * Math.cos(rotation) ; y1 = y + rx 
* Math.sin(rotation) ;
 //si les coins sont arrondis, calculent le point de 
commande pour/de la courbe du coin/et le dessinent si (arrondissez > 
0) {ctrlX = x + r * Math.cos(rotation - r2Angle) ; ctrlY = y + 
r * Math.sin(rotation - r2Angle) ; this.curveTo(ctrlX, ctrlY, 
x1, y1) ; }
 //calculez le point final du segment de verso et 
tracez la ligne rotation + = 2 * r1Angle ; x1 = x + rx * 
Math.cos(rotation) ; y1 = y + rx * Math.sin(rotation) ; 
this.lineTo(x1, y1) ;
 //calculez la prochaine rotation de point de départ de 
ligne segment + = r2Angle + r3Angle ; x1 = x + relais * 
Math.cos(rotation) ; y1 = y + relais * Math.sin(rotation) ;
 //aspiration le coin arrondi, si c'est approprié. 
si (> 0) rond {ctrlX = x + r * Math.cos(rotation - r3Angle) ; 
ctrlY = y + r * Math.sin(rotation - r3Angle) ; 
this.curveTo(ctrlX, ctrlY, x1, y1) ; }
 //calculez le point final du troisième segment et
tracez la ligne rotation + = 2 * r4Angle ; x1 = x + relais * 
Math.cos(rotation) ; y1 = y + relais * Math.sin(rotation) ; 
this.lineTo(x1, y1) ;
 //calculez le point de départ de la prochaine rotation de
segment + = r3Angle + r2Angle ; x1 = x + rx * 
Math.cos(rotation) ; y1 = y + rx * Math.sin(rotation) ;
 //si c'est approprié, dessinent le coin arrondi. si
(> 0) rond {ctrlX = x + r * Math.cos(rotation - r2Angle) ; 
ctrlY = y + r * Math.sin(rotation - r2Angle) ; 
this.curveTo(ctrlX, ctrlY, x1, y1) ; }
 //calculez le point final pour le quatrième 
segment et dessinez-le rotation + = 2 * r1Angle ; x1 = x + rx * 
Math.cos(rotation) ; y1 = y + rx * Math.sin(rotation) ; 
this.lineTo(x1, y1) ;
 //calculez le point final pour le prochain arc faisant le 
coin et, si c'est approprié, dessinez-le rotation + = r3Angle + 
r2Angle ; x1 = x + relais * Math.cos(rotation) ; y1 = y +
relais * Math.sin(rotation) ; si (> 0) rond {ctrlX = x + r * 
Math.cos(rotation - r3Angle) ; ctrlY = y + r * 
Math.sin(rotation - r3Angle) ; this.curveTo(ctrlX, ctrlY, x1, 
y1) ; }}

L'exemple précédent sera plus clair avec un examen plus étroit.

Les méthodes trigonométriques d'ActionScript exigent des angles mesurés en radians. Par conséquent, toutes les fois que vous indiquez un angle dans les degrés (qui est généralement plus facile pour des humains), vous devez convertir les unités en radians avant de les passer aux méthodes trigonométriques d'ActionScript. Dans ce cas-ci, nous convertissons le paramètre de rotation des degrés en radians en utilisant la méthode de Math.degToRad().

rotation = Math.degToRad(rotation) ;

La longueur des trois lignes imaginaires utilisées pour dessiner les coins arrondis, sont calculées en utilisant le théorème pythagorien. Dans notre exemple, ces distances sont :

variété r = Math.sqrt(Math.pow(width/2, 2) + 
Math.pow(height/2, 2)) ; rx de variété = 
Math.sqrt(Math.pow(width/2, 2) + Math.pow((height/2) - rond, 2)) ; 
variété relais = Math.sqrt(Math.pow((width/2) - rond, 2) + 
Math.pow(height/2, 2)) ;

Après, nous devons calculer les angles formés entre les haches et les lignes r, le rx, et le relais. Ces angles sont employés pour déterminer y de x et des segments latéraux commençants et terminaux. Si vous savez les longueurs des côtés d'une bonne triangle, vous pouvez déterminer les angles qu'ils forment. Puisque les haches et les lignes r, le rx, et le relais peuvent être façonnés en de bonnes triangles vous pouvez déterminer les angles ces lignes forme en utilisant la tangente et l'arctangente. La tangente dans une bonne triangle est définie comme rapport du latéral vis-à-vis de l'angle avec le côté à côté de l'angle. L'arctangente est l'inverse de la fonction de tangente, ainsi nous employons le suivant pour déterminer les angles :

r1Angle de variété = Math.abronzage(((height/2) - 
round)/(width/2)) ; variété r2Angle = 
Math.abronzage((height/2)/(width/2)) - r1Angle ; variété 
r4Angle = Math.abronzage(((width/2) - round)/(height/2)) ; 
variété r3Angle = (Math.PI/2) - r1Angle - r2Angle - r4Angle
;

Les coins chacun se composent de courbe simple qui est un demi-cercle. Déterminer la distance entre le point central du demi-cercle et le point de commande dessinait cette courbe, emploient encore le théorème pythagorien :

ctrlDist de variété = Math.sqrt(2 * Math.pow(round, 2)) 
;

La première chose que vous voulez faire quand vous dessinez le rectangle doit déplacer le stylo imaginaire à un point de départ sur le rectangle sans tracer réellement une ligne. Dans cet exemple, le point de départ calculé est à la bonne fin du segment inférieur (de l'unrotated le rectangle). Si vous savez la distance entre deux points et l'angle (l'angle opposé a formé par une bonne triangle imaginaire avec la ligne connue étant la hypoténuse), vous pouvez calculer le x et y de la destination se dirigent en utilisant des fonctions trigonométriques. X est déterminé par les temps de distance le cosinus de l'angle. Y est déterminé par les temps de distance le sinus de l'angle. Dans cet exemple y de x et (x1 et y1) sont également compensés par les paramètres de x et de y pour dessiner un rectangle au dont le centre n'est pas (0, 0) :

rotation + = r1Angle + r2Angle + r3Angle ; 
variété x1 = x + relais * Math.cos(rotation) ; variété
y1 = y + relais * Math.sin(rotation) ; this.moveTo(x1, y1) ;

Le reste de l'exemple suit le même modèle : tracez une ligne, dessinez un coin arrondi (si c'est approprié), et puis déplacez-vous au prochain segment latéral. Les nouvelles coordonnées pour chaque segment sont calculées en utilisant le même processus comme décrit précédemment. Une fois que vous avez défini et avez inclus la méthode de drawRectangle() dans votre document instantané, vous pouvez rapidement dessiner un rectangle dans n'importe quel exemple d'agrafe de film. N'oubliez pas que vous devez toujours définir la ligne modèle avant que le flash dessine réellement n'importe quoi.

//créez une nouvelle agrafe de film dans laquelle pour 
dessiner le rectangle this.createEmptyMovieClip("rectangle_mc", 1) ;
//définissez un 1-pixel, le noir, le modèle en trait 
plein rectangle_mc.lineStyle(1, 0x000000, 100) ;
//aspiration un rectangle avec des dimensions de 100 x de 
200. Le rectangle a arrondi/de coins/avec des rayons de 10, et 
il est tourné 45 degrés dans le sens des aiguilles d'une montre de 
rectangle_mc.drawRectangle(100, 200, 10, 45) ;

Vous pouvez dessiner une place en employant la méthode de drawRectangle() avec des valeurs égales de taille et de largeur :

this.createEmptyMovieClip("square_mc", 1) ; 
square_mc.lineStyle(1, 0x000000, 100) ; 
square_mc.drawRectangle(100, 100) ;

Vous pouvez dessiner des rectangles remplis en appelant le beginFill() ou le beginGradientFill() avant drawRectangle() et en appelant l'endFill() après drawRectangle() :

this.createEmptyMovieClip("filledRectangle_mc", 1) ; 
filledRectangle_mc.lineStyle(1, 0x000000, 100) ; 
//définissez un noir, 1-pixel la frontière 
filledRectangle_mc.beginFill(0x0000FF) ; //définissez une 
suffisance bleue pleine filledRectangle_mc.drawRectangle(100, 200) ; 
filledRectangle_mc.endFill() ;
c'est un article supplémentaire par Elis Frugalo


Déni : Notre site Web n'est pas responsable de l'information contenue par cet article. Cet article reflète nullement les vues, les avis, les pensées ou la croyance du personnel d'annuaire d'articles.

Notification de traduction : L'article "comment dessiner un rectangle avec les coins arrondis" a été traduit en utilisant un service de traduction automatisé. Nous faisons des excuses sincèrement pour toutes les erreurs de traduction qui se sont produites. Merci de l'arrangement.


Online: 1643 users browsing the articles directory