Comment dessiner un rectangle avec les coins
arrondis
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.