Utilisez Python pour la compression d’images CDR
Créez des applications Python pour compresser des images et des photos CDR via les API du serveur
Aspose.Imaging pour Python
Overview
Comment compresser des images et des photos CDR avec Python
L’adaptation des images pour la publication implique non seulement des processus créatifs mais également des ajustements techniques, tels que la compression des fichiers. En règle générale, les images haute résolution sont nécessaires pour les documents imprimés ou la publicité extérieure, alors que les sites Web peuvent être confrontés à des défis liés à la taille des fichiers. Les paramètres de compression des images peuvent varier en fonction de leur utilisation prévue et de l’endroit où elles seront publiées. Le téléchargement des fichiers volumineux peut prendre un temps considérable, en particulier sur les connexions mobiles, ce qui a un impact sur l’expérience utilisateur globale. Cependant, les images trop compressées peuvent souffrir de flou et de pixellisation visible, ce qui nuit à la qualité visuelle. Atteindre un équilibre entre la taille du fichier et la qualité de l’image nécessite une sélection minutieuse d’algorithmes et de niveaux de compression. Pour compresser des images au format CDR, 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 compresser les CDR via Python
Vous avez besoin de aspose-imaging-python-net pour essayer le workflow suivant dans votre propre environnement.
- Charger les fichiers CDR avec la méthode Image.Load
- Compresser 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.
Compresser les images CDR - Python
| from aspose.imaging.imageoptions import * | |
| from aspose.imaging import * | |
| 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 compress_vector_format_to_svg(): | |
| obj_init = [] | |
| obj_init.append("cdr") | |
| obj_init.append("cmx") | |
| obj_init.append("odg") | |
| obj_init.append("otg") | |
| obj_init.append("eps") | |
| format_exts = obj_init | |
| for format_ext in format_exts: | |
| input_file = os.path.join(templates_folder, f"template.{format_ext}") | |
| output_file = os.path.join(templates_folder, f"compressed_{format_ext.upper()}") | |
| with Image.load(input_file) as image: | |
| def rasterization_options_factory(): | |
| tmp_switch = image.file_format | |
| if tmp_switch == FileFormat.CDR: | |
| obj_init2 = CdrRasterizationOptions() | |
| obj_init2.page_width = float(image.width) | |
| obj_init2.page_height = float(image.height) | |
| return obj_init2 | |
| elif tmp_switch == FileFormat.CMX: | |
| obj_init3 = CmxRasterizationOptions() | |
| obj_init3.page_width = float(image.width) | |
| obj_init3.page_height = float(image.height) | |
| return obj_init3 | |
| elif tmp_switch == FileFormat.ODG: | |
| obj_init4 = OdgRasterizationOptions() | |
| obj_init4.page_width = float(image.width) | |
| obj_init4.page_height = float(image.height) | |
| return obj_init4 | |
| elif tmp_switch == FileFormat.OTG: | |
| obj_init5 = OtgRasterizationOptions() | |
| obj_init5.page_width = float(image.width) | |
| obj_init5.page_height = float(image.height) | |
| return obj_init5 | |
| else: | |
| return None | |
| 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: | |
| # for loop | |
| for_first_step2 = True | |
| page_index = 0 | |
| for page in multi_page.pages: | |
| obj_init6 = SvgOptions() | |
| obj_init6.compress = True | |
| obj_init6.vector_rasterization_options = rasterization_options_factory() | |
| out_file = f"{output_file}_p{page_index + 1}.svgz" | |
| page.save(out_file, obj_init6) | |
| if delete_output: | |
| os.remove(out_file) | |
| page_index += 1 | |
| else: | |
| obj_init7 = SvgOptions() | |
| obj_init7.compress = True | |
| obj_init7.vector_rasterization_options = rasterization_options_factory() | |
| image.save(output_file + ".svgz", obj_init7) | |
| if delete_output: | |
| os.remove(output_file + ".svgz") | |
| def compress_vector_format_to_wmf(): | |
| obj_init8 = [] | |
| obj_init8.append("cdr") | |
| obj_init8.append("cmx") | |
| obj_init8.append("odg") | |
| obj_init8.append("otg") | |
| obj_init8.append("eps") | |
| format_exts = obj_init8 | |
| for format_ext in format_exts: | |
| input_file = os.path.join(templates_folder, f"template.{format_ext}") | |
| output_file = os.path.join(templates_folder, f"compressed_{format_ext.upper()}") | |
| with Image.load(input_file) as image: | |
| def rasterization_options_factory(): | |
| tmp_switch = image.file_format | |
| if tmp_switch == FileFormat.CDR: | |
| obj_init9 = CdrRasterizationOptions() | |
| obj_init9.page_width = float(image.width) | |
| obj_init9.page_height = float(image.height) | |
| return obj_init9 | |
| elif tmp_switch == FileFormat.CMX: | |
| obj_init10 = CmxRasterizationOptions() | |
| obj_init10.page_width = float(image.width) | |
| obj_init10.page_height = float(image.height) | |
| return obj_init10 | |
| elif tmp_switch == FileFormat.ODG: | |
| obj_init11 = OdgRasterizationOptions() | |
| obj_init11.page_width = float(image.width) | |
| obj_init11.page_height = float(image.height) | |
| return obj_init11 | |
| elif tmp_switch == FileFormat.OTG: | |
| obj_init12 = OtgRasterizationOptions() | |
| obj_init12.page_width = float(image.width) | |
| obj_init12.page_height = float(image.height) | |
| return obj_init12 | |
| else: | |
| return None | |
| 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: | |
| # for loop | |
| for_first_step2 = True | |
| page_index = 0 | |
| for page in multi_page.pages: | |
| obj_init13 = WmfOptions() | |
| obj_init13.compress = True | |
| obj_init13.vector_rasterization_options = rasterization_options_factory() | |
| out_file = f"{output_file}_p{page_index + 1}.wmz" | |
| page.save(out_file, obj_init13) | |
| if delete_output: | |
| os.remove(out_file) | |
| else: | |
| obj_init14 = WmfOptions() | |
| obj_init14.compress = True | |
| obj_init14.vector_rasterization_options = rasterization_options_factory() | |
| image.save(output_file + ".wmz", obj_init14) | |
| if delete_output: | |
| os.remove(output_file + ".wmz") | |
| def compress_vector_formats_to_emf(): | |
| obj_init15 = [] | |
| obj_init15.append("cdr") | |
| obj_init15.append("cmx") | |
| obj_init15.append("odg") | |
| obj_init15.append("otg") | |
| obj_init15.append("eps") | |
| format_exts = obj_init15 | |
| for format_ext in format_exts: | |
| input_file = os.path.join(templates_folder, f"template.{format_ext}") | |
| output_file = os.path.join(templates_folder, f"compressed_{format_ext.upper()}") | |
| with Image.load(input_file) as image: | |
| def rasterization_options_factory(): | |
| tmp_switch = image.file_format | |
| if tmp_switch == FileFormat.CDR: | |
| obj_init16 = CdrRasterizationOptions() | |
| obj_init16.page_width = float(image.width) | |
| obj_init16.page_height = float(image.height) | |
| return obj_init16 | |
| elif tmp_switch == FileFormat.CMX: | |
| obj_init17 = CmxRasterizationOptions() | |
| obj_init17.page_width = float(image.width) | |
| obj_init17.page_height = float(image.height) | |
| return obj_init17 | |
| elif tmp_switch == FileFormat.ODG: | |
| obj_init18 = OdgRasterizationOptions() | |
| obj_init18.page_width = float(image.width) | |
| obj_init18.page_height = float(image.height) | |
| return obj_init18 | |
| elif tmp_switch == FileFormat.OTG: | |
| obj_init19 = OtgRasterizationOptions() | |
| obj_init19.page_width = float(image.width) | |
| obj_init19.page_height = float(image.height) | |
| return obj_init19 | |
| else: | |
| return None | |
| 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: | |
| # for loop | |
| for_first_step2 = True | |
| page_index = 0 | |
| for page in multi_page.pages: | |
| obj_init20 = EmfOptions() | |
| obj_init20.compress = True | |
| obj_init20.vector_rasterization_options = rasterization_options_factory() | |
| out_file = f"{output_file}_p{page_index + 1}.emz" | |
| page.save(out_file, obj_init20) | |
| if delete_output: | |
| os.remove(out_file) | |
| else: | |
| obj_init21 = EmfOptions() | |
| obj_init21.compress = True | |
| obj_init21.vector_rasterization_options = rasterization_options_factory() | |
| image.save(output_file + ".emz", obj_init21) | |
| if delete_output: | |
| os.remove(output_file + ".emz") | |
| # run | |
| compress_vector_formats_to_emf() | |
| compress_vector_format_to_svg() | |
| compress_vector_format_to_wmf() |
À 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.Compresser les CDR via l’application en ligne
Compressez les documents CDR en visitant notre site Web Live Demos . La démo en direct présente les avantages suivants
CDR Qu'est-ce que CDR Format de fichier
Un fichier CDR est un fichier d'image de dessin vectoriel créé nativement avec CorelDRAW pour stocker une image numérique encodée et compressée. Un tel fichier de dessin contient du texte, des lignes, des formes, des images, des couleurs et des effets pour la représentation vectorielle du contenu de l'image. Les fichiers CDR peuvent être ouverts avec CorelDRAW comme application principale et peuvent également être convertis en d'autres formats tels que PDF, JPG, PNG, BMP et AI. Il peut être utilisé pour la représentation de diverses données graphiques telles que des brochures, des tabloïds, des enveloppes et des cartes postales. Outre CorelDRAW, d'autres produits Corel tels que Corel Paintshop Pro et la suite graphique CorelDRAW peuvent également ouvrir les formats de fichiers CDR.
Lire la suiteAutres formats de compression pris en charge
En utilisant Python, on peut facilement compresser différents formats, y compris.