Utilice Python para aplicar filtros para imágenes JPG
Cree aplicaciones Python para filtrar imágenes y fotos JPG a través de las API del servidor
Aspose.Imaging para Python
Overview
Cómo filtrar imágenes y fotos de JPG con Python
Cada fotografía bien capturada conlleva potencial de mejora, una oportunidad de evolucionar hacia algo completamente distinto y emerger como una creación única. Los filtros sirven como una herramienta versátil para mejorar imágenes y fotografías, permitiéndole mejorar selectivamente la nitidez, introducir desenfoque o eliminar artefactos de color para obtener un resultado verdaderamente distintivo. Experimente con efectos de imagen individualmente o en combinación para combinar perfectamente degradados de color, eliminar ruidos no deseados y mejorar la nitidez de los bordes de los objetos en su fotografía. Para aplicar estos filtros de imagen a archivos JPG, utilizaremos Aspose.Imaging for Python via .NET API que es una API de conversión y manipulación de imágenes rica en funciones, potente y fácil de usar para la plataforma Python. Puede instalarlo usando el siguiente comando desde el comando de su sistema.
La línea de comando del sistema
>> pip install aspose-imaging-python-net
Pasos para filtrar JPG a través de Python
Necesita aspose-imaging-python-net para probar el siguiente flujo de trabajo en su propio entorno.
- Cargue archivos JPG con el método Image.Load
- Filtrar imágenes;
- Guarde la imagen comprimida en el disco en el formato compatible con Aspose.Imaging
Requisitos del sistema
Aspose.Imaging para Python es compatible con todos los principales sistemas operativos. Solo asegúrese de tener los siguientes requisitos previos.
- Microsoft Windows/Linux con .NET Core Runtime.
- Gestor de paquetes Python y PyPi.
Filtrar imágenes JPG - Python
| from aspose.imaging import RasterImage, Image, IMultipageImage, Rectangle | |
| from aspose.imaging.imagefilters.filteroptions import * | |
| from aspose.imaging.imageoptions import PngOptions | |
| from aspose.pycore import as_of, is_assignable | |
| import os | |
| if 'TEMPLATE_DIR' in os.environ: | |
| templates_folder = os.environ['TEMPLATE_DIR'] | |
| else: | |
| templates_folder = r"C:\Users\USER\Downloads\templates" | |
| delete_output = 'SAVE_OUTPUT' not in os.environ | |
| def delete_file(file): | |
| if delete_output: | |
| os.remove(file) | |
| def small_rectangular_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), SmallRectangularFilterOptions()), "smallrectangular") | |
| def big_rectangular_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), BigRectangularFilterOptions()), "bigrectangular") | |
| def sharpen_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), SharpenFilterOptions()), "sharpen") | |
| def motion_wiener_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), MotionWienerFilterOptions(20, 2, 0)), "motionwiener") | |
| def bilateral_smoothing_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), BilateralSmoothingFilterOptions()), "bilateralsmoothing") | |
| def gauss_blur_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), GaussianBlurFilterOptions(5, 4)), "gaussblur") | |
| def gauss_wiener_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), GaussWienerFilterOptions(5, 5)), "gausswiener") | |
| def median_filter(): | |
| filter_images(lambda image: image.filter(Rectangle(image.width // 6, image.height // 6, image.width * 2 // 3, image.height * 2 // 3), MedianFilterOptions(20)), "median") | |
| def filter_images(do_filter, filter_name): | |
| obj_init = [] | |
| obj_init.append("jpg") | |
| obj_init.append("png") | |
| obj_init.append("bmp") | |
| obj_init.append("apng") | |
| obj_init.append("dicom") | |
| obj_init.append("jp2") | |
| obj_init.append("j2k") | |
| obj_init.append("tga") | |
| obj_init.append("webp") | |
| obj_init.append("tiff") | |
| obj_init.append("gif") | |
| obj_init.append("ico") | |
| raster_formats = obj_init | |
| obj_init2 = [] | |
| obj_init2.append("svg") | |
| obj_init2.append("otg") | |
| obj_init2.append("odg") | |
| obj_init2.append("eps") | |
| obj_init2.append("wmf") | |
| obj_init2.append("emf") | |
| obj_init2.append("wmz") | |
| obj_init2.append("emz") | |
| obj_init2.append("cmx") | |
| obj_init2.append("cdr") | |
| vector_formats = obj_init2 | |
| all_formats = raster_formats | |
| all_formats.extend(vector_formats) | |
| for format_ext in all_formats: | |
| input_file = os.path.join(templates_folder, f"template.{format_ext}") | |
| is_vector_format = format_ext in vector_formats | |
| if is_vector_format: | |
| input_file = rasterize_vector_image(format_ext, input_file) | |
| output_file = os.path.join(templates_folder, f"{filter_name}_{format_ext}.png") | |
| print(format_ext) | |
| # explicit type casting from Image to RasterImage | |
| with as_of(Image.load(input_file), RasterImage) as image: | |
| multi_page = None | |
| # if image implements an IMultipageImage interface | |
| if is_assignable(image, IMultipageImage): | |
| multi_page = as_of(image, IMultipageImage) | |
| if multi_page is not None and multi_page.page_count > 1: | |
| page_index = 0 | |
| for page in multi_page.pages: | |
| file_name = f"{filter_name}_page{page_index}_{format_ext}.png" | |
| do_filter(as_of(page, RasterImage)) | |
| page.save(templates_folder + file_name, PngOptions()) | |
| delete_file(templates_folder + file_name) | |
| page_index += 1 | |
| else: | |
| do_filter(image) | |
| image.save(output_file, PngOptions()) | |
| delete_file(output_file) | |
| if is_vector_format: | |
| delete_file(input_file) | |
| def rasterize_vector_image(format_ext, input_file): | |
| output_file = os.path.join(templates_folder, "rasterized.{format_ext}.png") | |
| with Image.load(input_file) as image: | |
| image.save(output_file, PngOptions()) | |
| return output_file | |
| # run | |
| median_filter() | |
Acerca de Aspose.Imaging para Python API
Aspose.Imaging API es una solución de procesamiento de imágenes para crear, modificar, dibujar o convertir imágenes (fotos) dentro de las aplicaciones. Ofrece: procesamiento de imágenes multiplataforma, que incluye, entre otros, conversiones entre varios formatos de imagen (incluido el procesamiento uniforme de imágenes de varias páginas o varios cuadros), modificaciones como dibujar, trabajar con primitivas gráficas, transformaciones (redimensionar, recortar, voltear y rotar , binarización, escala de grises, ajuste), funciones avanzadas de manipulación de imágenes (filtrado, difuminado, enmascaramiento, corrección del sesgo) y estrategias de optimización de la memoria. Es una biblioteca independiente y no depende de ningún software para las operaciones de imagen. Uno puede agregar fácilmente funciones de conversión de imágenes de alto rendimiento con API nativas dentro de los proyectos. Estas son API locales 100 % privadas y las imágenes se procesan en sus servidores.Filtre JPG a través de la aplicación en línea
Filtre los documentos JPG visitando nuestro [sitio web de demostraciones en vivo] ( https://products.aspose.app/imaging/image-Filter) . La demostración en vivo tiene los siguientes beneficios
JPG Qué es JPG Formato de archivo
Un JPEG es un tipo de formato de imagen que se guarda mediante el método de compresión con pérdida. La imagen de salida, como resultado de la compresión, es un equilibrio entre el tamaño de almacenamiento y la calidad de la imagen. Los usuarios pueden ajustar el nivel de compresión para lograr el nivel de calidad deseado y al mismo tiempo reducir el tamaño de almacenamiento. La calidad de la imagen se ve afectada de manera insignificante si se aplica una compresión de 10:1 a la imagen. Cuanto mayor sea el valor de compresión, mayor será la degradación de la calidad de la imagen.
Leer másOtros formatos de filtro admitidos
Usando Python, uno puede filtrar fácilmente diferentes formatos, incluidos.