Instalación de la última versión de YAD (Yet Another Dialog) en antiX

Instalación de la última versión de YAD (Yet Another Dialog) en antiX

¿Qué es YAD?

YAD (Yet Another Dialog) es una herramienta de código abierto que permite crear interfaces gráficas de usuario (GUI) desde la terminal en sistemas Linux. Es una bifurcación mejorada de Zenity, diseñada para ofrecer mayor flexibilidad y opciones avanzadas, como diálogos HTML, soporte para Webkit, y vistas de código fuente con GtkSourceView. Desarrollada por Victor Ananjevsky, YAD es ideal para usuarios y desarrolladores que buscan automatizar tareas o crear scripts interactivos sin necesidad de programar aplicaciones completas.

Watermark (Marcas de Agua con YAD)

El paquete YAD se encuentra en algunos repositorios de Linux; sin embargo, todas son versiones anteriores. Actualmente (25 de marzo de 2025), "antiX-23.1_x64-base Arditi del Popolo 21 February 2024" aún mantiene la versión 0.40.0 de YAD (sin la opción webkit/--html), mientras que la versión actual de YAD del autor (Victor Ananjevsky) es la Release 14.1. Por lo tanto, en el caso de antiX, se necesita compilar YAD (la opción más segura) en el equipo.

Obtener el código fuente

Solo debe obtener el código fuente de YAD del repositorio oficial de su autor, que se encuentra en Github:

https://github.com/v1cont/yad/releases

A continuación, sigue estos pasos en la terminal:

• Accede como root:

(Ingresa tu contraseña)

sudo -s

• Instala las dependencias necesarias:

apt install automake build-essential intltool libglib2.0-dev libgtk-3-dev gstreamer1.0-libav gstreamer1.0-plugins-good gstreamer1.0-plugins-bad libwebkit2gtk-4.0-dev libgtksourceview-3.0-1 libgtksourceview-3.0-common libgtksourceview-3.0-dev gtk-update-icon-cache

• Sal del modo root:

exit

• Dirígete a una carpeta para descargar el código fuente (ajusta antix1 por tu usuario):

(Si no existe la carpeta "src", créala primero con mkdir src)

cd /home/antix1/src

• Clona el repositorio de YAD:

git clone https://github.com/v1cont/yad.git yad-dialog-code

• Entra en la carpeta del código:

cd yad-dialog-code

• Prepara el entorno para la compilación:

autoreconf -ivf && intltoolize

• Configura las opciones de compilación (incluye soporte para HTML y SourceView):

./configure --enable-html --enable-sourceview

make

Instalar YAD (como root)

Ahora, instala YAD con los siguientes comandos:

• Vuelve a entrar como root:

sudo -s

(Ingresa tu contraseña)

• Compila e instala YAD:

make install

• Ejecuta manualmente la actualización del caché de íconos:

gtk-update-icon-cache

¡HECHO! - Prueba YAD

Para verificar que todo funcionó correctamente, ejecuta en la terminal:

yad --about

Deberías ver algo como esto:

YAD
14.1
Built with Webkit
Built with GtkSourceView
Using GTK+ 3.24.38

¡Listo! Ahora tienes la versión más reciente de YAD instalada en tu sistema antiX.

¿Qué pasa con la versión 0.40 de YAD instalada por antiX?

En antiX, la versión 0.40 de YAD viene preinstalada desde los repositorios de Debian y es una dependencia de herramientas como control-centre-antix o apt-notifier. Si intentas eliminarla con sudo apt remove yad, también se desinstalarán estos paquetes, lo cual no es deseado.

Para evitar que una actualización futura de apt reemplace la 14.1 por la 0.40, bloquea el paquete yad en el gestor de paquetes:

Convivencia de dos versiones de YAD: 0.40 y 14.1

Tras instalar la versión 14.1 con sudo make install, esta se coloca en /usr/local/bin/yad, mientras que la versión 0.40 de Debian permanece en /usr/bin/yad. Al ejecutar:

which yad

Si obtienes /usr/local/bin/yad, significa que la 14.1 tiene prioridad gracias al orden del $PATH. Sin embargo, para evitar confusiones o conflictos futuros, te recomiendo:

1. Eliminar la versión antigua manualmente (sin afectar dependencias):

sudo rm /usr/bin/yad

2. Bloquear actualizaciones de apt para yad:

sudo apt-mark hold yad

Así, solo la versión 14.1 quedará operativa, y apt no la sobrescribirá con la 0.40 en futuras actualizaciones. Verifica con yad --about que sigues usando la 14.1.

Con esto, tu versión compilada (14.1) protegida y operativa hasta que decidas actualizarla manualmente de nuevo.

Implicaciones del soporte para WebKit en Yad

WebKit es un motor de renderizado de código abierto utilizado por navegadores como Safari y otros. Su integración en Yad implica que ahora se pueden mostrar contenidos web (HTML, CSS, JavaScript) dentro de diálogos gráficos generados por Yad. Esto abre las puertas a interfaces más dinámicas y modernas, ya que no está limitado a widgets básicos de GTK, sino que puede aprovechar la potencia del renderizado web.

• Visualización de contenido web: Los diálogos de Yad pueden mostrar páginas web o fragmentos de HTML renderizados en tiempo real, lo que es útil para mostrar documentación, formularios interactivos o vistas previas.
• Interactividad mejorada: Al soportar JavaScript mediante WebKit, Yad puede ejecutar scripts dentro de los diálogos, permitiendo interacciones dinámicas sin necesidad de herramientas externas.
• Compatibilidad multiplataforma: WebKit es altamente portable, lo que asegura que los diálogos con contenido web funcionen consistentemente en diferentes sistemas operativos compatibles con Yad (como Linux).

Ejemplos prácticos de uso

Mostrar una página web en un diálogo de Yad con WebKit

Supongamos que quieres mostrar una documentación en línea o un formulario web en un diálogo. Podrías usar WebKit para renderizar contenido HTML directamente:

yad --title="Julio Alberto Lascano (@drcalambre@mastodon.social) - Mastodon" --html --uri="https://mastodon.social/@drcalambre" --width=1024 --height=900

Historial de mejoras de YAD

Versión 14.1

• Corrección de la compilación con versiones antiguas de glib.

Versión 14.0

• Añadida la opción --workdir para cambiar el directorio de trabajo actual.
• Añadida la opción --window-type.
• Añadido el zoom en el diálogo HTML.
• Actualizaciones en la página de manual.
• Añadida la opción de configuración --disable-deprecated para excluir funciones obsoletas en tiempo de compilación.
• Posibilidad de compilar contra webkit2gtk-4.1 o webkit2gtk-4.0.
• Limpieza de código.

Versión 13.0

• Ampliado el comportamiento de --in-place en el diálogo de información de texto.
• Mejora en la apariencia de las etiquetas.
• Mejora en la colocación de la ventana de YAD.
• La opción --homogeneous también afecta a las columnas del formulario.
• Mejora en la ejecución de comandos externos.
• Corrección del campo de interruptor en el diálogo de formulario.
• Añadida la alineación de contenido en el diálogo de lista.
• Carga de CSS personalizado desde una cadena arbitraria además de un archivo.
• Añadida traducción al georgiano.
• Añadido el directorio debian/.
• Correcciones en la página de manual.

Versión 12.3

• Corregida la configuración de propiedades de WebKit y la hoja de estilo definida por el usuario en el diálogo HTML.
• Mejora en el manejo de entrada estándar (stdin) para el diálogo HTML.
• Actualización de la nota de derechos de autor.

Versión 12.2

• Añadida la opción --auto-scroll como alias de --tail.
• Corregido el salto a anclajes en modo simple del diálogo HTML.
• Corregido el análisis de datos desde entrada estándar para el modo árbol del diálogo de lista.
• Corregida la página de manual.
• Limpieza de código.

Versión 12.1

• Corregidos algunos errores tipográficos.
• Corregidos los permisos en la creación de miniaturas.
• Mejora en la cadena del intérprete en el script yad-settings.

Versión 12.0

• Añadida la capacidad de cargar varias imágenes en el diálogo de imágenes.
• Añadido un selector de color al diálogo de color y a yad-tools.
• Añadida la opción --line al diálogo de información de texto.
• Mejora en la detección de resaltado de sintaxis en el diálogo de información de texto.
• Añadida la opción --mime al modo de íconos en yad-tools.
• Añadido el tipo de campo interruptor en el diálogo de formulario (gracias a Misko <mpsrbija@gmail.com>).
• Uso de marcado Pango para campos de texto multilínea en el diálogo de formulario.

Versión 11.1

• Corrección del análisis de entrada para el ícono de notificación.
• Corrección del análisis de archivos de escritorio para el diálogo de íconos.
• Corrección del manejo de enlaces en el modo navegador del diálogo HTML.
• Mejora en la configuración de imágenes definidas por el usuario en el diálogo "acerca de".

Versión 11.0

• Eliminada la traducción al ruso "DROP K HUJAM".
• Para otros cambios, consulta el registro de cambios en git.

Versión 10.1

• No hacer las filas homogéneas cuando el formulario tiene un campo de texto.

Versión 10.0

• Muchas mejoras en el diálogo de información de texto:
  • Usa fuente monoespaciada por defecto.
  • Añadida barra de búsqueda en lugar de campo emergente (puede desactivarse).
  • Añadidas más capacidades de GtkSourceView (usa --help-source para ver la lista completa).
  • Añadida edición en el lugar y operaciones de archivo mediante menú emergente o atajos de teclado.
• Añadida barra de búsqueda al diálogo HTML (puede desactivarse).
• Añadidos atajos Ctrl+O y Ctrl+Q al diálogo HTML.
• Añadida la opción --f1-action que ejecuta un comando al presionar F1.
• Añadida la opción --changed-action al diálogo de formulario para controlar estados de campos como casillas o listas desplegables.
• Corregida la compilación con musl.
• Añadido el script yad-settings, una interfaz basada en YAD para editar configuraciones.
• Forzado el uso de íconos pequeños en el diálogo de lista si el ícono no es un nombre de archivo real.
• Corregido el ajuste de imágenes en el diálogo de imágenes.

Versión 9.3

• Corrección del bloqueo de la ventana principal con --row-action en el diálogo de lista o @cmd en diálogos de formulario.

Versión 9.2

• Algunas correcciones en el menú de listas editables.
• Añadidos dos elementos adicionales al menú de listas editables: "mover arriba" y "mover abajo".
• Uso de comillas dobles para argumentos en el comando intérprete por defecto.

Versión 9.1

• Corrección de la opción --version.

Versión 9.0

• Implementado un diálogo --about personalizable por el usuario.
• Corrección del paso de foco a hijos en diálogos de cuaderno y paneles.
• Añadido el modo --stack al diálogo de cuaderno.
• Añadida la opción --focused al diálogo de paneles para seleccionar el panel enfocado.
• No expandir verticalmente la entrada en el diálogo de entrada.
• Corrección de la posición del separador en el diálogo de paneles.
• Añadida la opción --wk-prop al diálogo HTML y habilitada la salida JS por defecto.
• Añadida la utilidad yad-tools en lugar de pfd. Ahora pfd es un script envolvente (por compatibilidad).
• Añadida la opción --align-buttons para alinear etiquetas en campos de botones en el diálogo de formulario.

Versión 8.0

• Añadida la opción --text-width para un ajuste más flexible de cadenas largas en el texto del diálogo.
• Manejo de URIs en el texto del diálogo.
• Añadida la opción --css (marcada --gtkrc como obsoleta).
• Muchas correcciones de errores.

Agradecimiento especial a Dmitry Butskoy por numerosas contribuciones.

Versión 7.3

• Corrección del análisis del campo separador en el diálogo de formulario (gracias a Dmitry Butskoy).
• Corrección del manejo del tamaño definido por el usuario con los argumentos --width y --height.

Versión 7.2

• Corrección del análisis de nombres de campos en el diálogo de formulario.
• Corrección del manejador de URI en el diálogo HTML.
• Añadido el esquema file: para la expresión regular de URI en el diálogo de información de texto.

Versión 7.1

• Corrección del análisis de nombres de campos en el diálogo de formulario.

Versión 7.0

• Añadida la opción --enforce-step al diálogo de escala.
• Añadidos tooltips y marcado a los encabezados de columnas en el diálogo de lista.
• Añadida definición de fuente estilo Pango al diálogo de información de texto.
• Añadida la opción --large-preview para un mejor manejo de miniaturas.
• Añadida la opción --interactive al explorador de íconos para imprimir íconos seleccionados en stdout.
• Añadido un manejador de URI personalizado (opción --uri-handler).
• Mejora en el algoritmo de eliminación de hijos en diálogos de cuaderno y paneles.
• Añadidos tooltips para campos de formulario.
• Corrección de la columna :tip en el diálogo de lista.
• Correcciones y limpiezas en funciones misceláneas.
• Corrección del análisis de rangos numéricos en el diálogo de formulario.
• Correcciones en la página de manual.
• Compilación del explorador de íconos por defecto.

Versión 6.0

• Añadida la opción --use-interp. Esta característica reduce el uso de comillas en argumentos de comandos.
• Añadido campo de enlace al diálogo --form.
• Opciones personalizables devueltas al diálogo --text-info.
• Corrección del comportamiento de YAD fuera de X11 (agradecimiento especial a Michael Weiser).
• Mejora en la colocación de la ventana del diálogo.
• Actualización de traducciones.

Versión 5.0

• Añadido modo de depuración, activable mediante gsettings. En este modo, YAD advierte sobre opciones obsoletas o inexistentes.
• Añadida la opción de configuración --enable-standalone para compilar YAD sin soporte de gsettings.
• Corrección de la expansión de nodos de árbol para datos de entrada estándar.
• Algunas correcciones en el diálogo de impresión.
• Corrección de la opción --uri-handler en el diálogo HTML.
• Corrección del comportamiento incorrecto de cierre automático en el diálogo de progreso.

Versión 4.1

• Corrección del manejo de datos de árbol desde entrada estándar en el diálogo de lista.

Versión 4.0

• La fuente puede seleccionarse con doble clic en el diálogo de fuentes.
• Añadido diálogo selector de aplicaciones y campo selector de aplicaciones en el diálogo de formulario.
• Añadido modo árbol en el diálogo de lista.
• Las funciones de diálogo multi-progreso se fusionaron con el diálogo de progreso. El diálogo multi-progreso separado ya no existe.
• Habilitado el marcado en la ventana de registro de progreso.
• Corrección de la salida de valores de color en notación hexadecimal.
• Eliminados los alias *-selection para los diálogos --file, --color y --font.

Versión 3.0

• Añadidos manejadores definidos por el usuario para todas las acciones de edición en el diálogo de lista. El parámetro --add-action renombrado a --row-action.
• Corrección de la carga de texto desde archivo en el diálogo de información de texto.
• Corrección de los nombres de claves en gsettings.

Versión 2.0

• Migración a gsettings desde archivo de configuración.
• Añadida la opción --keep-icon-size.
• El explorador de íconos muestra solo íconos regulares por defecto, modificable desde la línea de comandos.
• Corrección de fallo de segmentación en el diálogo de información de texto al especificar un archivo vacío.
• Corrección de la selección inicial en etiquetas seleccionables.

Versión 1.0

• Eliminado completamente el soporte para gtk+-2.0.
• Versión mínima requerida de gtk+ aumentada a 3.22.0.
• Añadida la opción --formatted al diálogo de información de texto para mostrar texto con marcado Pango.
• Añadida la opción --expand al diálogo de pestañas.
• El protocolo por defecto para el widget HTML es ahora HTTPS.
• Los elementos de stock de GTK ya no se usan; en su lugar, hay nombres predefinidos por YAD (detalles en la página de manual).
• Añadida la opción --bool-fmt para diferentes formas de salida de valores booleanos, reconocidas automáticamente en la entrada.
• La librería gspell ahora se usa para la corrección ortográfica.
• El ícono de bandeja es opcional ahora; este diálogo está habilitado por defecto pero puede desactivarse con ./configure --disable-tray.
• Eliminadas las opciones --fore, --back y --font para el diálogo de información de texto; esta funcionalidad puede lograrse mediante CSS personalizado.

Versión 0.42.0

• Añadida la utilidad pfd para la transformación de nombres de fuentes en scripts.
• Añadida la acción 'menú' para el ícono de notificación.
• Añadida la opción --icon-size al diálogo de íconos.
• Añadida la opción --simple-tips al diálogo de lista.
• Correcciones en la configuración del tamaño de la ventana.
• Mejora en la escalabilidad del tamaño en la salida separada del diálogo de fuentes.

Conky: Monitoreo de temperadura de discos en antiX

Script para automatizar la limpieza con BleachBit en antiX

Script: clean_with_bleachbit.sh

---

BleachBit . Personalmente yo la uso con antiX. Algunas características que lo hacen interesante:

• Limpieza profunda: BleachBit es conocido como "el CCleaner para Linux" por su capacidad de limpiar profundamente los sistemas, eliminando cachés, registros, cookies, archivos temporales y más.
• Soporte para múltiples aplicaciones: Puede limpiar archivos y cachés de una amplia gama de aplicaciones, como navegadores web, suites de oficina y programas de mensajería.
• Interfaz gráfica y de línea de comandos: Ofrece una interfaz gráfica sencilla y también puede ser usado desde la línea de comandos, lo que lo hace versátil para diferentes tipos de usuarios.
• Desfragmentación y trituración de archivos: Puede desfragmentar archivos y triturar archivos para una eliminación segura.

Interface de BleachBit

Ventajas:

• Eficiencia: Es ligero y consume pocos recursos del sistema.
• Potencia en la limpieza: Se enfoca específicamente en la limpieza y lo hace de manera efectiva.
• Flexibilidad: La opción de usarlo desde la línea de comandos lo hace adecuado para scripts y automatización . Aca les dejo un ejemplo de como podría ser incorporado a un script (este script opcionalmente luego podría ser incorporado como una tarea administrativa a través de cron).

Código

#!/bin/bash
# --------------------------------------------------------------------------------------------------------------------------------------
# File: clean_with_bleachbit.sh
# By Julio Alberto Lascano http://drcalambre.blogspot.com/
#________          _________        .__                ___.                  
#\______ \_______  \_   ___ \_____  |  | _____    _____\_ |_________   ____  
# |    |  \_  __ \ /    \  \/\__  \ |  | \__  \  /     \| __ \_  __ \_/ __ \ 
# |    `   \  | \/ \     \____/ __ \|  |__/ __ \|  Y Y  \ \_\ \  | \/\  ___/ 
#/_______  /__|     \______  (____  /____(____  /__|_|  /___  /__|    \___  >
#        \/                \/     \/          \/      \/    \/            \/ 
# --------------------------------------------------------------------------------------------------------------------------------------
# Last modified:2024-07-14
# --------------------------------------------------------------------------------------------------------------------------------------

# Script para automatizar la limpieza con BleachBit
# Asegúrate de tener BleachBit instalado y configurado para ejecutarse desde la línea de comandos

# Configurar las opciones de limpieza de BleachBit
# Puedes encontrar la lista completa de opciones en la documentación de BleachBit o usando `bleachbit --list`

# Lista de opciones de limpieza
options=(
    "apt.autoclean"
    "apt.clean"
    "system.cache"
    "system.tmp"
    "chromium.cache"
    "chromium.dom"
    "chromium.history"
    "chromium.form_history"
    "chromium.search_engines"
    "chromium.sync"
    "chromium.vacuum"
    "firefox.cache"
    "firefox.crash_reports"
    "firefox.dom"
    "firefox.forms"
    "firefox.session_restore"
    "firefox.site_preferences"
    "firefox.vacuum"
    "google_chrome.cache"
    "google_chrome.dom"
    "google_chrome.history"
    "google_chrome.search_engines"
    "google_chrome.vacuum"
)   

# Función para ejecutar la limpieza
run_bleachbit() {
    for option in "${options[@]}"; do
        echo "Limpiando $option"
        bleachbit --clean "$option"
    done
}

# Ejecutar la función de limpieza
run_bleachbit

# Salida del script
echo "Limpieza completada con BleachBit"

Guardar el script en:

 
/usr/local/bin/clean_with_bleachbit.sh

Dar permisos de ejecución al script

chmod +x /usr/local/bin/clean_with_bleachbit.sh

Implementación con CRON

# Editar el archivo crontab para el usuario actual

(crontab -l 2>/dev/null; echo "0 2 * * * /usr/local/bin/clean_with_bleachbit.sh >> /var/log/bleachbit.log 2>&1") | crontab -

En el ejemplo de cron proporcionado programará la ejecución del script clean_with_bleachbit.sh todos los días a las 2:00 AM. Explicación del Cronograma

0 2 * * *: Esta parte del cronograma especifica los momentos en que se ejecutará el script.
0: El minuto en que se ejecutará la tarea (0 significa en el minuto cero de la hora especificada).
2: La hora en que se ejecutará la tarea (2 significa a las 2:00 AM).
*: Cualquier día del mes.
*: Cualquier mes.
*: Cualquier día de la semana.
Interpretación
Minuto (0): El script se ejecutará al minuto 0 de la hora especificada (es decir, al principio de la hora).
Hora (2): El script se ejecutará a las 2:00 AM.
Día del Mes (*): Se ejecutará cualquier día del mes.
Mes (*): Se ejecutará cualquier mes.
Día de la Semana (*): Se ejecutará cualquier día de la semana.

Verificación Después de ejecutar el comando anterior, puedes verificar que la tarea cron se haya configurado correctamente utilizando el siguiente comando:

crontab -l

Implementación con ANACRON

Usar anacron en lugar de cron para tu script de limpieza con BleachBit puede ofrecer varias ventajas, especialmente si estás en un entorno donde el equipo no está encendido constantemente o en horarios específicos.

Aquí están algunas de las ventajas:

• Ejecución Garantizada: anacron garantiza que las tareas programadas se ejecuten incluso si el equipo estuvo apagado durante el horario programado. En contraste, cron solo ejecuta tareas en momentos específicos y las tareas se pierden si el equipo no está encendido.
• Flexibilidad de Horarios: anacron permite definir periodos en días para la ejecución de tareas (e.g., diario, semanal, mensual) sin necesidad de especificar una hora exacta, lo que ofrece mayor flexibilidad para equipos que no están siempre encendidos.
• Fácil Configuración para Tareas Periódicas: Para tareas que necesitan ejecutarse al menos una vez al día, anacron es una opción más sencilla y robusta. En lugar de depender de un cronjob que puede no ejecutarse si el sistema está apagado, anacron simplemente ejecuta la tarea la próxima vez que el sistema esté encendido.
• Manejo Automático de Retrasos: Si una tarea se retrasa (por ejemplo, porque el equipo estuvo apagado en el momento programado para la ejecución), anacron se encargará de ejecutarla la próxima vez que el equipo esté encendido. Esto asegura que las tareas críticas no se pierdan simplemente porque el equipo no estaba disponible en el momento exacto de la programación, a diferencia de cron, que no reprograma tareas perdidas.

El COMO usar anacron con un usuario común, aunque requiere algunos pasos adicionales en comparación con cron. A continuación, una explicacíon cómo configurar anacron para un usuario común.

Instalar anacron.

Primero, asegúrate de que anacron esté instalado en tu sistema. En la mayoría de las distribuciones basadas en Debian/Ubuntu, puedes instalarlo con:.

sudo apt-get install anacron

Crear Directorios y Archivos de Configuración

anacron generalmente se configura a nivel de sistema, pero puedes configurarlo para un usuario común creando los directorios y archivos necesarios en tu directorio de inicio.

Crear Directorios:

Crea un directorio ~/.anacron para almacenar los archivos de estado de anacron:

mkdir -p ~/.anacron

Crear el Archivo de Tareas:

Crea un archivo llamado anacrontab en tu directorio de inicio:

touch ~/.anacron/anacrontab

Luego, edita este archivo con tu editor de texto preferido y añade la configuración de la tarea. Por ejemplo, para ejecutar el script de limpieza con BleachBit diariamente:

# archivo de configuración para anacron
# formato: periodo   demora   identificador   comando
# Trabajo diario
1       5       clean_with_bleachbit   /usr/local/bin/clean_with_bleachbit.sh >> /var/log/bleachbit.log 2>&1 && echo "---- $(date) ----" >> /var/log/bleachbit.log

Este ejemplo configura anacron para ejecutar el script clean_with_bleachbit.sh diariamente.

• 1: Especifica que el trabajo debe ejecutarse diariamente.
• 5 clean_with_bleachbit: Esto significa que el trabajo se ejecutará 5 minuto después de que anacron se inicie.
• /usr/local/bin/clean_with_bleachbit.sh: Es el script que se va a ejecutar.
• >> /var/log/bleachbit.log: Redirige la salida estándar (stdout) del script al archivo /var/log/bleachbit.log. El operador >> añade la salida al final del archivo sin sobrescribirlo.
• 2>&1: Redirige la salida de error estándar (stderr) al mismo lugar que la salida estándar (stdout).

Desglose de 2>&1

• 2 representa el descriptor de archivo para stderr.
• > es el operador de redirección.
• &1 significa que stderr se redirigirá al mismo lugar que stdout.

Crear un Script para Ejecutar anacron

Para asegurarte de que anacron se ejecute regularmente, incluso si el equipo se apaga, puedes crear un script que ejecute anacron cada vez que inicies sesión o se inicie el entorno de escritorio.

Crear el Script:

Crea un archivo llamado run_anacron.sh en tu directorio de inicio:

touch ~/run_anacron.sh

Luego, edita este archivo y añade lo siguiente:

#!/bin/bash

# Esperar 1 minuto para asegurar que el entorno esté listo
sleep 60

# Registro adicional para depuración
echo "Running Anacron script at $(date)" > ~/anacron_debug.log
echo "Current user: $(whoami)" >> ~/anacron_debug.log
echo "Current directory: $(pwd)" >> ~/anacron_debug.log
echo "Environment variables: $(env)" >> ~/anacron_debug.log
echo "Anacron status before execution:" >> ~/anacron_debug.log
/sbin/anacron -T -t ~/.anacron/anacrontab >> ~/anacron_debug.log 2>&1

# Ejecutar Anacron
/sbin/anacron -t ~/.anacron/anacrontab -S ~/.anacron -s
exit_code=$?

# Verificar el código de salida y registrar en el log
if [ $exit_code -eq 0 ]; then
    echo "Starting Anacron at $(date)" > ~/anacron_log.log
else
    echo "Anacron failed to start at $(date) with exit code $exit_code" > ~/anacron_log.log
fi

# Registrar el estado después de la ejecución
echo "Anacron status after execution:" >> ~/anacron_debug.log
/sbin/anacron -T -t ~/.anacron/anacrontab >> ~/anacron_debug.log 2>&1

Ejecutar anacron al Iniciar Sesión

Finalmente, configura tu entorno para ejecutar anacron al iniciar sesión. Puedes agregar el script run_anacron.sh a tus aplicaciones de inicio.

Para GNOME, por ejemplo:

• Abre "Aplicaciones de inicio" (Startup Applications).
• Añade una nueva entrada: Nombre: anacron

Comando: /home/tu_usuario/run_anacron.sh
Comentario: Ejecutar tareas de anacron

• Resumen: Siguiendo estos pasos, puedes usar anacron con un usuario común para ejecutar tareas programadas, asegurándote de que se ejecuten incluso si el equipo estuvo apagado durante el tiempo programado.

Además de estas variantes predefinidas, puedes definir tareas usando un formato más detallado, especificando el número de días entre ejecuciones. Aquí tienes algunos ejemplos adicionales:

Variantes de anacron

• Especificar el Número de Días
  • Puedes especificar cualquier número de días entre ejecuciones.
  • Formato: [número de días] [demora en minutos] [identificador] [comando]
  • Ejemplo para ejecutar cada 3 días:

    
            
    3 1 clean_with_bleachbit /usr/local/bin/clean_with_bleachbit.sh >> /var/log/bleachbit.log 2>&1
            
            

Ejemplos Adicionales

• Ejecutar Cada 2 Días:

  
      
  2 1 clean_temp_files /usr/local/bin/clean_temp_files.sh >> /var/log/clean_temp_files.log 2>&1
      
      

• Ejecutar Cada 10 Días:

  
      
  10 1 backup_data /usr/local/bin/backup_data.sh >> /var/log/backup_data.log 2>&1
      
      

Sintaxis del Archivo anacrontab

Cada línea en el archivo anacrontab sigue esta sintaxis:

[periodo] [demora en minutos] [identificador] [comando]

• periodo: Número de días entre ejecuciones.
• demora en minutos: Tiempo de espera antes de ejecutar la tarea después de iniciar anacron.
• identificador: Un nombre único para identificar la tarea.
• comando: El comando o script a ejecutar.

Archivo ~/.anacron/anacrontab con Varias Tareas

# archivo de configuración para anacron
# formato: periodo   demora   identificador   comando
# Trabajo diario
1       5       clean_with_bleachbit   /usr/local/bin/clean_with_bleachbit.sh >> /var/log/bleachbit.log 2>&1
# Trabajo semanal
7       1       clean_logs             /usr/local/bin/clean_logs.sh >> /var/log/clean_logs.log 2>&1
# Trabajo mensual
30      30      system_backup          /usr/local/bin/system_backup.sh >> /var/log/system_backup.log 2>&1
# Otros trabajos
3       1       clean_temp_files       /usr/local/bin/clean_temp_files.sh >> /var/log/clean_temp_files.log 2>&1
10      1       backup_data            /usr/local/bin/backup_data.sh >> /var/log/backup_data.log 2>&1

Estas configuraciones permiten una gran flexibilidad en la programación de tareas periódicas, asegurando que se ejecuten incluso si el sistema no está encendido en el momento exacto programado.

Introducción a las Interfaces Gráficas y YAD (¿Como empezó todo?)

Introducción a las Interfaces Gráficas y YAD

Las interfaces gráficas y YAD (Yet Another Dialog). 

¿Qué es una Interfaz Gráfica?

Imagina que estás en la cocina y necesitas hacer una receta que nunca has preparado antes. Tienes todos los ingredientes y utensilios, pero si no tienes una receta clara y fácil de seguir, puede ser muy complicado. Lo mismo ocurre cuando usamos computadoras y dispositivos electrónicos. Una interfaz gráfica es como esa receta clara y visual que nos permite interactuar con una computadora de manera sencilla y comprensible.

La Evolución de las Interacciones con las Computadoras

Antes de las interfaces gráficas, las personas interactuaban con las computadoras usando líneas de texto. Imagina tener que escribir comandos complicados para abrir una aplicación o archivo. Esto era difícil y poco intuitivo para la mayoría de las personas.

Antes de QDOS (Quick and Dirty Operating System), que fue posteriormente conocido como 

86-DOS, el sistema operativo más influyente y ampliamente utilizado en las microcomputadoras CP/M (Control Program for Microcomputers). Gary Kildall, fundador de Digital Research Inc., desarrolló CP/M en 1974.

Luego, llegaron las interfaces gráficas, que usan imágenes, íconos y menús desplegables que podemos ver y con los que podemos interactuar utilizando un ratón o nuestros dedos. Esto hizo que el uso de las computadoras fuera mucho más accesible y fácil para todos.

La primera interfaz gráfica de usuario (GUI) ampliamente reconocida fue desarrollada por el Xerox Palo Alto Research Center (PARC) en la década de 1970.

Ejemplos Cotidianos

• El Escritorio de una Computadora: Al encender tu computadora, lo primero que ves es el escritorio, que suele tener íconos que representan programas, archivos y carpetas. Puedes hacer clic en estos íconos para abrirlos, lo cual es mucho más intuitivo que escribir comandos.
• Aplicaciones en tu Teléfono: Cuando usas tu teléfono, ves muchas aplicaciones con íconos coloridos. Tocando estos íconos, abres las aplicaciones. Esto es una interfaz gráfica en acción.
• Cajeros Automáticos (ATM): Cuando usas un cajero automático, ves opciones en la pantalla como "Retirar dinero", "Consultar saldo", etc. Puedes tocar estas opciones para realizar tus operaciones. Esto es mucho más fácil que escribir comandos para obtener dinero.

Componentes de una Interfaz Gráfica

• Ventanas: Son áreas en la pantalla que muestran información y permiten interactuar con diferentes programas.
• Íconos: Pequeñas imágenes que representan programas, archivos o funciones.
• Botones: Áreas que se pueden hacer clic para realizar acciones, como "Aceptar" o "Cancelar".
• Menús: Listas de opciones o comandos que se despliegan cuando hacemos clic en ellos.

Beneficios de las Interfaces Gráficas

• Facilidad de Uso: Permiten a personas sin conocimientos técnicos usar computadoras y dispositivos electrónicos.
• Accesibilidad: Hacen que la tecnología sea accesible para personas de todas las edades y habilidades.
• Eficiencia: Facilitan la realización de tareas comunes de manera rápida y sencilla.

¿Qué es YAD?

YAD (Yet Another Dialog) es una herramienta que permite crear cuadros de diálogo en sistemas Linux. Es muy útil para los desarrolladores y usuarios avanzados que quieren agregar interfaces gráficas simples a sus scripts de shell. Con YAD, puedes crear ventanas con botones, cuadros de texto, listas desplegables y más, sin necesidad de conocimientos profundos de programación.

¿Cómo Funciona YAD?

YAD funciona mediante comandos que se escriben en la terminal. Estos comandos indican a YAD qué tipo de cuadro de diálogo debe mostrar y cómo debe comportarse. Por ejemplo, puedes crear un cuadro de diálogo para que el usuario seleccione un archivo, o para mostrar un mensaje de alerta.

Ejemplos de Uso de YAD

• Cuadro de Diálogo de Selección de Archivo:

yad --file

Este comando abre un cuadro de diálogo que permite al usuario seleccionar un archivo de su sistema.


• Mensaje de Alerta:

yad --info --text="Este es un mensaje de alerta"

Este comando muestra una ventana con un mensaje de alerta.


• Formulario de Entrada:

yad --form --field="Nombre" --field="Edad"

Este comando abre un formulario donde el usuario puede ingresar su nombre y edad.

Conclusión

Las interfaces gráficas han revolucionado la manera en que interactuamos con las computadoras y dispositivos electrónicos, haciendo la tecnología más accesible y fácil de usar. Herramientas como YAD permiten a los usuarios y desarrolladores crear estas interfaces de manera rápida y sencilla, integrando cuadros de diálogo en scripts de shell sin necesidad de conocimientos avanzados.

Espero que esta explicación les haya dado una buena idea de qué son las interfaces gráficas y cómo YAD puede ser utilizado para crear cuadros de diálogo en Linux.

Automatización de Marcas de Agua en Imágenes y Clasificación Basada en Luminosidad

Por Julio Alberto Lascano

En esta entrada, exploraremos dos scripts útiles para la manipulación de imágenes: uno para aplicar una marca de agua y otro para clasificar imágenes según sus características. Ambos scripts son herramientas valiosas para fotógrafos, diseñadores gráficos y cualquier persona que trabaje con imágenes digitales. La combinación de Bash y Python permite crear una solución eficiente y automatizada para procesar múltiples imágenes a la vez.

Introducción a las Librerías cv2 (OpenCV) y NumPy

En el mundo de la programación y la informática, existen herramientas poderosas que nos permiten realizar tareas complejas de manera más sencilla y eficiente. Hoy, vamos a explorar dos de estas herramientas: cv2 (también conocida como OpenCV) y NumPy.

¿Qué es cv2 (OpenCV)?

OpenCV (Open Source Computer Vision Library) es una biblioteca de software de visión por computadora. Esto significa que proporciona una gran cantidad de funciones que permiten a las computadoras "ver" y procesar imágenes y videos. Con OpenCV, puedes realizar tareas como:

• Detectar y reconocer caras en imágenes.
• Seguir objetos en movimiento en videos.
• Aplicar filtros y efectos a imágenes.
• Medir distancias y tamaños en fotografías.

Detectar y reconocer caras en imágenes

La librería cv2 es simplemente el módulo de Python para usar OpenCV. Es una herramienta muy potente en el campo de la inteligencia artificial y la visión por computadora.

¿Qué es NumPy?

NumPy (Numerical Python) es una biblioteca para el lenguaje de programación Python que permite realizar operaciones matemáticas y estadísticas de manera eficiente. Es especialmente útil cuando trabajamos con grandes cantidades de datos, ya que está diseñada para realizar cálculos rápidos y precisos. Con NumPy, puedes:

• Crear y manipular arreglos (matrices) de datos.
• Realizar operaciones matemáticas complejas.
• Procesar datos de manera eficiente.
• Integrar con otras librerías científicas y de análisis de datos.

NumPy es la base para muchas otras librerías científicas y de aprendizaje automático en Python, como SciPy, Pandas y TensorFlow.

NumPy - Software de análisis numérico

¿Por qué Usar cv2 y NumPy Juntas?

La combinación de cv2 y NumPy es muy común en proyectos de visión por computadora. NumPy se utiliza para manejar y procesar los datos de las imágenes (que son, en esencia, matrices de números) de manera eficiente, mientras que cv2 proporciona las herramientas específicas para la visión por computadora. Juntas, estas librerías permiten desarrollar aplicaciones poderosas que pueden analizar y manipular imágenes y videos de maneras muy avanzadas.

Descripción de los Scripts

aplicar_marca_agua.sh

Este script de Bash automatiza el proceso de aplicar una marca de agua a todas las imágenes en un directorio especificado. Utiliza las potentes herramientas de ImageMagick para realizar esta tarea de manera eficiente. A continuación, se detalla el flujo de trabajo del script:

• Verificación de comandos de ImageMagick: Se asegura de que los comandos 'identify', 'convert' y 'composite' estén disponibles.
• Definición de parámetros: Se especifican las rutas de las marcas de agua (blanca y negra), el directorio de imágenes a procesar, el factor de escala para el tamaño de la marca de agua y el directorio de salida.
• Verificación de parámetros y rutas: Se comprueba que todos los parámetros necesarios se han proporcionado y que las rutas de las marcas de agua y el directorio de imágenes existen. Si el directorio de salida no existe, se crea automáticamente.
• Bucle para procesar cada imagen: Itera sobre cada archivo en el directorio de imágenes, verificando si es una imagen válida.
• Obtención del tamaño de la imagen: Utiliza el comando 'identify' para obtener el tamaño de la imagen en píxeles.
• Cálculo del tamaño de la marca de agua: Calcula el tamaño de la marca de agua proporcional al tamaño de la imagen original.
• Redimensionamiento de la marca de agua: Redimensiona la marca de agua al tamaño calculado.
• Aplicación de la marca de agua: Aplica la marca de agua al pie de la imagen con un margen inferior centrado.
• Eliminación de archivos temporales: Elimina el archivo temporal de la marca de agua redimensionada después de aplicarla a la imagen.

clasificar_imagen_v5.py

Este script de Python se utiliza para determinar el color (blanco o negro) más adecuado para la marca de agua en función de la luminosidad de la región inferior de la imagen. Utiliza las bibliotecas OpenCV (cv2) y NumPy, que son herramientas poderosas para la visión por computadora y la manipulación de matrices numéricas.

• OpenCV (cv2): Es una biblioteca popular de código abierto para visión por computadora y procesamiento de imágenes. Proporciona una amplia gama de funciones para manipular y analizar imágenes.
• NumPy: Es una biblioteca fundamental en Python para la computación científica y numérica. Proporciona un objeto de matriz multidimensional y una variedad de funciones para operar sobre estas matrices.

Cómo Funciona

El script de Python realiza una segmentación basada en color en la región inferior de la imagen para identificar ciertos tonos o rangos de color. Luego, calcula la luminosidad promedio de esta región y decide si la marca de agua debe ser blanca o negra basándose en la luminosidad calculada.

Pasos del Proceso

• Carga de la imagen: El script carga la imagen proporcionada como argumento.
• Definición de la región inferior: Se define una región en la parte inferior de la imagen, que es donde se aplicará la marca de agua.
• Segmentación basada en color: Se segmenta la región inferior para identificar ciertos tonos de color.
• Cálculo de la luminosidad promedio: Se calcula la luminosidad promedio de la región inferior y de la región donde se detecta un color específico.
• Decisión del color de la marca de agua: Basándose en la luminosidad promedio y la presencia de un color específico, el script decide si la marca de agua debe ser blanca o negra.

Este enfoque asegura que la marca de agua se vea correctamente en la imagen, proporcionando un buen contraste independientemente de la luminosidad de la región donde se aplica.

Descripción del Script: aplicar_marca_agua.sh

El script aplicar_marca_agua.sh automatiza el proceso de aplicar una marca de agua a todas las imágenes en un directorio especificado. A continuación, se explica paso a paso lo que hace el script:

1. Verificación de comandos de ImageMagick: Se verifica si los comandos 'identify', 'convert' y 'composite' están disponibles.
2. Definición de parámetros:
   • MARCA_DE_AGUA_BLANCA: Ruta de la imagen que se utilizará como marca de agua blanca.
   • MARCA_DE_AGUA_NEGRA: Ruta de la imagen que se utilizará como marca de agua negra.
   • DIRECTORIO_IMAGENES: Directorio que contiene las imágenes a las que se aplicará la marca de agua.
   • FACTOR_ESCALA: Factor de escala que determina el tamaño proporcional de la marca de agua en relación con el ancho de la imagen original.
   • DIRECTORIO_SALIDA: Directorio donde se guardarán las imágenes con la marca de agua aplicada.
3. Verificación de parámetros y rutas:
   • Se verifica que todos los parámetros necesarios se han proporcionado.
   • Se verifica que las rutas de las marcas de agua y el directorio de imágenes existen.
   • Si el directorio de salida no existe, se crea automáticamente.
4. Bucle para procesar cada imagen: Se utiliza un bucle 'for' para iterar sobre cada archivo en el directorio de imágenes especificado.
5. Obtención del tamaño de la imagen: Se utiliza el comando 'identify' para obtener el tamaño de la imagen en píxeles.
6. Cálculo del tamaño de la marca de agua: Se calcula el tamaño de la marca de agua proporcional al tamaño de la imagen original, utilizando el factor de escala definido.
7. Redimensionamiento de la marca de agua: Se redimensiona la marca de agua al tamaño calculado y se elimina cualquier perfil de color incrustado para evitar advertencias.
8. Aplicación de la marca de agua: Se aplica la marca de agua al pie de la imagen con un margen inferior centrado utilizando el comando 'composite'.
9. Eliminación de archivos temporales: Se elimina el archivo temporal de la marca de agua redimensionada después de aplicarla a la imagen.

 
#!/bin/bash

# --------------------------------------------------------------------------------------------------------------------------------------
# File: aplicar_marca_agua.sh
# By Julio Alberto Lascano http://drcalambre.blogspot.com/
#________          _________        .__                ___.                  
#\______ \_______  \_   ___ \_____  |  | _____    _____\_ |_________   ____  
# |    |  \_  __ \ /    \  \/\__  \ |  | \__  \  /     \| __ \_  __ \_/ __ \ 
# |    `   \  | \/ \     \____/ __ \|  |__/ __ \|  Y Y  \ \_\ \  | \/\  ___/ 
#/_______  /__|     \______  (____  /____(____  /__|_|  /___  /__|    \___  >
#        \/                \/     \/          \/      \/    \/            \/ 
# --------------------------------------------------------------------------------------------------------------------------------------
# Last modified:2024-06-10
# --------------------------------------------------------------------------------------------------------------------------------------
# Descripción del script: aplicar_marca_agua.sh
# --------------------------------------------------------------------------------------------------------------------------------------
# Uso: aplicar_marca_agua.sh -b [marca_agua_blanca] -n [marca_agua_negra] -d [directorio_imagenes] -s [factor_escala] -o [directorio_salida]
# --------------------------------------------------------------------------------------------------------------------------------------
# Este script automatiza el proceso de aplicar una marca de agua a todas las imágenes en un directorio especificado.
# A continuación se explica paso a paso lo que hace el script:
#
# 1. Verificación de comandos de ImageMagick:
#    - Se verifica si los comandos 'identify', 'convert' y 'composite' están disponibles.
#
# 2. Definición de parámetros:
#    - MARCA_DE_AGUA_BLANCA: Ruta de la imagen que se utilizará como marca de agua blanca.
#    - MARCA_DE_AGUA_NEGRA: Ruta de la imagen que se utilizará como marca de agua negra.
#    - DIRECTORIO_IMAGENES: Directorio que contiene las imágenes a las que se aplicará la marca de agua.
#    - FACTOR_ESCALA: Factor de escala que determina el tamaño proporcional de la marca de agua en relación con el ancho de la imagen original.
#    - DIRECTORIO_SALIDA: Directorio donde se guardarán las imágenes con la marca de agua aplicada.
#
# 3. Verificación de parámetros y rutas:
#    - Se verifica que todos los parámetros necesarios se han proporcionado.
#    - Se verifica que las rutas de las marcas de agua y el directorio de imágenes existen.
#    - Si el directorio de salida no existe, se crea automáticamente.
#
# 4. Bucle para procesar cada imagen:
#    - Se utiliza un bucle 'for' para iterar sobre cada archivo en el directorio de imágenes especificado.
#    - Se verifica si el archivo actual en el bucle es un archivo regular utilizando la condición 'if [ -f "$IMAGEN" ]'.
#
# 5. Obtención del tamaño de la imagen:
#    - Se utiliza el comando 'identify' para obtener el tamaño de la imagen en píxeles.
#
# 6. Cálculo del tamaño de la marca de agua:
#    - Se calcula el tamaño de la marca de agua proporcional al tamaño de la imagen original, utilizando el factor de escala definido.
#
# 7. Redimensionamiento de la marca de agua:
#    - Se redimensiona la marca de agua al tamaño calculado y se elimina cualquier perfil de color incrustado para evitar advertencias.
#
# 8. Aplicación de la marca de agua:
#    - Se aplica la marca de agua al pie de la imagen con un margen inferior centrado utilizando el comando 'composite'.
#
# 9. Eliminación de archivos temporales:
#    - Se elimina el archivo temporal de la marca de agua redimensionada después de aplicarla a la imagen.
# --------------------------------------------------------------------------------------------------------------------------------------


# Verificación de comandos de ImageMagick
if ! command -v identify &> /dev/null || ! command -v convert &> /dev/null || ! command -v composite &> /dev/null
then
    echo "ImageMagick no está instalado o los comandos necesarios no están disponibles. Por favor, instálalo antes de ejecutar este script."
    exit 1
fi

# Manejo de errores
# Se añade manejo de errores para asegurar que el script se detenga si ocurre algún problema. 
# Se hace con: set -e lo que hace que el script termine si algún comando falla.

set -e

# Uso: aplicar_marca_agua.sh -b [marca_agua_blanca] -n [marca_agua_negra] -d [directorio_imagenes] -s [factor_escala] -o [directorio_salida]
while getopts "b:n:d:s:o:" opt; do
    case ${opt} in
        b ) MARCA_DE_AGUA_BLANCA=$OPTARG ;;
        n ) MARCA_DE_AGUA_NEGRA=$OPTARG ;;
        d ) DIRECTORIO_IMAGENES=$OPTARG ;;
        s ) FACTOR_ESCALA=$OPTARG ;;
        o ) DIRECTORIO_SALIDA=$OPTARG ;;
        \? ) echo "Uso: aplicar_marca_agua.sh -b [marca_agua_blanca] -n [marca_agua_negra] -d [directorio_imagenes] -s [factor_escala] -o [directorio_salida]"
             exit 1 ;;
    esac
done

# Verificación de parámetros
if [ -z "$MARCA_DE_AGUA_BLANCA" ] || [ -z "$MARCA_DE_AGUA_NEGRA" ] || [ -z "$DIRECTORIO_IMAGENES" ] || [ -z "$FACTOR_ESCALA" ] || [ -z "$DIRECTORIO_SALIDA" ]; then
    echo ""
    echo "Uso: aplicar_marca_agua.sh -b [marca_agua_blanca] -n [marca_agua_negra] -d [directorio_imagenes] -s [factor_escala] -o [directorio_salida]"
    echo ""
    echo "Todos los parámetros (-b, -n, -d, -s, -o) son obligatorios."
    echo "-------------------------------------------------------------------------------------------------------------"
    echo "Factor de escala para el tamaño de la marca de agua -s [factor_escala]"
    echo "Por ejemplo: -s 0.15 , un factor de escala del 15% es adecuado para la fotografia de paisajes."
    echo "-------------------------------------------------------------------------------------------------------------"
    exit 1
fi

# Verificación de la existencia de las rutas de las marcas de agua
if [ ! -f "$MARCA_DE_AGUA_BLANCA" ]; then
    echo "La ruta de la marca de agua blanca ($MARCA_DE_AGUA_BLANCA) no existe."
    exit 1
fi

if [ ! -f "$MARCA_DE_AGUA_NEGRA" ]; then
    echo "La ruta de la marca de agua negra ($MARCA_DE_AGUA_NEGRA) no existe."
    exit 1
fi

# Verificación de la existencia del directorio de imágenes
if [ ! -d "$DIRECTORIO_IMAGENES" ]; then
    echo "El directorio de imágenes ($DIRECTORIO_IMAGENES) no existe."
    exit 1
fi

# Verificación de la existencia del directorio de salida
if [ ! -d "$DIRECTORIO_SALIDA" ]; then
    echo "El directorio de salida ($DIRECTORIO_SALIDA) no existe. Creando el directorio..."
    mkdir -p "$DIRECTORIO_SALIDA"
fi

# Obtener el directorio del script Bash
SCRIPT_DIR="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"

# Ruta del script Python relativo al directorio del script Bash
SCRIPT_PATH="$SCRIPT_DIR/scripts/clasificar_imagen_v5.py"

# Verificar que el script Python exista
if [[ ! -f "$SCRIPT_PATH" ]]; then
  echo "El script $SCRIPT_PATH no existe. Verifica la ruta."
  exit 1
fi

contador=0
tiempo_inicio=$(date +%s)

# Aplicar marca de agua a cada imagen en el directorio
for IMAGEN in "$DIRECTORIO_IMAGENES"/*; do
    if [ -f "$IMAGEN" ] && file --mime-type "$IMAGEN" | grep -q -E "image/(png|gif|jpeg|jpg)"; then
        nombre_imagen=$(basename "$IMAGEN")
        
        # La expresión ${nombre_imagen##*.} utiliza un mecanismo de expansión de parámetros en el shell 
        # de Unix para extraer la extensión de un nombre de archivo.
        # Significa eliminar todo hasta el último punto en el nombre del archivo, y devolver lo que queda.
        
        
        extension_imagen="${nombre_imagen##*.}"
        
        # Obtener el tamaño de la imagen (ancho x altura)
        tamano_imagen=$(identify -format "%wx%h" "$IMAGEN")
        
        # Separar el ancho y la altura
        ancho_imagen=$(echo "$tamano_imagen" | cut -d'x' -f 1)
        altura_imagen=$(echo "$tamano_imagen" | cut -d'x' -f 2)
        
        # Calcular el tamaño de la marca de agua proporcional al tamaño de la imagen
        tamano_marca=$(echo "$ancho_imagen * $FACTOR_ESCALA" | bc)
        
        # Llamada al script de Python para determinar el color (blanco o negro)
        resultados=$(python "$SCRIPT_PATH" "$DIRECTORIO_IMAGENES$nombre_imagen" "$FACTOR_ESCALA")
        
        # Imprimir los resultados
        
        # Leer los resultados separados
		read -r resultado_color luminosidad <<< "$resultados"
		        
        # Imprimir el resultado capturado para depuración
        
		echo "-------------------------------"
		echo "Color marca de agua: $resultado_color"
		echo "Luminosidad: $luminosidad"
		echo "-------------------------------"
		echo "Aplicando marca de agua a $DIRECTORIO_IMAGENES$nombre_imagen -> $DIRECTORIO_SALIDA${nombre_imagen%.*}_wm.$extension_imagen"

        # Seleccionar la marca de agua según el color determinado
        case "$resultado_color" in
            "blanco")
                MARCA_DE_AGUA=$MARCA_DE_AGUA_BLANCA
                ;;
            "negro")
                MARCA_DE_AGUA=$MARCA_DE_AGUA_NEGRA
                ;;
            *)
                echo "Color desconocido: $color. Usando la marca de agua blanca por defecto."
                MARCA_DE_AGUA=$MARCA_DE_AGUA_BLANCA
                ;;
        esac
        
     
        # Redimensionar la marca de agua al tamaño calculado y eliminar el perfil de color
        # Crear un archivo temporal
        marca_de_agua_redimensionada=$(mktemp)
        convert "$MARCA_DE_AGUA" -resize "${tamano_marca}x${tamano_marca}" -strip "$marca_de_agua_redimensionada"
        
        # Aplicar marca de agua al pie de la imagen con margen inferior centrado
        composite -dissolve 50% -gravity South -geometry +0+50   "$marca_de_agua_redimensionada" "$IMAGEN" "$DIRECTORIO_SALIDA/${nombre_imagen%.*}_wm.$extension_imagen"
        
        # Eliminar el archivo temporal de la marca de agua redimensionada
        rm "$marca_de_agua_redimensionada"
        
        # Incrementar el contador por cada imagen procesada
		contador=$((contador + 1))
        
    fi
done

# Calcular el tiempo total transcurrido
tiempo_fin=$(date +%s)
tiempo_total=$((tiempo_fin - tiempo_inicio))

# Convertir tiempo total a formato hh:mm:ss
horas=$((tiempo_total / 3600))
minutos=$(( (tiempo_total % 3600) / 60 ))
segundos=$((tiempo_total % 60))

# Mostrar el total de imágenes procesadas y el tiempo que tomó
echo "Total de imágenes procesadas: $contador"
# Formatear la salida
printf "Tiempo total transcurrido: %02d:%02d:%02d\n" $horas $minutos $segundos

Descripción del Script: clasificar_imagen_v5.py

El script clasificar_imagen_v5.py carga la imagen y define la región inferior de la misma para segmentación basada en color y análisis de luminosidad promedio. A continuación, se detallan las funcionalidades del script:

1. Segmentación basada en color en la región inferior:
   • Identifica ciertos tonos o rangos de color en la región inferior de la imagen.
2. Cálculo de la luminosidad promedio:
   • Calcula la luminosidad promedio de la región inferior y de la región donde se detecta un color específico.
   • Basándose en la luminosidad promedio y la presencia de color específico, decide si la marca de agua debe ser blanca o negra.
3. Bibliotecas utilizadas:
   • cv2 (OpenCV): Biblioteca popular para la visión por computadora y el procesamiento de imágenes.
   • NumPy: Biblioteca fundamental para computación científica y numérica en Python.

El script imprime el resultado (blanco o negro) junto con la luminosidad promedio de la región inferior.

 
#!/usr/bin/env python

# --------------------------------------------------------------------------------------------------------------------------------------
# File: clasificar_imagen_v5.py
# By Julio Alberto Lascano http://drcalambre.blogspot.com/
#________          _________        .__                ___.                  
#\______ \_______  \_   ___ \_____  |  | _____    _____\_ |_________   ____  
# |    |  \_  __ \ /    \  \/\__  \ |  | \__  \  /     \| __ \_  __ \_/ __ \ 
# |    `   \  | \/ \     \____/ __ \|  |__/ __ \|  Y Y  \ \_\ \  | \/\  ___/ 
#/_______  /__|     \______  (____  /____(____  /__|_|  /___  /__|    \___  >
#        \/                \/     \/          \/      \/    \/            \/ 
# --------------------------------------------------------------------------------------------------------------------------------------
# Last modified:2024-05-30
# --------------------------------------------------------------------------------------------------------------------------------------
# Descripción del script: clasificar_imagen_v5.py
# Carga la imagen y define la región inferior de la misma.
# --------------------------------------------------------------------------------------------------------------------------------------
# Segmentación basada en color en la región inferior y luminosidad promedio de la región inferior:
# --------------------------------------------------------------------------------------------------------------------------------------
# Realiza una segmentación basada en color en la región inferior para identificar ciertos tonos o rangos de color.
# Calcula la luminosidad promedio de la región inferior y de la región donde se detecta un color específico.
# Basándose en la luminosidad promedio y la presencia de color específico, decide si la marca de agua debe ser blanca o negra.
# Imprime el resultado (blanco o negro) junto con la luminosidad promedio de la región inferior.
# --------------------------------------------------------------------------------------------------------------------------------------
# cv2
# --------------------------------------------------------------------------------------------------------------------------------------
# La biblioteca cv2, o OpenCV (Open Source Computer Vision Library), es una biblioteca popular de código abierto diseñada para 
# la visión por computadora y el procesamiento de imágenes. Ofrece una amplia gama de funciones y algoritmos que permiten realizar 
# una variedad de tareas relacionadas con el procesamiento de imágenes y la visión por computadora.
# --------------------------------------------------------------------------------------------------------------------------------------
# NumPy
# --------------------------------------------------------------------------------------------------------------------------------------
# NumPy es una biblioteca fundamental en Python para computación científica y numérica. Proporciona un objeto de matriz 
# multidimensional, junto con una variedad de funciones para operar en estas matrices.
# NumPy se utiliza específicamente para calcular la media (np.mean) y la desviación estándar (np.std) de la luminosidad del color detectado
# en la región inferior de la imagen. Estas estadísticas se utilizan luego para ajustar dinámicamente el valor del umbral para decidir si 
# aplicar una marca de agua blanca o negra.
# --------------------------------------------------------------------------------------------------------------------------------------


import sys
import cv2
import numpy as np

# Función para calcular la luminosidad promedio de una región de la imagen
def calcular_luminosidad_promedio(region):
    luminosidad = cv2.mean(region)[0]
    return luminosidad

def main():
    # Verificar que se proporcionen los argumentos necesarios
    if len(sys.argv) < 3:
        print("Uso: clasificar_imagen_v5.py  ")
        sys.exit(1)

    # Ruta de la imagen proporcionada como argumento
    ruta_imagen = sys.argv[1]

    # Definir el factor de escala proporcionado como argumento
    try:
        FACTOR_ESCALA = float(sys.argv[2])
    except ValueError:
        print("El factor de escala debe ser un número.")
        sys.exit(1)

    # Cargar la imagen
    img = cv2.imread(ruta_imagen)

    # Verificar si la imagen se cargó correctamente
    if img is None:
        print("Error al cargar la imagen. Verifique la ruta y el formato del archivo.")
        sys.exit(1)

    # Obtener dimensiones de la imagen
    alto, ancho, _ = img.shape

    # Calcular el tamaño del cuadrante a analizar
    #
    # FACTOR_ESCALA se usa para determinar el tamaño del cuadrante a analizar en la imagen. Ese cuadrante es el que ocupara la marca de agua.
    # alto_cuadrante y ancho_cuadrante se calculan como una fracción de las dimensiones de la imagen.
    #
    # Región Inferior Centrada:
    # Las coordenadas (y_inicio, x_inicio) se calculan para centrar el cuadrante horizontalmente y posicionarlo en la parte inferior de la imagen.
    #
    # Segmentación y Análisis:
    # La segmentación basada en color y el cálculo de luminosidad promedio se realizan en esta región inferior centrada.
    # Esto asegura que el análisis se realice en la parte de la imagen donde estará la marca de agua, considerando su posición centrada y tamaño relativo basado en el factor de escala.

    alto_cuadrante = int(alto * FACTOR_ESCALA * 2)
    ancho_cuadrante = int(ancho * FACTOR_ESCALA * 2)

    # Definir las coordenadas del cuadrante inferior centrado
    y_inicio = alto - alto_cuadrante  # Inicio del cuadrante inferior
    x_inicio = (ancho - ancho_cuadrante) // 2  # Centrar horizontalmente

    # Extraer el cuadrante inferior centrado de la imagen
    region_inferior = img[y_inicio:, x_inicio:x_inicio + ancho_cuadrante]

    # Segmentación basada en color en la región inferior de la imagen
    region_inferior_hsv = cv2.cvtColor(region_inferior, cv2.COLOR_BGR2HSV)
    lower_color = (0, 50, 50)  # Define el rango inferior de color HSV
    upper_color = (20, 255, 255)  # Define el rango superior de color HSV
    mask_color = cv2.inRange(region_inferior_hsv, lower_color, upper_color)

    # Calcular la luminosidad promedio del color detectado en la región inferior
    luminosidad_color = calcular_luminosidad_promedio(mask_color)

    # Calcular estadísticas sobre la luminosidad promedio del color
    luminosidad_color_mean = np.mean(luminosidad_color)
    luminosidad_color_std = np.std(luminosidad_color)

    # Ajustar dinámicamente el valor de umbral_color
    umbral_color = luminosidad_color_mean + 2 * luminosidad_color_std  # Por ejemplo, media + 2 * desviación estándar

    # Calcular la luminosidad promedio de la región inferior
    luminosidad_region_inferior = calcular_luminosidad_promedio(region_inferior)

    # Decidir el color de la marca de agua basado en la luminosidad promedio y el umbral dinámico
    
    # El valor de 127 se utiliza como umbral de luminosidad. Este valor se elige arbitrariamente como punto de corte 
    # para distinguir entre regiones relativamente oscuras y regiones relativamente claras en la imagen. 
    # Un valor de 127 corresponde aproximadamente a la mitad del rango de 0 a 255 en el espacio de color de escala de grises, 
    # donde 0 representa el negro absoluto y 255 representa el blanco absoluto.
    # Si la luminosidad promedio de la región inferior es menor o igual a 127, se considera que esta región es relativamente 
    # oscura. En este caso, se asume que una marca de agua blanca sería más visible y contrastaría mejor con el fondo oscuro. 
    # Por lo tanto, se decide aplicar una marca de agua blanca.
    #
    # La variable luminosidad_color_mean contiene la luminosidad promedio del color detectado en la región inferior de la imagen. 
    # Esta región se segmenta en función de ciertos tonos o rangos de color específicos, como se especifica en el código.
    #
    # Umbral dinámicamente ajustado (umbral_color): En lugar de utilizar un umbral estático, como en el caso 
    # de luminosidad_region_inferior <= 127, aquí se calcula y utiliza un umbral dinámico basado en las estadísticas de la 
    # luminosidad del color detectado en la región inferior. Este umbral puede ajustarse según las características específicas de 
    # la imagen en términos de iluminación, tonos de color, etc.
    #
    # Decisión de aplicar marca de agua blanca o negra: Si la luminosidad promedio del color detectado en la región inferior es menor 
    # o igual al umbral dinámicamente ajustado (umbral_color), se considera que esta región es relativamente oscura en términos de color. 
    # En este caso, se asume que una marca de agua blanca sería más visible y contrastaría mejor con el fondo oscuro. 
    # Por lo tanto, se decide aplicar una marca de agua blanca.
    #
    # Adaptabilidad del umbral dinámico: Al calcular el umbral dinámicamente en función de las estadísticas de la luminosidad del color 
    # detectado, se mejora la adaptabilidad del proceso de decisión a diferentes condiciones de iluminación y variaciones en los tonos de
    # color de la imagen.
    
    if luminosidad_region_inferior <= 127 and luminosidad_color_mean <= umbral_color:
        resultado_color = "blanco"
    else:
        resultado_color = "negro"

    # Imprimir el resultado y la luminosidad
    print(resultado_color, luminosidad_region_inferior)

if __name__ == "__main__":
    main()

Uso de la Desviación Estándar

La desviación estándar mide qué tan dispersos están los valores de luminosidad. Si todos los valores son muy similares, la desviación estándar será baja; si hay mucha variación, será alta.

Se calcula un "umbral" dinámico usando la desviación estándar. Este umbral es una combinación de la luminosidad promedio del color y la desviación estándar de esa luminosidad.

Conclusión

La combinación de estos dos scripts proporciona una solución robusta y eficiente para aplicar marcas de agua a un gran número de imágenes de manera automatizada. Utilizando Bash y Python, se puede asegurar que cada imagen reciba una marca de agua que se ajuste perfectamente a sus características específicas, mejorando así la presentación y protección de sus imágenes digitales.

Dependencias

- **Imagemagick**:Paquete de software para manipular y editar imágenes.

- **bc**: es una calculadora de precisión arbitraria en Unix-like.

- **OpenCV (`cv2`)**: una popular biblioteca de código abierto diseñada para visión por computadora y procesamiento de imágenes.

- **NumPy**: Biblioteca fundamental en Python para computación científica y numérica. Se utiliza para calcular estadísticas como la media y la desviación estándar de la luminosidad para la detección de color en la región inferior de la imagen.

 
antix1@antix1:~ sudo apt-get install imagemagick bc
antix1@antix1:~ sudo apt-get install python3-opencv
antix1@antix1:~ sudo apt-get install python3-numpy

Los escript se pueden descargar desde mi repositorio en GitHub:

https://github.com/DrCalambre/watermark 

Entradas relacionadas tambien en este blog:

Como crear una Marca de Agua con GIMP.

Como crear una Marca de Agua con GIMP

Antes de continuar, una breve descripción: 

¿Que son los canales alfa?

Imagínate que estás coloreando un dibujo en una hoja de papel. Tienes los colores y los usas para pintar las partes del dibujo que quieras. Ahora, imagina que tienes una hoja especial que no solo te permite colorear, sino que también te permite decidir qué partes del dibujo serán visibles y qué partes serán transparentes, como si pudieras hacer "agujeros" en la hoja para ver a través de ellos.

En GIMP, esta hoja especial se llama "canal alfa". El canal alfa es una especie de capa extra que cada imagen puede tener, y su función principal es controlar la transparencia de la imagen.

Colores y Transparencia: 

En una imagen normal, cada píxel tiene colores (rojo, verde y azul). Con el canal alfa, cada píxel también tiene una información adicional que dice cuán transparente es ese píxel. Esta transparencia puede ir desde completamente opaco (no puedes ver a través) hasta completamente transparente (puedes ver lo que está detrás).

Ejemplo Práctico: 

Imagina que tienes una foto de una manzana y quieres ponerla en un fondo diferente. Usando el canal alfa, puedes borrar el fondo alrededor de la manzana, haciendo que solo la manzana sea visible. Cuando pones esta imagen en otro fondo, solo verás la manzana, y el fondo original será transparente, dejando ver el nuevo fondo.

En resumen, el canal alfa es como una capa mágica que te permite controlar la transparencia de cada parte de tu imagen, permitiendo crear efectos de superposición y mezclas que serían imposibles con imágenes opacas

Paso 1: Preparar el Texto de la Marca de Agua

1. Abrir GIMP: Inicia GIMP en tu ordenador.

Gimp

2. Crear un Nuevo Documento:

• Ve a Archivo > Nuevo....
• Elige las dimensiones deseadas para tu marca de agua. Por ejemplo, 800x300 píxeles.

Crear imágen nueva

3. Añadir Texto:

Selecciona la herramienta de texto (la letra "A" en la caja de herramientas).

Herramienta de texto

Haz clic en el área de trabajo y escribe el texto de tu marca de agua.

Escribe el texto

Ajusta el tamaño, fuente y color del texto según tus preferencias.

Paso 2: Hacer Transparente el Fondo del Texto

Agregar una Capa Alfa:


En la ventana de Capas, haz clic derecho en la capa de fondo y selecciona Añadir Canal Alfa.

Añadir canal alfa

Añadir canal alfa

Eliminar el Fondo:


Selecciona la herramienta de selección por color (el icono de la varita mágica).

Varita mágica

Haz clic en el fondo blanco para seleccionarlo.

clic en el fondo blanco

Presiona Supr o Delete para eliminar el fondo, haciendo que sea transparente.

Suprimir el fondo

Paso 3: Ajustar la Opacidad

Bajar la Opacidad del Texto:

En la ventana de Capas, ajusta la opacidad de la capa de texto a alrededor del 30-50%, para que la marca de agua no sea demasiado intrusiva.

Ajustar opacidad 50%

Ajustar opacidad 50%

Paso 4: Exportar la Marca de Agua

Guardar la Imagen:

Ve a Archivo > Exportar Como....

Selecciona el formato PNG para preservar la transparencia (por ejemplo, marca_agua.png).

Haz clic en Exportar y ajusta las configuraciones según sea necesario.

Exportar Como...

Formato png

Exportar

Les dejo algunas fuentes (fonts) que utilice del texto que se pueden instalar y son adecuadas para estas marcas de agua:

Great Vibes:

Es una fuente cursiva elegante y fluida, que transmite una sensación de sofisticación y personalización, ideal para firmas y marcas personales.

Playfair Display:

Esta fuente serif tiene un aire clásico y profesional, manteniendo una elegancia que puede complementar muy bien las fotografías naturales y paisajes.

Cinzel:

Inspirada en las inscripciones romanas, Cinzel es una fuente serif que da una sensación de atemporalidad y formalidad, adecuada para la majestuosidad de las montañas.

Raleway:

Una fuente sans-serif moderna y elegante que es muy versátil y puede dar un toque contemporáneo sin perder la profesionalidad.

Montserrat:

Esta es una fuente sans-serif geométrica que es moderna y clara, lo que la hace ideal para marcas limpias y profesionales.

Dancing Script:

Es una fuente manuscrita que tiene un aspecto casual y amigable, perfecta si quieres darle un toque más personal y artístico.

Puedes descargar mas fuentes desde sitios confiable como Google Fonts o dafont.com.

para instalarlas puedes usar un gestor tipografico

Gestor tipográfico de antiX (font-manager)