<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />Le JSL ci-dessous crée deux bitmaps : un arrière-plan de couleur arc-en-ciel et un masque en forme de Mandelbrot.Les deux bitmaps sont ajoutés à un graphique et l'arc-en-ciel est déplacé sous le masque.C'est très rapide car les bitmaps ne sont créés qu'une seule fois et le système d'exploitation prend en charge le trou transparent du masque.
Le trou transparent dans le masque est créé avec le calque alpha, qui est similaire aux calques rouge, vert et bleu.Alpha est un nombre compris entre zéro et un qui détermine le degré de transparence/opacité d'un pixel lorsqu'il est rendu au-dessus d'un pixel précédemment dessiné.Dans cet exemple, alpha vaut zéro (transparent) ou un (opaque).Vous pouvez mélanger des bitmaps avec des valeurs intermédiaires.
Cette version en ligne du JSL a été modifiée pour créer les bitmaps de la vidéo.Le fichier joint peut paraître un peu meilleur lors de son exécution, car il utilise le minuteur pour déterminer quelle image afficher ensuite.
Craige Hales - YouTube
https://www.youtube.com/watch?v=NA-O0YbehpQ
// cet exemple montre une façon de créer une image avec un trou.
// La plupart des images utilisent simplement le rouge, le vert et le bleu (comme l'arc-en-ciel d'arrière-plan
//image ci-dessous).Certaines images ajoutent Alpha comme quatrième canal décrivant
// opacité ou transparence.JMP utilise 1 pour opaque.
//
échelle = 35 ; // taille globale
nr = 20 * échelle ; // ratio d'aspect
nc = 25 * échelle ; // ratio d'aspect
// les pixels sont initialement construits dans une matrice, alloués avec la fonction J
transp = J(nr, nc, 0 );
// remplit les pixels avec la fonction mandelbrot.Utiliser l'affectation parallèle
// plutôt que des boucles imbriquées, pour plus de vitesse.
Attribution parallèle (
{nr = N lignes (transp), nr2 = N lignes (transp) / 2,
nc = N Cols( transp ), nc3 = N Cols( transp ) / 1,3333, limite = 1000},
transp[r, c] = Mandelbrot( limit, 4, // renvoie des réponses entières de 1..limit
2 * (c - nc3) / Sqrt( nr * nc ), // mettre à l'échelle les lignes et les colonnes de la matrice dans un espace intéressant
2 * (r - nr2) / Sqrt( nr * nc ) ) / limit // diviser par les échelles limites 0..1
);
// la ligne suivante est la plus importante.cette image est créée avec 4 canaux de données,
// Rouge, Vert, Bleu et Alpha.Parce que la même valeur "transp" est utilisée pour r, g, b, le
// l'image est en échelle de gris, mais à cause des données de Mandelbrot(), vous ne verrez pas grand-chose
// gris dans le masque... seulement noir.changez le 2ème transp en 1-transp et vous verrez
// un masque vert.Mais le paramètre important est transp<.5 qui crée l'alpha
// canal.transp est une matrice rectangulaire de valeurs comprises entre 0 et 1 ; valeurs élevées
// sont la zone plate à l'intérieur de l'ensemble de Mandelbrot, les valeurs faibles sont à l'extérieur.transp < 0,5
// est vrai, ou 1, à l'extérieur et faux, ou 0, à l'intérieur.cela fait un tableau rectangulaire de
// alphas qui valent 0 ou 1 : 1 est le masque et 0 est transparent.(l'alpha peut être fractionnaire
// et cela mélangera les bitmaps.Je ne l'utilise pas ici.)
transpImage = Nouvelle Image( "rgba", {transp, transp, transp, transp < .5} );
// cet exemple n'utilise pas l'image enregistrée, mais vous pouvez, comme ça, et le png
// c'est-à-dire que la sauvegarde est transparente si vous l'ouvrez avec Gimp, par exemple.
// test : transpimage << saveimage( "\\VBOXSVR\windowsShare\transparent\test.png", "png" );
// crée une fenêtre pour contenir l'animation et une graphbox pour contenir les bitmaps.
// votre meilleure option pour faire apparaître des bitmaps transparents dans JMP est dans un graphique
// parce que les autres boîtes d'affichage avec des bitmaps ne veulent pas vraiment se chevaucher.
Nouvelle fenêtre( "transparence",
gb = Graph Box (framesize (nc + 20, nr + 20), // bordure arc-en-ciel de 10 pixels tout autour
<
// insère la première image dans le cadre et obtient un handle vers le segment d'image
gb[framebox( 1 )] << addimage( image( transpimage ) );
transpSeg = gb[framebox( 1 )] << childseg;
// le positionne ; ce "masque" n'est positionné qu'une seule fois, ici même
transpSeg << déplacer( 50, 50 );
//
//
// crée une deuxième image arc-en-ciel sans aucune transparence
arrière-plan = J( nr * 2, nc * 2, 0 ); // supplémentaire pour le défilement.faites des pixels arc-en-ciel...
Attribution parallèle (
{nr = N Lignes (arrière-plan), nc = N Cols (arrière-plan)},
background[r, c] = Couleur RVB ((Sin( r / 70 ) + 1) / 2, (Sin( c / 50 ) + 1) / 2, Sin( (r + c) / 60 ) )
);
// transforme les pixels en une image bitmap, ajoute au cadre, obtient une poignée
backgroundImage = Nouvelle image (arrière-plan) ;
gb[framebox( 1 )] << addimage( image( backgroundImage ) );
backgroundSeg = gb[framebox( 1 )] << childseg;
//
wait(.1);// assurez-vous que la fenêtre s'ouvre avant le début de la boucle
//
début = 0 ; // utilise le temps pour créer une animation plus fluide
cadre=0 ;
while( start < 30, // exécute pendant 30 secondes
position = début ; // utilisé comme argument radian pour sin et cos...
début = début + 1/30 ;
x = 50 + 50 * Péché( position * .39 ); // mise à l'échelle arbitraire en utilisant
y = 50 + 50 * Cos( position * .27 ); // licence artistique
// OK, c'est maladroit ; il semble que la méthode de déplacement ait besoin d'aide pour évaluer...
// EvalExpr examine son argument et recherche Expr à évaluer.
// EvalExpr renvoie une expression qui doit encore être évaluée
Eval( Eval Expr( backgroundseg << move( Expr( x ), Expr( y ) ) ) );
// gb<
gb << updatewindow; // c'est une animation très fluide, mais pas interactive
//créer une image : gb << savepicture("\\VBOXSVR\windowsShare\transparent\v\v"||right(char(frame++,9),9,"0")||".png", "png" );
);
//
// plus d'idées (non testées, faites-nous savoir ce qui se passe) :
// définit les graphbox xscale et yscale pour qu'ils correspondent à la taille du cadre
// si vous souhaitez travailler en pixels précis.
// expérimentez avec des valeurs alpha autour de 0,5 pour mélanger les images.
// arrange les autres segments du graphique pour qu'ils soient dessinés avant le segment de masque ;
// un segment de marqueur peut apparaître à travers le trou du masque.Jumelles de cinéma.
// déplace le masque à la place des données.
// plusieurs calques avec transparence.Défilements latéraux utilisant l'idée de parallaxe.
// utilise MouseTrap pour faire glisser un masque.
// essayez de faire pivoter un masque, peut-être aussi avec le MouseTrap, selon la distance du clic
// vient du centre du masque.
