<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />El JSL a continuación crea dos mapas de bits: un fondo con los colores del arco iris y una máscara con forma de Mandelbrot.Los dos mapas de bits se agregan a un gráfico y el arco iris se mueve debajo de la máscara.Es muy rápido porque los mapas de bits solo se crean una vez y el sistema operativo admite el orificio transparente de la máscara.
El agujero transparente en la máscara se crea con la capa alfa, que es similar a las capas roja, verde y azul.Alfa es un número entre cero y uno que determina qué tan transparente/opaco es un píxel cuando se representa sobre un píxel dibujado previamente.En este ejemplo, alfa es cero (transparente) o uno (opaco).Puede combinar mapas de bits con valores intermedios.
Esta versión en línea de JSL se modificó para hacer los mapas de bits para el video.El archivo adjunto puede verse un poco mejor mientras se ejecuta porque usa el temporizador para determinar qué cuadro mostrar a continuación.
Craige Hales - YouTube
https://www.youtube.com/watch?v=NA-O0YbehpQ
// este ejemplo demuestra una forma de hacer una imagen con un agujero.
// La mayoría de las imágenes solo usan rojo, verde y azul (como el arcoíris de fondo
// imagen de abajo).Algunas imágenes agregan Alpha como un cuarto canal que describe
// opacidad o transparencia.JMP usa 1 para opaco.
//
escala = 35; // tamaño global
nr = 20 * escala; // relación de aspecto
nc = 25 * escala; // relación de aspecto
// los píxeles se construyen inicialmente en una matriz, se asignan con la función J
transp = J( nr, nc, 0 );
// rellena los píxeles con la función mandelbrot.Usar asignación paralela
// en lugar de bucles anidados, por velocidad.
Asignación en paralelo (
{nr = N filas (transp), nr2 = N filas (transp) / 2,
nc = N columnas (transp), nc3 = N columnas (transp) / 1,3333, límite = 1000},
transp[r, c] = Mandelbrot( limit, 4, // devuelve respuestas enteras de 1..limit
2 * (c - nc3) / Sqrt (nr * nc), // filas de matriz de escala, cols a espacio interesante
2 * (r - nr2) / Sqrt( nr * nc ) ) / límite // dividir por límite escalas 0..1
);
// la siguiente línea es la importante.esta imagen se crea con 4 canales de datos,
// Rojo, Verde, Azul y Alfa.Debido a que se usa el mismo valor "transp" para r,g,b, el
// la imagen está en escala de grises, pero debido a los datos de Mandelbrot() no verá mucho
// gris en la mascara...solo negro.cambia la segunda transp a 1 transp y verás
// una máscara verde.Pero el parámetro importante es transp<.5 que crea el alfa
// canal.transp es una matriz rectangular de valores entre 0 y 1; valores altos
// son el área plana dentro del conjunto de mandelbrot, los valores bajos están fuera.transp<.5
// es verdadero, o 1, fuera y falso, o 0, dentro.esto hace una matriz rectangular de
// alfas que son 0 o 1: 1 es la máscara y 0 es transparente.(alfa puede ser fraccionario
// y eso combinará los mapas de bits.No usar eso aquí.)
transpImage = Nueva Imagen( "rgba", {transp, transp, transp, transp < .5} );
// este ejemplo no usa la imagen guardada, pero puede, así, y el png
// eso es save tiene transparencia si lo abres con Gimp, por ejemplo.
// prueba: transpimage << saveimage( "\\VBOXSVR\windowsShare\transparent\test.png", "png" );
// crea una ventana para contener la animación y un gráfico para contener los mapas de bits.
// su mejor apuesta para hacer que los mapas de bits transparentes se muestren en JMP está en un gráfico
// porque otros cuadros de visualización con mapas de bits realmente no quieren superponerse entre sí.
Nueva ventana ("transparencia",
gb = Graph Box (tamaño de fotograma (nc + 20, nr + 20), // borde de arco iris de 10 píxeles alrededor
<
// inserta la primera imagen en el marco y obtiene un identificador para el segmento de la imagen
gb[framebox( 1 )] << addimage( image(transpimage ) );
transpSeg = gb[framebox( 1 )] << childseg;
// posicionarlo; esta "máscara" solo se coloca una vez, justo aquí
transpSeg << mover( 50, 50 );
//
//
// crea una segunda imagen de arcoíris sin ninguna transparencia
fondo = J( nr * 2, nc * 2, 0 ); // adicional por desplazamiento.Haz algunos píxeles de arcoíris...
Asignación en paralelo (
{nr = N filas (fondo), nc = N columnas (fondo)},
fondo[r, c] = Color RGB( (Sin( r / 70 ) + 1) / 2, (Sin( c / 50 ) + 1) / 2, Sin( (r + c) / 60 ) )
);
// convertir los píxeles en una imagen de mapa de bits, agregar al marco, obtener un identificador
backgroundImage = Nueva imagen (fondo);
gb[cuadro de cuadro (1)] << addimage (imagen (imagen de fondo));
backgroundSeg = gb[framebox( 1 )] << childseg;
//
wait(.1); // asegúrese de que la ventana se abra antes de que comience el bucle
//
inicio = 0; // usa el tiempo para crear una animación más fluida
cuadro=0;
while( start < 30, // corre por 30 segundos
posición = inicio; // usado como argumento en radianes para sen y cos...
inicio = inicio + 1/30;
x = 50 + 50 * Sin (posición * .39); // escalado arbitrario usando
y = 50 + 50 * Cos( posición * .27 ); // licencia artistica
// OK, esto es torpe; parece que el método de movimiento necesita ayuda para evaluar...
// EvalExpr mira su argumento y busca Expr para evaluar.
// EvalExpr devuelve una expresión que aún necesita ser evaluada
Eval( Eval Expr( backgroundseg << move( Expr( x ), Expr( y ) ) ) );
// gb<
gb << ventana de actualización; // esta es una animación muy fluida, pero no interactiva
//hacer imagen: gb << savepicture("\\VBOXSVR\windowsShare\transparent\v\v"||right(char(frame++,9),9,"0")||".png", "png" );
);
//
// más ideas (no probadas, háganos saber qué sucede):
// configura el cuadro gráfico xscale y yscale para que coincida con el tamaño del marco
// si desea trabajar en píxeles precisos.
// experimente con valores alfa alrededor de .5 para mezclar imágenes.
// organiza otros segmentos en el gráfico para que se dibujen antes del segmento de la máscara;
// un segmento de marcador puede aparecer a través del agujero en la máscara.Prismáticos de película.
// mueve la máscara en lugar de los datos.
// múltiples capas con transparencia.Desplazadores laterales usando la idea de paralaje.
// usa MouseTrap para arrastrar una máscara.
// intente rotar una máscara, tal vez también con MouseTrap, dependiendo de qué tan lejos haga clic
// es desde el centro de la máscara.
