Si desea agregar una marca de agua a una foto sin molestarse con los editores de imágenes o agregarla mientras carga fotos en el servidor, entonces esta lección es para usted.
En este tutorial, le mostraré cómo agregar una marca de agua a una imagen sobre la marcha sin cambiar realmente la imagen original. En primer lugar, necesitará una imagen que utilizará como marca de agua.
Luego formamos el encabezado del archivo:
// esta línea le dirá al navegador que estamos pasando un encabezado de imagen jpg ("content-type: image/jpeg");
Luego formamos imagen png y obtener sus dimensiones:
// crear una marca de agua png $watermark = imagecreatefrompng("watermark.png"); // obtener ancho y alto $watermark_width = imagesx($watermark); $marca de agua_altura = imágenesy($marca de agua);
Haremos lo mismo con la imagen original, pero solo en formato jpg. Esto es común para las fotos que se cargan a través de un formulario. Actuamos de la siguiente manera:
// creación de jpg imágenes $image_path = "original.jpg"; $imagen = imagecreatefromjpeg($image_path); // obtener la dimensión de la imagen $tamaño = getimagesize($image_path);
Ahora necesitamos colocar una marca de agua en la imagen:
// pongo la marca de agua abajo a la derecha. relleno de 5px $dest_x = $tamaño - $watermark_width - 5; $dest_y = $tamaño - $watermark_height - 5;
Luego configuraremos las opciones de fusión para ambas imágenes:
imagealphablending($imagen, verdadero); imagealphablending($marca de agua, verdadero);
Al final, creamos una nueva imagen usando los parámetros:
// crea una nueva imagen imagecopy($image, $watermark, $dest_x, $dest_y, 0, 0, $watermark_width, $watermark_height); imagenjpeg($imagen);
Es importante llevar:
// memoria libre imagedestroy($imagen); imagedestroy($marca de agua);
Puede usar Photoshop para ajustar la transparencia de la marca de agua.
Eso es todo con la teoría. Ahora aplicaremos nuestros conocimientos en un proyecto real. Todo esto debe guardarse en un archivo. Por ejemplo, llamado marca de agua.php
Encabezado ("tipo de contenido: imagen/jpeg"); // obtener el nombre de la imagen a través de GET $imagen = $_GET["imagen"]; // crea una marca de agua $watermark = imagecreatefrompng("watermark.png"); // obtener la altura y el ancho de la marca de agua $watermark_width = imagesx($watermark); $marca de agua_altura = imágenesy($marca de agua); // crear jpg a partir de la imagen original $image_path = "/path/to/image/folder/" . $imagen; $imagen = imagecreatefromjpeg($image_path); //si algo sale mal if ($imagen === false) (return false; ) $size = getimagesize($image_path); // poner una marca de agua en la imagen $dest_x = $tamaño - $watermark_width - 5; $dest_y = $tamaño - $watermark_height - 5; imagealphablending($imagen, verdadero); imagealphablending($marca de agua, verdadero); // crea una nueva imagen imagecopy($image, $watermark, $dest_x, $dest_y, 0, 0, $watermark_width, $watermark_height); imagenjpeg($imagen); // memoria libre imagedestroy($imagen); imagedestroy($marca de agua);
Ahora, para mostrar una foto que tendrá una marca de agua sin cambiar la imagen original, use el siguiente código.
Los propietarios de sitios (foros, tablones de anuncios, etc.) a menudo enfrentan el problema de poner marcas de agua en todas las imágenes grandes del sitio.
Por supuesto, este problema se puede resolver creando manualmente una marca de agua en cada imagen; sin embargo, en primer lugar, lleva mucho tiempo y, en segundo lugar, es necesario almacenar dos versiones de la imagen, con y sin marca de agua.
La solución a este problema puede ser aplicar dinámicamente una marca de agua a la imagen antes de transferirla al visitante del sitio.
Hay una solución a este problema en Internet en forma de dos archivos, cuyo contenido se proporciona a continuación.
Código fuente del archivo ".htaccess"
DirectoryIndex index.php RewriteEngine On RewriteCond %(REQUEST_FILENAME) -f RewriteRule ^(.*)$ /watermark/_watermark.php
El código fuente del archivo "_watermark.php"
250) && ($info_o > 250)) ( // Para imágenes sin canal alfa // El último parámetro de la función es el grado de opacidad de la marca de agua imageCopyMerge($out, $watermark, ($info_o-$info_w)/ 2, ($info_o -$info_w)/2, 0, 0, $info_w, $info_w, 25); // Para imágenes con canal alfa // En este caso, la transparencia es controlada por el canal alfa de la propia imagen // imageCopy($out, $watermark, ($info_o-$info_w)/2, ($info_o-$info_w)/2, 0, 0, $info_w, $info_w); ) switch ($info_o) (caso 1 : imageGIF($out); break; caso 2: imageJPEG($out); break; caso 3: imagePNG($out); break; predeterminado: return false; ) imageDestroy($out); destrucción de imagen($original); imageDestroy($marca de agua); devolver verdadero; ) ?>
La solución se reduce a lo siguiente, el archivo ".htaccess" se coloca en el directorio con los archivos de imagen. Además, se crea la carpeta "marca de agua" en el servidor, que contiene el archivo de secuencia de comandos "_watermark.php" y el archivo de marca de agua real "watermark.png".
Al mismo tiempo, en comparación con la versión original que se encuentra en Internet, realicé cambios menores en ambos archivos de texto.
En el archivo ".htaccess", en expresión regular búsqueda de archivos de imagen, se agrega la extensión "jpeg", como también es común.
Se ha rediseñado el script "_watermark.php" para colocar la marca de agua en el centro de la imagen (esto era requerido por la tarea específica que se está resolviendo) y se ha agregado la capacidad de ajustar la transparencia de la marca de agua creada (comentarios en el script cuerpo le ayudará a establecer este parámetro usted mismo).
También debe prestar atención al hecho de que colocar la carpeta "marca de agua" en la carpeta de imágenes, como aconsejan las fuentes originales, no logrará el resultado deseado, porque. en este caso tendremos que tener en cada carpeta su propio archivo ".htaccess" y carpeta "marca de agua". Esto se debe al hecho de que el archivo ".htaccess" contiene rutas absolutas desde el directorio raíz del sitio hasta el archivo "_watermark.php". Por lo tanto, al tener una subcarpeta de "marca de agua" separada en cada carpeta con imágenes, si necesitamos cambiar la marca de agua (o el script que la superpone en la imagen), tendremos que hacer cambios en todas las carpetas.
Para evitar este problema, recomiendo crear una carpeta de "marca de agua" en el directorio raíz del sitio y colocar un archivo ".htaccess" en los directorios de imágenes sin tener que cambiarlo cada vez. En este caso, para cambiar la marca de agua o el script, necesitaremos realizar cambios en un solo lugar del sitio. Crea diferentes marcas de agua para diferentes carpetas con imágenes en este caso, puede consultar desde diferentes archivos".htaccess" a diferentes scripts como "_watermark-1.php", "_watermark-2.php", etc.
Por lo tanto, resumiendo, podemos decir que para aplicar marcas de agua a todas las imágenes del sitio, debe descargar el archivo adjunto a continuación, descomprimirlo, colocar la carpeta "marca de agua" en el directorio raíz del sitio, reemplazar el archivo de marca de agua " watermark.png" en él con el suyo propio, y coloque el archivo ".htaccess" en esos directorios del sitio, cuyas imágenes deben estar marcadas con una marca de agua.
Puede descargar un archivo que contiene todos los archivos necesarios desde este
En algunos casos, agregar marcas de agua a las imágenes que coloca en su sitio es la única forma de alguna manera protegerlos del robo. Además, dicen que tales marcas de agua atraen tráfico adicional.
Hay muchas maneras de poner una marca de agua en una imagen con usando PHP, pero mi cliente necesitaba un método de aplicación que permitiera cambiar la marca de agua por una nueva en cualquier momento.
Resulta que existe tal solución.
Esto suele ser utilizado por personas que desarrollan sitios con contenido gráfico en su mayoría.
El problema de implementar toda esta desgracia radica en la elección de cómo aplicar una marca de agua entre rendimiento y flexibilidad. Solución ideal, que convendría a todo el mundo simplemente no existe. Es por eso que hay muchas implementaciones.
En mi caso, el cliente se reserva el derecho de cambiar la marca en cualquier momento y en lugar de "Cuernos y pezuñas" escribir "Pezuñas y cuernos". El método seleccionado de marca de agua también debe tolerar esto.
La esencia de la tecnología de marca de agua descrita aquí es agregar esta misma marca cada vez que se carga una imagen. Sí, este método conlleva una serie de limitaciones que pueden afectar significativamente al rendimiento, pero como se suele decir, el cliente siempre tiene la razón, y por tanto si las tiene. Dado que la tarea requiere la aplicación dinámica de una marca de agua, esto es exactamente lo que debe hacer.
Si alguien tiene una manera más fácil, entonces eres bienvenido en los comentarios. Será interesante escuchar.
Antes de traer algo de código, me gustaría describir las ventajas, así como dar un ejemplo de trabajo.
Conclusiones: para acomodar una pequeña cantidad de imágenes con marcas de agua, este método es el mejor, pero si va a abrir una galería de fotos, será más correcto buscar algo menos pesado.
Como prometí, para esto no necesitas tener ningún conocimiento especial, necesitas:
Eso es todo. Todos contentos, tanto tú como el cliente.
Corre un gran riesgo cuando publica sus imágenes y videos en Internet, ya que su contenido se puede copiar fácilmente a cientos de otros sitios. No sería genial encontrar tu foto para la noticia, por ejemplo, en la que trabajaste mucho, en otro sitio sin indicar la fuente, es decir, tu sitio, ¿verdad? Estará molesto, por decirlo suavemente, pero si no fuera así imagen sencilla a las noticias, y el trabajo difícil en Photoshop, ¡decir que te enojarás es no decir nada! Entonces, ¿qué puede hacer para proteger sus gráficos?
Para proteger los derechos de autor de imágenes o videos en Internet, generalmente se usa una marca de agua digital o una marca de agua digital por conveniencia. Adjunte una marca de agua a cada imagen cargada para asegurarla. CEH puede ser el logotipo de su sitio o empresa, bella y estéticamente colocado en las imágenes cargadas.
Primero creemos un archivo que contenga la configuración necesaria en forma de constantes: /config.php:
Define("WATERMARK_OVERLAY_IMAGE", "/develop/images/watermark.png"); // Ruta a su marca de agua define("WATERMARK_OUTPUT_QUALITY", 100); // La calidad de la imagen recibida de la marca de agua. Recuerde que la calidad afecta directamente el tamaño del archivo. define("DESTINO_IMAGEN_CARGADA", "/desarrollar/carpeta1/"); // Ruta a la ubicación de las imágenes cargadas iniciales define("WATERMARK_IMAGE_DESTINATION", "/develop/folder2/"); // Ruta a las imágenes con marca de agua superpuesta
Recopilemos los archivos creados anteriormente en el archivo que ejecuta la descarga /subir.php
incluir("config.php"); include("funciones.php"); $resultado = ImageUpload($_FILES["userfile"]["tmp_name"], $_FILES["userfile"]["name"]); if ($resultado === falso)( echo "¡Falló la carga!"; )
Por ejemplo, si la imagen que se está cargando fuera:
Luego, después de cargar y aplicar una marca de agua, obtienes la siguiente imagen: 
EN este ejemplo la imagen subida se guarda en una carpeta, y la imagen con marca de agua digital en otra, para que siempre tengas acceso a las imágenes originales, pero, por supuesto, debes colocar imágenes de la CEH en el sitio.
(178,4 KiB, 989 visitas)
Una de las cosas interesantes que puede hacer con la biblioteca de gráficos GD de PHP es una clase que marca una imagen con una marca de agua. En resumen, la marca de agua es una tecnología para proteger las imágenes digitales del uso no autorizado mediante marcas de agua o subtítulos. Como consecuencia de esto, puede usarse (y en su mayoría lo es) para determinar el propietario de los derechos de autor de una imagen. Así que sigamos adelante.
En esta etapa de su desarrollo, PHP ofrece una amplia gama de funciones para que los programadores generen y trabajen dinámicamente con imágenes. En este artículo, le mostraré cómo crear una clase que marcará con agua estas mismas imágenes. Esta clase trabajará con dos imágenes: original y marca de agua. Como adición, se ha introducido un tercer parámetro: nuestra clase contendrá una variable alfa. Esto nos permitirá usar un canal alfa para nuestra marca de agua.
Para referencia
canal alfa (canal alfa): parte de la imagen que almacena información sobre la transparencia de secciones individuales de la imagen, mientras que los canales de color almacenan información sobre el color de la imagen. EN editores gráficos se utiliza para enmascarar (proteger de la edición) alguna zona de la imagen. En algunas aplicaciones, se les llama máscara transparente.
La información que se encuentra en el canal alfa suele representar puntos destacados: alguna forma o disposición de áreas coloreadas. Mantener el canal alfa en la imagen aumenta el tamaño del archivo en 1/3. Las imágenes RGB pueden tener hasta 24 canales alfa. Los mapas de bits y las imágenes indexadas no pueden contener canales alfa.
Antes de comenzar a escribir la clase en sí, veamos las funciones que se usarán en ella. Aquí está su lista:
# devuelve el ancho y el alto de la imagen imagesx() imagesy() # crea una nueva imagen de color verdadero imagecreatetruecolor # devuelve una matriz asociativa con las claves rojo, verde y azul (+canal alfa) que contiene los valores correspondientes para el índice de color especificado imagecolorsforindex() # devuelve el índice de color de un píxel en una ubicación específica de una imagen imagecolorat() # dibuja un solo píxel del color dado imagesetpixel() # devuelve el índice del índice de color de la paleta de la imagen, la identificación del color (compuesto de componentes RGB), y el índice de color de la paleta de la imagen que es "más cercana" al valor RGB respectivamente (este dato es necesario para la función imagesetpixel()) imagecolorexact() imagecolorallocate() imagecolorclosest()
Como puede ver, php tiene suficientes funciones para trabajar con gráficos. Aunque en teoría la finalidad de algunos de ellos no está del todo clara, en la práctica todo es mucho más sencillo. Por lo tanto, para averiguar cómo trabajar con ellos, los aplicaremos en nuestra clase.
Ahora que ya hemos decidido el objetivo de nuestro "mini-proyecto", retrocedamos un poco y hablemos sobre las formas de implementarlo.
Primero, nuestra aplicación recibe dos imágenes: la imagen original y la marca de agua en sí. A continuación, debemos determinar las dimensiones de estas imágenes (ancho-ancho y alto-alto). Necesitamos estos datos para colocar la marca de agua en el centro de la imagen (asumiendo que el tamaño de la marca de agua será más pequeño que la imagen misma).
Luego necesitaremos superponer nuestra marca de agua en la imagen original. Para hacer esto, necesitamos sumar los colores (matemáticamente) de las imágenes superpuestas para obtener la tercera.
Y al final, necesitaremos mostrar la imagen resultante en el navegador. EN este caso la imagen se abrirá directamente desde la fuente especificada en la etiqueta " "
Creo que la teoría ya es suficiente: los puntos clave se revelan con suficiente detalle. Ahora pasemos a escribir el guión.
Comencemos con lo más simple: escribamos una clase que cree un archivo con una marca de agua. Llamémoslo "marca de agua" y escribamos su código en el archivo "api.watermark.php". El "esqueleto" de la clase tendrá tres funciones:
El siguiente paso es escribir el código para las funciones de la clase "marca de agua". Complementamos el archivo "api.watermark.php" con las siguientes líneas de código:
# una función que fusiona dos imágenes de origen en una sola función create_watermark($main_img_obj, $watermark_img_obj, $alpha_level = 100) ( # convierte el valor de transparencia del canal alfa de % a decenas $alpha_level/= 100; # calcula las dimensiones de la imagen (ancho y alto ) $main_img_obj_w = imagesx($main_img_obj); $main_img_obj_h = imagesy($main_img_obj); $watermark_img_obj_w = imagesx($watermark_img_obj); $watermark_img_obj_h = imagesy($watermark_img_obj); # determinar las coordenadas del centro de la imagen $main_img_obj_min_x=piso(($main _img_obj_w /2)-($watermark_img_obj_w/2)); $main_img_obj_max_x=ceil(($main_img_obj_w/2)+($watermark_img_obj_w/2)); $main_img_obj_min_y=piso(($main_img_obj_h/2)-($watermark_img_obj_h/2 ) ); $main_img_obj_max_y=ceil(($main_img_obj_h/2)+($watermark_img_obj_h/2)); # crear una nueva imagen $return_img = imagecreatetruecolor($main_img_obj_w, $main_img_obj_h); # recorrer la imagen original # "algo de código " # mostrar imagen con marca de agua return $return_img; ) # fin de la función create_watermark()
Ahora echemos un vistazo más de cerca a la función create_watermark().
En primer lugar, le pasamos tres parámetros:
# imagen de origen para la marca de agua $main_img_obj # la propia marca de agua debe contener un canal alfa $watermark_img_obj # valor de transparencia del canal alfa de la marca de agua, (0-100, predeterminado = 100) $alpha_level
(Es importante tener en cuenta que nuestra función acepta imágenes como objetos, no solo como caminos hacia ellos, sino más adelante).
El siguiente paso es crear una nueva imagen en color verdadero con las mismas dimensiones que la imagen original. Esta imagen (variable ($return_img)) se utilizará para combinar la información de las imágenes originales (imagen y marca de agua).
Pero antes de eso, aún necesita "recorrer" cada una de las dos imágenes originales y "fusionarlas" en una sola. Es demasiado pronto para hacer esto, todavía no estamos listos para esto. En su lugar, colocaremos un comentario de "algún código" y luego agregaremos un fragmento de código a ese espacio.
El paso final es mostrar nuestra imagen modificada en la página web que lo solicita. A continuación, considere las dos funciones auxiliares restantes.
Además de la función create_watermark, nuestra clase de marca de agua tiene dos funciones más. Continuemos fuente clase con las siguientes líneas:
# promediar dos colores, teniendo en cuenta la transparencia de la función del canal alfa _get_ave_color($color_a, $color_b, $alpha_level) (return round((($color_a*(1-$alpha_level))+($color_b*$alpha_level) )); ) # devuelve los valores de los componentes RGB más cercanos de la nueva función de imagen _get_image_color($im, $r, $g, $b) ( $c=imagecolorexact($im, $r, $g, $ b); if ($c!=- 1) devuelve $c; $c=imagecolorallocate($im, $r, $g, $b); if ($c!=-1) devuelve $c; return imagecolorclosest( $im, $r, $g, $b); )
Y ahora con más detalle. Nuestra primera función "_get_ave_color" toma los valores numéricos de dos colores y un canal alfa. Devuelve su valor medio. Necesitamos esta función para determinar el color que se obtendrá al superponer los píxeles de dos dibujos.
La segunda función "_get_image_color" divide la imagen en componentes rojo (rojo), verde (verde) y azul (azul) (paleta rgb). con incorporado funciones php para trabajar con gráficos (su descripción estaba al principio del artículo), obtenemos el valor de color más cercano para la nueva imagen.
Además, se comprueban algunos puntos más. Primero, si fue posible obtener el valor exacto (variable $c), entonces se devuelve desde la función (return $c). De lo contrario, se intenta hacer coincidir el color con la función imagecolorallocate(). Si esto no ayuda a lograr el resultado, al usar la función imagecolorclosest (), simplemente se devuelve el valor de color más cercano (el más inexacto).
Bueno, nuestra clase está casi lista. Solo queda reemplazar el comentario "algún código" en la función "create_watermark" con las siguientes líneas:
# recorrer la imagen para ($y = 0; $y< $main_img_obj_h; $y++) { for ($x = 0; $x < $main_img_obj_w; $x++) { $return_color = NULL; # определение истинного расположения пикселя в пределах # нашего водяного знака $watermark_x = $x - $main_img_obj_min_x; $watermark_y = $y - $main_img_obj_min_y; # выбор информации о цвете для наших изображений $main_rgb = imagecolorsforindex($main_img_obj, imagecolorat($main_img_obj, $x, $y)); # если наш пиксель водяного знака непрозрачный if ($watermark_x >= 0 && $marca de agua_x< $watermark_img_obj_w && $watermark_y >= 0 && $marca de agua_y< $watermark_img_obj_h) { $watermark_rbg = imagecolorsforindex($watermark_img_obj, imagecolorat($watermark_img_obj, $watermark_x, $watermark_y)); # использование значения прозрачности альфа-канала $watermark_alpha = round(((127-$watermark_rbg["alpha"])/127),2); $watermark_alpha = $watermark_alpha * $alpha_level; # расчет цвета в месте наложения картинок $avg_red = $this->_get_ave_color($main_rgb["rojo"], $watermark_rbg["rojo"], $watermark_alpha); $avg_green = $this->_get_ave_color($main_rgb["green"], $watermark_rbg["green"], $watermark_alpha); $avg_blue = $this->_get_ave_color($main_rgb["blue"], $watermark_rbg["blue"], $watermark_alpha); # utilizando los datos recibidos, calcule el índice de color $return_color = $this->_get_image_color($return_img, $avg_red, $avg_green, $avg_blue); # si no puede elegir un color, simplemente tome # una copia del píxel original) else ($return_color = imagecolorat($main_img_obj, $x, $y); ) # dibuje una nueva imagen a partir de los píxeles recibidos imagesetpixel( $return_img, $x, $y, $return_color); ) )
Después de escribir una parte tan importante del código, puede hacer una pausa y profundizar en su análisis con más detalle.
Nuestro script primero atraviesa la imagen usando dos bucles "for". Paralelamente, también se calculan las coordenadas de cada píxel de la marca de agua.
A continuación, se busca la información RGB de cada píxel. Si el píxel actual no está en el área donde se cruzan la imagen original y la marca de agua, entonces nuestra clase solo duplica el píxel para la nueva imagen. Si el píxel está ubicado en el área de intersección, debemos determinar su color como resultado de la superposición de la imagen original y la marca de agua.
Para determinar el color del área de intersección, primero debemos obtener el valor de la variable RGB de la marca de agua utilizando la información que obtuvimos en los bucles "for". Luego, usando la función "_get_ave_color", se determina el valor de color promedio para la nueva imagen. Luego viene la función "_get_image_color" para determinar el esquema de color que utilizará la función "return_img".
Como resultado, después de completar los bucles "for", tenemos una imagen terminada con una marca de agua.
Y ahora veamos nuestra clase en acción.
Para empezar, necesitamos dos archivos. Llamemos al primero "watermark_test.php" y coloquemos el siguiente código en él:
El propósito de este archivo es muy simple: muestra las imágenes originales (main.jpg) y las resultantes (watermark.png, watermarked) en el navegador.
Como puede ver, nuestra segunda imagen (watermark.png) se refiere al archivo php image.php, no al archivo de imagen. Este enlace parece una solicitud GET, donde los valores de dos variables se pasan al archivo php: $main y $watermark.
Llamemos al segundo archivo "image.php" y coloquemos el siguiente código en él:
create_watermark($main_img_obj, $watermark_img_obj, 66); # mostrar nuestra imagen resultante en el navegador - # pero primero hacerle saber que es un encabezado de archivo jpeg ("Content-Type: image/jpeg"); header("Content-Disposition: inline; filename=" . $_GET["src"]); imagenjpeg($return_img_obj, "", 50); ?>
Bueno, aquí llegamos a la final. (ZIP, 47.6Kb)
