Una de las características más divertidas del lienzo es la capacidad de usar imágenes. Estos se pueden usar para hacer compuestas de fotos dinámicas o usarse como fondos de gráficos, etc. Actualmente también es la única forma de agregarles texto (la especificación no contiene ninguna función para dibujar texto). Las imágenes externas se pueden usar en cualquier formato admitido por GeckO (por ejemplo, formato PNG, GIF o JPEG). Otros elementos de lienzo en la misma página también se pueden usar como fuente.
Una de las características interesantes del lienzo es que puede introducir imágenes, que se pueden usar para la síntesis de imágenes o la producción de fondo, etc. Actualmente, solo se puede agregar texto a las imágenes (la descripción estándar no incluye la función del texto de dibujo). Siempre que las imágenes compatibles con gecko (como PNG, GIF, JPEG, etc.) puedan introducirse en lienzo, y otros elementos de lienzo también pueden usarse como fuente de la imagen.
Importar imágenes es básicamente un proceso de dos pasos:
La introducción de una imagen requiere solo dos pasos simples:
Veamos el paso uno primero. Básicamente hay cuatro opciones disponibles:
Primero echemos un vistazo al primer paso, básicamente hay cuatro opciones:
Podemos acceder a todas las imágenes en una página utilizando la colección Docum.Images, el método Document.getElementsByTagName, o si conocemos el atributo de identificación de la imagen, el método de document.getElementById.
Podemos obtener la imagen en la página (si se conoce la ID del elemento de imagen) a través de la colección de Document.Images, el método Document.getElementsByTagName o el método Document.getElementById.
Al igual que con las imágenes normales, accedemos a otros elementos de lona utilizando el método Document.getElementsByTagName o el método Document.getElementById. Asegúrese de haber dibujado algo para el lienzo de origen antes de usarlo en su lienzo de destino.
Similar a la imagen en la página de referencia, use el document.getElementsBytagName o el documento. GetElementById Methods para obtener otros elementos de lona. Pero lo que debe presentar es el lienzo listo.
Uno de los usos más prácticos de esto sería usar un segundo elemento de lienzo como vista en miniatura del otro lienzo más grande.
Una aplicación común es hacer miniaturas para otro lienzo grande.
<Otra opción es crear nuevos objetos de imagen en nuestro script. La principal falla de este enfoque es que si no queremos que nuestro script se detenga en el medio porque necesita esperar a que se cargue una imagen, necesitamos alguna forma de precarga de imagen.
Además, podemos usar scripts para crear un nuevo objeto de imagen, pero la principal desventaja de este método es que si no queremos que el script haga una pausa porque esperamos el dispositivo de imagen, aún necesitamos romper la precarga.
Básicamente para crear un nuevo objeto de imagen, hacemos esto:
Podemos crear imágenes de la siguiente manera simple:
var img = nueva imagen (); // Crear nueva imagen Objectimg.src = 'myImage.png'; // Establecer ruta de origen
Cuando se ejecuta este script, la imagen comienza a cargarse. Si la carga no está terminada cuando se ejecuta una declaración de DrawImage, el script se detiene hasta que la imagen esté terminada de cargar. Si no desea que esto suceda, use un controlador de eventos de Onload:
Cuando se ejecuta el script, la imagen comienza a cargarse. Si la imagen no se carga al llamar a DrawImage, el script esperará hasta que se cargue. Si no quiere esto, puede usar el evento de Onload:
var img = nueva imagen (); // Crear nueva imagen Objectimg.Onload = function () {// Ejecutar las declaraciones de DrawImage aquí} img.src = 'myImage.png'; // Establecer ruta de origenSi solo está usando una imagen externa, este puede ser un buen enfoque, pero una vez que necesite rastrear más de uno, necesitamos recurrir a algo más astuto. Está más allá del alcance de este tutorial observar las tácticas de precarga de imágenes, pero puede consultar JavaScript Image Preloader para una solución completa.
Si solo usa una imagen, eso es suficiente. Pero una vez que se necesita más de una imagen, se requiere un método de procesamiento más complejo, pero la estrategia de precarga de imagen está más allá del alcance de este tutorial. Si está interesado, puede referirse al pregolador de imágenes JavaScript.
Otra posible forma de incluir imágenes es a través de los datos: URL. Las URL de datos le permiten definir completamente una imagen como una cadena de caracteres codificada Base64 directamente en su código. Una ventaja de las URL de datos es que la imagen resultante está disponible inmediatamente sin otro viaje de ida y vuelta al servidor. (Otra ventaja es que es posible encapsular en un archivo todos sus CSS, JavaScript, HTML e imágenes, lo que hace que sea más portátil a otras ubicaciones). Algunas desventajas de este método son que su imagen no está en caché, y para imágenes más grandes la URL codificada puede ser bastante larga:
También podemos hacer referencia a imágenes a través del método DATA: URL. Las URL de datos permiten definir una imagen en una cadena de cadenas codificadas Base64. La ventaja es que el contenido de la imagen está disponible inmediatamente sin tener que volver al servidor nuevamente. (Y otra ventaja es que puede encapsular CSS, JavaScript, HTML e imágenes juntos, lo cual es muy conveniente para migrar). La desventaja es que las imágenes no se pueden almacenar en caché. Si las imágenes son grandes, los datos de URL integrados serán bastante largos:
var img_src = 'data: image/gif; base64, r0lgodlhcwalaiaaaaaaaaaaa3pn/zih5baeaaaaaaalaaaaaaaaaaaaaaaaaaaaiuha+hkcuo4lmnvinda7qyrixigbyaw ==';
Una vez que tenemos una referencia a nuestro objeto de imagen fuente, podemos usar el método Drawimage para renderizarlo en el lienzo. Como veremos más adelante, el método DrawImage está sobrecargado y tiene tres variantes diferentes. En su forma más básica se ve así.
Una vez que se obtiene el objeto gráfico de origen, podemos convertirlo en lienzo utilizando el método Drawimage. Hay tres formas del método DrawImage, y la siguiente es la más básica.
Drawimage (Imagen, X, Y)donde la imagen es una referencia a nuestro objeto de imagen o lienzo. X e Y forman la coordenada en el lienzo objetivo donde se debe colocar nuestra imagen.
donde la imagen es un objeto de imagen o lienzo, y X e Y son sus coordenadas iniciales en el lienzo objetivo.
En el siguiente ejemplo, usaré una imagen externa como telón de fondo de un gráfico de línea pequeña. El uso de fondos puede hacer que su guión sea considerablemente más pequeño porque no necesitamos dibujar un fondo elaborado. Solo estoy usando una imagen aquí, así que uso el controlador de eventos Onload del objeto de imagen para ejecutar las declaraciones de dibujo. El método DrawImage coloca el telón de fondo en la coordenada (0,0), que es la esquina superior izquierda del lienzo.
En el siguiente ejemplo, uso una imagen externa como fondo de una imagen lineal. No necesitamos dibujar un fondo responsable con la imagen de fondo y guardar mucho código. Solo se usa un objeto de imagen aquí, por lo que la acción de dibujo se activa en su función de respuesta al evento de encendido. El método Drawimage coloca la imagen de fondo en la esquina superior izquierda (0,0) del lienzo.
functionDraw () {
function draw () {var ctx = document.getElementById ('Canvas'). getContext ('2d'); var img = nueva imagen (); img.onload = function () {ctx.drawimage (img, 0,0); ctx.beginpath (); CTX.moveto (30,96); CTX.Lineto (70,66); CTX.Lineto (103,76); CTX.Lineto (170,15); ctx.stroke (); } img.src = 'Images/backdrop.png'; }La segunda variante del método DrawImage agrega dos nuevos parámetros y nos permite colocar imágenes a escala en el lienzo.
Otra variante del método DrawImage es la adición de dos parámetros para controlar la imagen a escala en lienzo.
Drawimage (imagen, x, y, ancho, altura)donde el ancho y la altura son el tamaño de la imagen en el lienzo objetivo.
En este ejemplo, voy a usar una imagen como fondo de pantalla y la repetiré varias veces en el lienzo. Esto se hace simplemente en bucle y colocando las imágenes escaladas en diferentes posiciones. En el código debajo del primero para los bucles a través de las filas, la segunda para el bucle las columnas. La imagen se escala un tercio de su tamaño original, que es de 50x38 píxeles. Veremos cómo esto también podría haberse logrado, creando un patrón personalizado, más adelante en este tutorial.
En este ejemplo, usaría una imagen para extenderse en lienzo de manera repetida como el fondo. También es muy simple de implementar, simplemente pase a través de las imágenes zoom. Vea el código a continuación. La primera capa de For Loop es repetir filas, y la segunda capa es repetir columnas. El tamaño de la imagen se escala a un tercio del original, 50x38 PX. Este método se puede utilizar para lograr bien el efecto de los patrones de fondo, como verá en el siguiente tutorial.
NOTA : Las imágenes pueden volverse borrosas al escalar o ser granuladas si se reducen demasiado. El escalado probablemente no se realice si tiene algún texto que debe permanecer legible.Nota: La imagen puede volverse oscura o borrosa debido a la escala a gran escala. Si su imagen tiene texto, es mejor no escalar, porque después de procesar eso, es muy probable que el texto en la imagen sea irreconocible.
functionDraw () {
function draw () {var ctx = document.getElementById ('Canvas'). getContext ('2d'); var img = nueva imagen (); img.onload = function () {for (i = 0; i <4; i ++) {for (j = 0; j <3; j ++) {ctx.drawimage (img, j*50, i*38,50,38); }}} img.src = 'Images/rhino.jpg'; }La tercera y última variante del método DrawImage tiene ocho nuevos parámetros. Podemos usar este método para cortar partes de una imagen de origen y dibujarlas al lienzo.
La tercera y última variante del método DrawImage tiene 8 nuevos parámetros para controlar la visualización de cortes.
Drawimage (Image, SX, Sy, Swidth, Sheight, DX, DY, Dwidth, Dheight)La primera imagen de parámetro, al igual que con las otras variantes, es una referencia a un objeto de imagen o una referencia a un elemento de lona diferente. Para los otros ocho parámetros es mejor mirar la imagen a la derecha. Los primeros cuatro parámetros definen la ubicación y el tamaño de la porción en la imagen de origen. Los últimos cuatro parámetros definen la posición y el tamaño en el lienzo de destino.
El primer parámetro es el mismo que los demás, ambos son referencias a una imagen u otro lienzo. Los otros 8 parámetros se refieren mejor al diagrama de la derecha. Los primeros 4 definen la posición y el tamaño del corte de la fuente de imagen, y los últimos 4 definen la posición y el tamaño de la pantalla objetivo de la porción.
El corte puede ser una herramienta útil cuando desea hacer composiciones. Puede tener todos los elementos en un solo archivo de imagen y usar este método para combinar un dibujo completo. Por ejemplo, si desea hacer un gráfico, podría tener una imagen PNG que contenga todo el texto necesario en un solo archivo y, dependiendo de sus datos, podría cambiar la escala de su gráfico sin mucha dificultad. Otra ventaja es que no necesita cargar cada imagen individualmente.
El corte es una herramienta poderosa para la síntesis de imágenes. Supongamos que hay una imagen que contiene todos los elementos, entonces puede usar este método para sintetizar una imagen completa. Por ejemplo, si desea dibujar un gráfico y tener un archivo PNG con todo el texto necesario en su mano, puede cambiar fácilmente el cuadro final mostrado de acuerdo con las necesidades de datos reales. Otro beneficio de este método es que no necesita cargar cada imagen por separado.
En este ejemplo, voy a usar el mismo rinoceronte que hemos visto arriba, pero ahora voy a cortar la cabeza y compilarla en un marco de imagen. La imagen del marco de la imagen incluye una dropshadow que se ha guardado como una imagen PNG de 24 bits. Debido a que las imágenes PNG de 24 bits incluyen un canal alfa completo de 8 bits, a diferencia de las imágenes GIF y PNG de 8 bits, puedo colocarlo en ningún fondo y no tengo que preocuparme por un color mate.
En este ejemplo, utilicé la imagen de rinocerontes que había usado arriba, pero esta vez haría un primer plano de la cabeza de rinoceronte y luego la sintetizaría en un marco de fotos. El marco tiene un efecto de sombra y es una imagen guardada en formato PNG de 24 bits. Debido a que la imagen PNG de 24 bits viene con un canal alfa completo de 8 bits, a diferencia de GIF y PNG de 8 bits, puedo ponerla como un fondo sin preocuparme por el color subyacente.
Tomé un enfoque diferente a la carga de las imágenes que el ejemplo anterior. Acabo de colocar las imágenes directamente en mi documento HTML y usé una regla CSS para ocultarlas de la vista (Pantalla: Ninguno). Asigné ambas imágenes un atributo de identificación para que sean más fáciles de seleccionar. El script en sí es muy simple. Primero dibujé la imagen en rodajas y escalada en el lienzo (Declaración de primera DrawImage), y luego coloco el marco en la parte superior (Declaración de segunda DrawImage).
Cargo la imagen de una manera diferente a la que usé arriba, inserte la imagen directamente en el HTML y luego la oculto a través de CSS (pantalla: Ninguno). Asigné IDS para ambas imágenes, que son convenientes para su uso posterior. Mirando el guión a continuación, es bastante simple. Primero, corte la cabeza de rinocerontes (la primera DrawImage) y póngala en el lienzo, y luego póngala un marco de fotos (la segunda DrawImage).
function draw () {var canvas = document.getElementById ('Canvas'); var ctx = canvas.getContext ('2d'); // Dibuja Slice Ctx.DrawImage (document.getElementById ('fuente'), 33,71,104,124,21,20,87,104); // dibujar marco ctx.drawimage (document.getElementById ('frame'), 0,0);}En el ejemplo final de este capítulo, he hecho una pequeña galería de arte. La galería consiste en una tabla que contiene varias imágenes. Cuando se carga la página, para cada imagen en la página se inserta un elemento de lona y se dibuja un marco a su alrededor.
En mi caso, todas las imágenes tienen un ancho y altura fijos, y también lo hace el marco que se dibuja a su alrededor. Puede mejorar el script para que use el ancho y la altura de la imagen para que el marco se ajuste perfectamente a su alrededor.
El siguiente código debe explicarse por sí mismo. Realizamos la matriz de imágenes y agregamos nuevos elementos de lienzo en consecuencia. Probablemente lo único a tener en cuenta, para aquellos que no están tan familiarizados con el DOM, es el uso del método InsertBefore. Insertbefore es un método del nodo principal (una celda de tabla) del elemento (la imagen) antes del cual queremos insertar nuestro nuevo nodo (el elemento Canvas).