<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 la couche alpha, qui est similaire aux couches rouge, verte et bleue.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 est zéro (transparent) ou un (opaque).Vous pouvez fusionner 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 sembler un peu mieux pendant son exécution car il utilise la minuterie 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, allouer avec la fonction J
transp = J( nr, nc, 0 );
// remplir les pixels avec la fonction mandelbrot.Utiliser l'attribution parallèle
// plutôt que des boucles imbriquées, pour la vitesse.
Affectation 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 de la matrice, les colonnes vers l'espace intéressant
2 * (r - nr2) / Sqrt( nr * nc ) ) / limite // 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
// canaliser.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 basses sont à l'extérieur.transp<.5
// est vrai, ou 1, extérieur et faux, ou 0, intérieur.cela fait un tableau rectangulaire de
// alphas qui sont 0 ou 1 : 1 est le masque et 0 est transparent.(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 ceci, et le png
// c'est-à-dire que save a de la transparence 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 meilleur pari 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 positionner ; ce "masque" n'est positionné qu'une seule fois, ici
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 ); // extra pour le défilement.faire des pixels arc-en-ciel...
Affectation parallèle(
{nr = N Lignes (arrière-plan), nc = N Cols (arrière-plan)},
fond[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
trame=0 ;
while( start < 30, // s'exécute pendant 30 secondes
poste = début ; // utilisé comme radian arg pour sin et cos...
début = début + 1/30 ;
x = 50 + 50 * Sin( position * .39 ); // mise à l'échelle arbitraire à l'aide
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 << fenêtre de mise à jour ; // 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, laissez-nous savoir ce qui se passe):
// définit la graphbox xscale et yscale pour correspondre à la taille du cadre
// si vous voulez travailler dans des pixels précis.
// expérimentez avec des valeurs alpha autour de 0,5 pour mélanger les images.
// organise les autres segments du graphe à dessiner avant le segment de masque ;
// un segment marqueur peut apparaître à travers le trou du masque.Jumelles de cinéma.
// déplace le masque au lieu 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.
