Mostrar los tags: ag

Mostrando del 1 al 10 de 240 coincidencias
<<>>
Se ha buscado por el tag: ag
Imágen de perfil

Generador de gifs a partir de video (nueva version)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 10 de Julio del 2026 por Antonio (77 códigos) (Publicado el 29 de Enero del 2024)
26.586 visualizaciones desde el 29 de Enero del 2024
Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)

PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

imagge
Imágen de perfil

Transformada de Radon


Java

Publicado el 2 de Enero del 2026 por Francisco Javier Rojas Garrido (27 códigos)
476 visualizaciones desde el 2 de Enero del 2026
Comparto mi primera versión Java de la transformada de Radon para imágenes.

La transformada de Radon es una transformada que transforma una función escalar del dominio cartesiano al dominio (ρ, θ).

La versión que comparto, transforma una función escalar en el plano (dos variables cartesianas, (x, y)).
Más en concreto trabaja con imágenes rectangulares.
La función que se maneja es el color de los píxeles en su forma de escala de grises.

Cada (ρ, θ) del dominio transformado representa una línea (en un formato parecido a coordenadas polares, desde el centro de la imagen).
El valor de la transformada para una coordenada (ρ, θ), resulta de la suma de los valores de los píxeles (luminancia) sobre esa línea dentro de la imagen.

El dominio de ρ es simétrico respecto al centro de coordenadas (va de -ρmax a ρmax).
El dominio de θ va de [0 a 180º) en grados sexagesimales, o de [0, pi) en radianes (media vuelta).

Esta transformada puede servir, por ejemplo, para detectar líneas largas dentro de una imagen, si se aplica sobre una imagen tipo Canny (detección de bordes) de tu imagen objetivo.
En esas condiciones, una línea en la imagen original resultará en una línea con mucha luminancia en la imagen tipo Canny, y el valor de la transformada de Radon en esa línea (representada por una (ρ, θ)), será muy alto.

Así pues, si tenemos una imagen negra (luminancia 0) con las aristas de un cuadrado pintadas en blanco (luminancia 1), la transformada de Radon dará un valor muy alto sobre las (ρ, θ) que representan a las líneas del cuadrado.

En un problema real no es tan fácil la detección, pero bueno, esta transformada es sólo una herramienta más.
Para detectar líneas, se puede hacer de otras maneras (creo que el algoritmo de HoughLines es más interesante para esa tarea, que creo que implementa la librería de openCV)

Puedes ver conocer más sobre la teoría de esta transformada en este enlace a la wikipedia: https://es.wikipedia.org/wiki/Transformada_de_Radon

Si la librería ha logrado captar tu atención, a lo mejor te apetece darle un vistazo a la página de mi sitio web donde la comparto:
https://www.frojasg1.com:8443/downloads_web/web/html/radon.html?origin=lawebdelprogramador


radonCollage.540x374
radonImage.540x374
Imágen de perfil

Colector de links


Python

Actualizado el 15 de Marzo del 2025 por Antonio (77 códigos) (Publicado el 6 de Marzo del 2022)
5.958 visualizaciones desde el 6 de Marzo del 2022
Aplicación para guardar accesos directos a internet (que se guardan en un archivo 'json' que se genera al ejecutar el programa por primera vez), mediante la introducción de la URL en la entrada superior (o su copia mediante el botón 'IMPORT NEW LINK'). El nuevo acceso se guarda mediante el botón "SAVE LINK AS:" que abrirá una ventana pidiendo el nombre del nuevo acceso. Una vez guardado el acceso, se podrá acceder a la correspondiente página seleccionando, en la lista, el elemento guardado y clicando en el botón 'ACCESS' (admite selección normal y múltiple). También permite la eliminación la totalidad de los link o solo los seleccionados. También permite la búsqueda por nombre entre los accesos guardados. El botón "SAVE LIST" generará un archivo de texto con los nombres de enlace y sus correspondientes URLs asociadas, que estén almacenados en el archivo JSON.
PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.
LNKC
Imágen de perfil

Generador de ternas pitagóricas


Basic

Publicado el 27 de Febrero del 2025 por Ángel (5 códigos)
1.714 visualizaciones desde el 27 de Febrero del 2025
A partir de dos números enteros positivos genera una terna pitagórica.
Genera un gráfico del triángulo rectángulo situando los valores de la terna pitagórica.
Imágen de perfil

Suavizado de imagen en archivos de vídeo por 'Filtrado bilateral', (aplicación en línea de comandos)


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 23 de Mayo del 2024 por Antonio (77 códigos) (Publicado el 20 de Marzo del 2023)
8.353 visualizaciones desde el 20 de Marzo del 2023
Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.

ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)

PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS
bvf
bvf2
bvf3
bvf4
Imágen de perfil

ImageDataGenerator.


Python

Publicado el 23 de Enero del 2024 por Hilario (145 códigos)
662 visualizaciones desde el 23 de Enero del 2024
palomas
descarga

********************************************************************************************************************
En este breve ejercicio, pretendo explicar algunas dudas sobre la utilizacion de ImageDataGenerator.
Esta función se utiliza en las redes convolucionales, para nodificar los parámetros o apariencia de las imagenes
utilizadas para el training, con el propósito principal de mejorar el rendimiento y la generalización del modelo mediante el aumento de datos y la normalización.

Aquí están los objetivos clave:
--------------------------------------

Aumento de Datos para Mejor Generalización:

El aumento de datos implica aplicar transformaciones aleatorias a las imágenes durante el entrenamiento, como rotación, cambio de escala, volteo horizontal, etc. Este proceso aumenta la diversidad del conjunto de datos, permitiendo que el modelo vea variaciones de las imágenes originales. Como resultado, la CNN se vuelve más robusta y generaliza mejor a nuevas imágenes que puede encontrar durante la inferencia.

Prevención de Sobreajuste (Overfitting):

El sobreajuste ocurre cuando un modelo aprende demasiado bien los detalles específicos del conjunto de entrenamiento y tiene dificultades para generalizar a datos no vistos. El aumento de datos ayuda a prevenir el sobreajuste al introducir variaciones artificiales en las imágenes de entrenamiento. Esto es crucial cuando el conjunto de datos es relativamente pequeño.

Normalización para Facilitar el Entrenamiento:

La normalización de píxeles (escalando valores a un rango específico, como [0, 1]) facilita el proceso de entrenamiento. Al tener valores de píxeles en un rango más pequeño, los gradientes durante el entrenamiento son más estables, lo que puede llevar a una convergencia más rápida del modelo.

Manejo Eficiente de Grandes Conjuntos de Datos:

Cuando trabajas con grandes conjuntos de datos que no caben completamente en la memoria, ImageDataGenerator permite cargar y procesar las imágenes de manera eficiente en lotes durante el entrenamiento. Esto es esencial para hacer frente a conjuntos de datos de tamaño considerable.
En resumen, ImageDataGenerator contribuye significativamente a mejorar la capacidad de generalización de una CNN, a hacer que el modelo sea más robusto frente a variaciones en los datos y a facilitar el proceso de entrenamiento, especialmente cuando se trata de conjuntos de datos grandes.

********************************************************************************************************************
Un ejemplo típico de argumentos pasados a ImageDataGenerator sería el siguiente:

datagen = ImageDataGenerator(
rescale=1./255, # Normalización
rotation_range=20, # Rango de rotación aleatoria
width_shift_range=0.2, # Rango de cambio horizontal aleatorio
height_shift_range=0.2, # Rango de cambio vertical aleatorio
shear_range=0.2, # Rango de cizallamiento aleatorio
zoom_range=0.2, # Rango de zoom aleatorio
horizontal_flip=True # Volteo horizontal aleatorio
)

********************************************************************************************************************
********************************************************************************************************************
Este programa ha sido editado y ejecutadoi con Google Colab.
El archivo de jemplo estaba alojado en Drive de Google Colab.


---------------------------------------------------------------------------------------------------------------------------
Imágen de perfil

Visualización de la imagen normalizada.


Python

Publicado el 22 de Enero del 2024 por Hilario (145 códigos)
537 visualizaciones desde el 22 de Enero del 2024
Sencillo_Concep_Pixel_Aula_28.py
**********************

Figure_1
Figure_12

********************************************************************************************************************

Con este sencillo y diminuto ejercicio, tratamos de explicar algunas dudas conceptuales sobre el tratamiento y comprensión
del funcionamiento de los pixeles. Aula 28.
-----------------------------------------------------------------------------------------------------------------------

Definición de los valores del píxel:
------------------------------------------------
Se especifican los valores de los canales rojo, verde y azul del píxel. En este caso, son [88, 15, 108].

Visualización de la imagen sin normalización:
---------------------------------------------------------------
Se crea una imagen de 1x1 píxeles con los valores de los canales y se muestra directamente. La escala de colores refleja los valores originales sin ajustes.

Normalización de los valores de los canales:
--------------------------------------------------------------
Se normalizan los valores de los canales dividiéndolos por 255.0. Este paso es común en procesamiento de imágenes para asegurarse de que los valores estén en el rango [0, 1].

Visualización de la imagen normalizada:
--------------------------------------------------------
Se crea una nueva imagen con los valores normalizados y se muestra. La escala de colores ahora refleja los valores ajustados al rango [0, 1].

Impresión de la matriz normalizada:
--------------------------------------------------
La matriz normalizada se imprime en la consola. Esto muestra cómo los valores de los canales se han ajustado a la escala [0, 1].

En resumen, el código realiza dos visualizaciones de un píxel: una con los valores de los canales originales y otra después de normalizar esos valores para asegurarse de que estén en un rango comprensible para la visualización de colores.

Salida por consola de los pixels normalizados.


[[0.34509804 0.05882353 0.42352941]]



***********************************************************************************************
Realizado en Plataforma Linux. Ubuntu 20.04.6 LTS
Editado con Sublime text.
Ejecución:python3 Sencillo_Concep_Pixel_Aula_28.py
************************************************************************************************
Imágen de perfil

Programa para aplicación de filtros, en archivos de vídeo.


Python

estrellaestrellaestrellaestrellaestrella(4)
Actualizado el 20 de Noviembre del 2023 por Antonio (77 códigos) (Publicado el 24 de Mayo del 2021)
14.115 visualizaciones desde el 24 de Mayo del 2021
El presente programa se encarga de aplicar filtros sobre los fotogramas de un archivo de video empleando diferentes funciones. El programa realiza el filtrado frame a frame para a continuación generar un nuevo video con la secuencia de frames procesados (aplicando el frame rate del vídeo original). También usa el software "ffmpeg" para copiar el audio del vídeo original y añadirlo al vídeo resultante.

USO: Primeramente seleccionaremos el vídeo a filtrar mediante el botón "SEARCH". Una vez seleccionado iniciaremos el proceso con "START FILTERING" con el que empezaremos seleccionando la ubicación del nuevo vídeo, para a continuación iniciar el proceso (NOTA: La ruta del directorio de destino no deberá contener espacios en blanco). El proceso de filtrado podrá ser cancelado medinate el botón "CANCEL".
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

vf