Um dos recursos mais divertidos da tela é a capacidade de usar imagens. Eles podem ser usados para fazer composição de fotos dinâmicos ou usados como cenários de gráficos etc. Atualmente, também é a única maneira de adicionar texto a eles (a especificação não contém nenhuma função para desenhar o texto). As imagens externas podem ser usadas em qualquer formato suportado por Gecko (por exemplo, formato PNG, GIF ou JPEG). Outros elementos de tela na mesma página também podem ser usados como fonte.
Um dos recursos interessantes da tela é que ela pode introduzir imagens, que podem ser usadas para síntese de imagem ou produção de fundo, etc. Atualmente, apenas o texto pode ser adicionado às imagens (a descrição padrão não inclui a função do texto de desenho). Enquanto as imagens suportadas por Gecko (como PNG, GIF, JPEG etc.) podem ser introduzidas na tela e outros elementos de lona também podem ser usados como fonte da imagem.
Importar imagens é basicamente um processo de duas etapas:
A introdução de uma imagem requer apenas duas etapas simples:
Vejamos a etapa um primeiro. Existem basicamente quatro opções disponíveis:
Vamos dar uma olhada no primeiro passo primeiro, há basicamente quatro opções:
Podemos acessar todas as imagens em uma página usando a coleção Document.Images, o método Document.getElementsByTagName, ou se soubermos o atributo ID da imagem, o método Document.getElementById.
Podemos obter a imagem na página (se o ID do elemento de imagem for conhecido) através da coleção Document.Images, o método Document.getElementsByTagName ou o método document.getElementById.
Assim como nas imagens normais, acessamos outros elementos de tela usando o método Document.getElementsByTagName ou o Document.getElementById. Certifique -se de que você desenhou algo para a tela de origem antes de usá -la em sua tela de destino.
Semelhante à imagem na página de referência, use o documento.getElementsByTagName ou Document.getElementById Métodos para obter outros elementos de tela. Mas o que você deve apresentar é a tela pronta.
Um dos usos mais práticos disso seria usar um segundo elemento de tela como uma visão de miniatura da outra tela maior.
Uma aplicação comum é fazer miniaturas para outra tela grande.
<Outra opção é criar novos objetos de imagem em nosso script. A principal falha dessa abordagem é que, se não queremos que nosso script pare no meio, porque ele precisa esperar que uma imagem seja carregada, precisamos de algum tipo de pré -carregamento da imagem.
Além disso, podemos usar scripts para criar um novo objeto de imagem, mas a principal desvantagem desse método é que, se não queremos que o script pause porque aguardamos o dispositivo de imagem, ainda precisamos interromper a pré -carga.
Basicamente, para criar um novo objeto de imagem, fazemos isso:
Podemos criar imagens da seguinte maneira:
var iMg = new Image (); // Crie nova imagem objectimg.src = 'myImage.png'; // Defina o caminho de origem
Quando esse script é executado, a imagem começa a carregar. Se o carregamento não for concluído quando uma declaração de drawimage for executada, o script é interrompido até que a imagem termine de carregar. Se você não quiser que isso aconteça, use um manipulador de eventos Onload:
Quando o script é executado, a imagem começa a carregar. Se a imagem não for carregada ao chamar o drawimage, o script aguardará até que seja carregado. Se você não quiser isso, pode usar o evento Onload:
var iMg = new Image (); // Crie nova imagem ObjectImg.onload = function () {// Execute as instruções DrawImage aqui} img.src = 'myImage.png'; // Defina o caminho de origemSe você estiver usando apenas uma imagem externa, isso pode ser uma boa abordagem, mas uma vez que você precisar rastrear mais de uma, precisamos recorrer a algo mais astuto. Está além do escopo deste tutorial para analisar as táticas de pré -carregamento da imagem, mas você pode conferir o pré -atendimento da imagem JavaScript para obter uma solução completa.
Se você usar apenas uma imagem, isso é suficiente. Mas uma vez mais de uma imagem é necessária, é necessário um método de processamento mais complexo, mas a estratégia de pré -carregamento da imagem está além do escopo deste tutorial. Se você estiver interessado, pode consultar o Preloader de imagem JavaScript.
Outra maneira possível de incluir imagens é através dos dados: URL. Os URLs de dados permitem definir completamente uma imagem como uma sequência de caracteres codificados BASE64 diretamente no seu código. Uma vantagem dos URLs de dados é que a imagem resultante está disponível imediatamente sem outra ida e volta ao servidor. (Outra vantagem é que é possível encapsular em um arquivo todo o seu CSS, JavaScript, HTML e imagens, tornando -o mais portátil para outros locais.) Algumas desvantagens desse método são que sua imagem não é armazenada em cache e, para imagens maiores, o URL codificado pode se tornar bastante longo:
Também podemos fazer referência a imagens através do método de dados: URL. Os URLs de dados permitem que uma imagem seja definida em uma sequência de strings codificadas por Base64. A vantagem é que o conteúdo da imagem está disponível imediatamente sem precisar contornar o servidor novamente. (E outra vantagem é que ele pode encapsular CSS, JavaScript, HTML e imagens juntos, o que é muito conveniente para migrar.) A desvantagem é que as imagens não podem ser armazenadas em cache. Se as imagens forem grandes, os dados de URL incorporados serão bastante longos:
var iMg_src = 'Dados: imagem/gif; base64, r0lgodlhcwalaiaaaaaaaaaa3pn/ziH5baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+;
Depois de ter uma referência ao nosso objeto de imagem de origem, podemos usar o método de drawimage para renderizá -lo à tela. Como veremos mais adiante, o método de drawimage está sobrecarregado e tem três variantes diferentes. Na sua forma mais básica, parece isso.
Depois que o objeto de gráfico de origem for obtido, podemos renderizá -lo em tela usando o método DrawImage. Existem três formas do método de drawimage, e o seguinte é o mais básico.
drawimage (imagem, x, y)onde a imagem é uma referência à nossa imagem ou objeto de tela. X e Y formam a coordenada na tela de destino onde nossa imagem deve ser colocada.
onde a imagem é um objeto de imagem ou tela e x e y são suas coordenadas iniciais na tela de destino.
No exemplo a seguir, usarei uma imagem externa como pano de fundo de um pequeno gráfico de linha. O uso de cenários pode tornar seu script consideravelmente menor, porque não precisamos desenhar um fundo elaborado. Estou usando apenas uma imagem aqui, então uso o manipulador de eventos Onload do objeto de imagem para executar as instruções de desenho. O método Drawimage coloca o pano de fundo na coordenada (0,0), que é o canto superior esquerdo da tela.
No exemplo a seguir, uso uma imagem externa como plano de fundo de uma imagem linear. Não precisamos desenhar um plano de fundo responsável com a imagem de fundo e economizar muito código. Apenas um objeto de imagem é usado aqui, portanto a ação de desenho é acionada em sua função de resposta a eventos OnLoad. O método Drawimage coloca a imagem de fundo no canto superior esquerdo (0,0) da tela.
functionDraw () {
função draw () {var ctx = document.getElementById ('canvas'). getContext ('2d'); var iMg = new Image (); 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'; }A segunda variante do método Drawimage adiciona dois novos parâmetros e nos permite colocar imagens em escala na tela.
Outra variante do método Drawimage é a adição de dois parâmetros para controlar a imagem para escalar em tela.
drawimage (imagem, x, y, largura, altura)Onde a largura e a altura são o tamanho da imagem na tela de destino.
Neste exemplo, vou usar uma imagem como papel de parede e repeti -la várias vezes na tela. Isso é feito simplesmente loop e colocando as imagens em escala em diferentes posições. No código abaixo, o primeiro para loops através das linhas, o segundo para loop das colunas. A imagem é escalada um terço do seu tamanho original, com 50x38 pixels. Veremos como isso também poderia ter sido alcançado, criando um padrão personalizado, posteriormente neste tutorial.
Neste exemplo, eu usaria uma imagem para espalhar em tela de maneira repetida como o plano de fundo. Também é muito simples de implementar, basta atravessar as imagens em zoom. Veja o código abaixo. A primeira camada do loop é repetir linhas, e a segunda camada é repetir as colunas. O tamanho da imagem é dimensionado para um terço do original, 50x38 px. Este método pode ser usado para alcançar bem o efeito dos padrões de fundo, como você verá no seguinte tutorial.
NOTA : As imagens podem ficar embaçadas ao escalar ou granuladas se forem reduzidas demais. A escala provavelmente não é feita se você tiver algum texto que precisa permanecer legível.Nota: A imagem pode ficar obscura ou borrada devido à escala em larga escala. Se a sua imagem tiver texto, é melhor não escalar, porque depois de processar isso, é muito provável que o texto na imagem se torne irreconhecível.
functionDraw () {
função draw () {var ctx = document.getElementById ('canvas'). getContext ('2d'); var iMg = new Image (); 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 = 'imagens/rhino.jpg'; }A terceira e última variante do método de drawimage possui oito novos parâmetros. Podemos usar esse método para cortar partes de uma imagem de origem e desenhá -las para a tela.
A terceira e última variante do método de drawimage possui 8 novos parâmetros para controlar a exibição de fatias.
drawimage (imagem, sx, sy, swidth, sheight, dx, dy, dwidth, dheight)A primeira imagem do parâmetro, assim como as outras variantes, é uma referência a um objeto de imagem ou a uma referência a um elemento de tela diferente. Para os outros oito parâmetros, é melhor olhar para a imagem à direita. Os quatro primeiros parâmetros definem a localização e o tamanho da fatia na imagem de origem. Os últimos quatro parâmetros definem a posição e o tamanho na tela de destino.
O primeiro parâmetro é o mesmo que os outros, ambos são referências a uma imagem ou outra tela. Os outros 8 parâmetros são melhor referidos ao diagrama à direita. Os 4 primeiros definem a posição da fatia e o tamanho da fonte da imagem, e os últimos 4 definem a posição de exibição de destino e o tamanho da fatia.
O corte pode ser uma ferramenta útil quando você deseja fazer composições. Você pode ter todos os elementos em um único arquivo de imagem e usar esse método para combinar um desenho completo. Por exemplo, se você deseja criar um gráfico, poderá ter uma imagem PNG contendo todo o texto necessário em um único arquivo e, dependendo dos seus dados, pode alterar a escala do seu gráfico sem muita dificuldade. Outra vantagem é que você não precisa carregar todas as imagens individualmente.
O corte é uma ferramenta poderosa para a síntese de imagem. Suponha que haja uma imagem contendo todos os elementos, você pode usar esse método para sintetizar uma imagem completa. Por exemplo, se você deseja desenhar um gráfico e ter um arquivo PNG com todo o texto necessário em sua mão, poderá alterar facilmente o gráfico final exibido de acordo com as necessidades reais de dados. Outro benefício desse método é que você não precisa carregar cada imagem separadamente.
Neste exemplo, vou usar o mesmo rinoceronte como vimos acima, mas agora vou cortar a cabeça para fora e compunhá -lo em uma moldura. A imagem do quadro de imagem inclui um dropshadow que foi salvo como uma imagem PNG de 24 bits. Como as imagens PNG de 24 bits incluem um canal alfa completo de 8 bits, diferentemente das imagens GIF e PNG de 8 bits, posso colocá-lo em qualquer plano de fundo e não preciso me preocupar com uma cor fosca.
Neste exemplo, usei a imagem do rinoceronte que eu havia usado acima, mas desta vez eu fazia uma fatia close-up da cabeça do rinoceronte e a sintetizava em uma estrutura fotográfica. O quadro tem um efeito de sombra e é uma imagem salva em formato PNG de 24 bits. Como a imagem PNG de 24 bits vem com um canal alfa completo de 8 bits, diferentemente do GIF e do PNG de 8 bits, posso colocá-lo como um fundo sem me preocupar com a cor subjacente.
Eu adotei uma abordagem diferente para o carregamento das imagens do que o exemplo acima. Acabei de colocar as imagens diretamente no meu documento HTML e usei uma regra CSS para escondê -las da visualização (exibição: nenhuma). Designei as duas imagens um atributo de identificação para facilitar a seleção. O script em si é muito simples. Primeiro desenho a imagem fatiada e dimensionada na tela (Primeira declaração de drawimage) e depois coloco o quadro na parte superior (segunda declaração de drawimage).
Carrego a imagem de uma maneira diferente da que usei acima, insiro a imagem diretamente no HTML e depois a oculto através do CSS (exibição: Nenhum). Atribuí IDs para ambas as imagens, que são convenientes para uso posterior. Olhando para o script abaixo, é bastante simples. Primeiro, corte a cabeça do rinoceronte (a primeira drawimage) e coloque -a na tela e, em seguida, coloque uma moldura fotográfica (o segundo drawimage).
função draw () {var canvas = document.getElementById ('canvas'); var ctx = Canvas.getContext ('2D'); // desenhe slice ctx.drawimage (document.getElementById ('fonte'), 33,71,104,124,21,20,87,104); // Desenhe o quadro ctx.drawimage (document.getElementById ('frame'), 0,0);}No exemplo final deste capítulo, fiz uma pequena galeria de arte. A galeria consiste em uma tabela contendo várias imagens. Quando a página é carregada, para cada imagem na página, um elemento de tela é inserido e um quadro é desenhado em torno dela.
No meu caso, todas as imagens têm uma largura e altura fixa, assim como o quadro que é desenhado em torno dela. Você pode aprimorar o script para que ele use a largura e a altura da imagem para fazer com que a estrutura se encaixe perfeitamente em torno dele.
O código abaixo deve ser auto-explicativo. Voltamos através da matriz de imagens e adicionamos novos elementos de tela de acordo. Provavelmente, a única coisa a observar, para aqueles que não estão tão familiarizados com o DOM, é o uso do método de inserção antes. Inserir antes é um método do nó pai (uma célula de tabela) do elemento (a imagem) antes do qual queremos inserir nosso novo nó (o elemento de tela).