PPTX DOCX XLSX PDF ODP
Aspose.Imaging pour Python
TGA

Utilisez Python pour appliquer des filtres aux images TGA

Créez des applications Python pour filtrer les images et les photos TGA via les API du serveur

 

Aspose.Imaging pour Python Aspose.Imaging pour Python

Overview

Comment filtrer les images et les photos TGA avec Python

Chaque photo bien capturée comporte un potentiel d’amélioration, une chance d’évoluer vers quelque chose de complètement distinct et d’émerger comme une création unique en son genre. Les filtres constituent un outil polyvalent d’amélioration des images et des photos, vous permettant d’améliorer de manière sélective la netteté, d’introduire du flou ou d’éliminer les artefacts de couleur pour un résultat vraiment distinctif. Expérimentez avec des effets d’image individuellement ou en combinaison pour mélanger parfaitement les dégradés de couleurs, éliminer le bruit indésirable et améliorer la netteté des bords des objets de votre photo. Pour appliquer ces filtres d’image aux fichiers TGA, nous utiliserons Aspose.Imaging for Python via .NET API qui est une API de manipulation et de conversion d’images riche en fonctionnalités, puissante et facile à utiliser pour la plate-forme Python. Vous pouvez l’installer en utilisant la commande suivante à partir de votre commande système.

La ligne de commande système

>> pip install aspose-imaging-python-net

Étapes pour filtrer les TGA via Python

Vous avez besoin de aspose-imaging-python-net pour essayer le workflow suivant dans votre propre environnement.

  • Charger les fichiers TGA avec la méthode Image.Load
  • Filtrer les images ;
  • Enregistrer l’image compressée sur le disque au format pris en charge par Aspose.Imaging

Configuration requise

Aspose.Imaging pour Python est pris en charge sur tous les principaux systèmes d’exploitation. Assurez-vous simplement que vous disposez des prérequis suivants.

  • Microsoft Windows/Linux avec .NET Core Runtime.
  • Gestionnaire de packages Python et PyPi.
 

Filtrer les images TGA - 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()
view raw filter-images.py hosted with ❤ by GitHub
 

    • À propos de l'API Aspose.Imaging pour Python

    Aspose.Imaging API est une solution de traitement d’images pour créer, modifier, dessiner ou convertir des images (photos) au sein d’applications. Il offre : le traitement d’image multiplateforme, y compris, mais sans s’y limiter, les conversions entre différents formats d’image (y compris le traitement d’image multipage ou multicadre uniforme), les modifications telles que le dessin, l’utilisation de primitives graphiques, les transformations (redimensionner, recadrer, retourner et faire pivoter , binarisation, niveaux de gris, ajustement), fonctionnalités avancées de manipulation d’images (filtrage, tramage, masquage, redressement) et stratégies d’optimisation de la mémoire. C’est une bibliothèque autonome et ne dépend d’aucun logiciel pour les opérations d’image. On peut facilement ajouter des fonctionnalités de conversion d’image hautes performances avec des API natives dans les projets. Ce sont des API sur site 100 % privées et les images sont traitées sur vos serveurs.

    Filtrer les TGA via l’application en ligne

    Filtrez les documents TGA en visitant notre site Web Live Demos . La démo en direct présente les avantages suivants

      Pas besoin de télécharger ou de configurer quoi que ce soit
      Pas besoin d'écrire de code
      Téléchargez simplement vos fichiers TGA et appuyez sur le bouton "Filtrer maintenant"
      Obtenez instantanément le lien de téléchargement du fichier résultant

    TGA Qu'est-ce que TGA Format de fichier

    Truevision TGA, souvent appelé TARGA, est un format de fichier graphique raster créé par Truevision Inc. (qui fait maintenant partie d'Avid Technology). C'était le format natif des cartes TARGA et VISTA, qui étaient les premières cartes graphiques pour PC compatibles IBM à prendre en charge l'affichage Highcolor/truecolor.

    Lire la suite

    Autres formats de filtre pris en charge

    En utilisant Python, on peut facilement filtrer différents formats, y compris.

    APNG (Graphiques de réseau portables animés)
    BMP (Image bitmap)
    ICO (Icône Windows)
    JPG (Groupe mixte d'experts photographiques)
    JPEG (Groupe mixte d'experts photographiques)
    DIB (Bitmap indépendant du périphérique)
    DICOM (Imagerie numérique et communications)
    DJVU (Format graphique)
    DNG (Image d'appareil photo numérique)
    EMF (Format de métafichier amélioré)
    EMZ (Métafichier amélioré compressé Windows)
    GIF (Format d'échange graphique)
    JP2 (JPEG 2000)
    J2K (Image compressée en ondelettes)
    PNG (Portable Network Graphics)
    TIFF (Format d'image balisé)
    TIF (Format d'image balisé)
    WEBP (Image Web raster)
    WMF (Métafichier Microsoft Windows)
    WMZ (Skin du lecteur Windows Media compressé)
    SVG (Image Vectorielle)
    AVIF
    EPS (Langage PostScript encapsulé)
    CDR (Image de dessin vectoriel)
    CMX (Image d'échange Corel)
    OTG (Norme OpenDocument)
    ODG (Format de dessin Apache OpenOffice)