Gebruik Python voor compressie van EPS afbeeldingen
Maak Python-apps om EPS afbeeldingen en foto’s te comprimeren via server-API’s
Aspose.Imaging voor Python
Overview
Hoe u EPS afbeeldingen en foto's comprimeert met Python
Het aanpassen van afbeeldingen voor publicatie omvat niet alleen creatieve processen, maar ook technische aanpassingen, zoals bestandscompressie. Over het algemeen zijn afbeeldingen met een hoge resolutie nodig voor drukwerk of buitenreclame, terwijl websites met grote bestandsgroottes te maken kunnen krijgen. De instellingen voor beeldcompressie kunnen variëren, afhankelijk van het beoogde gebruik en de plaats waar ze worden gepubliceerd. Het downloaden van grote bestanden kan een aanzienlijke hoeveelheid tijd in beslag nemen, vooral op mobiele verbindingen, wat van invloed is op de algehele gebruikerservaring. Overmatig gecomprimeerde afbeeldingen kunnen echter last hebben van wazigheid en zichtbare pixelvorming, waardoor de visuele kwaliteit wordt ondermijnd. Het bereiken van een evenwicht tussen bestandsgrootte en beeldkwaliteit vereist een zorgvuldige selectie van algoritmen en compressieniveaus. Om afbeeldingen in het EPS-formaat te comprimeren, gebruiken we Aspose.Imaging for Python via .NET API, een veelzijdige, krachtige en gebruiksvriendelijke API voor beeldmanipulatie en conversie voor het Python-platform. U kunt het installeren met behulp van de volgende opdracht van uw systeemopdracht.
De systeemopdrachtregel
>> pip install aspose-imaging-python-net
Stappen om EPS's te comprimeren via Python
U hebt de aspose-imaging-python-net nodig om de volgende workflow in uw eigen omgeving uit te proberen.
- Laad EPS-bestanden met de methode Image.Load
- Comprimeer afbeeldingen;
- Bewaar gecomprimeerde afbeelding op schijf in het formaat dat wordt ondersteund door Aspose.Imaging
systeem vereisten
Aspose.Imaging voor Python wordt ondersteund op alle belangrijke besturingssystemen. Zorg ervoor dat u aan de volgende vereisten voldoet.
- Microsoft Windows / Linux met .NET Core Runtime.
- Python en PyPi pakketbeheerder.
Comprimeer EPS afbeeldingen - 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() |
Over Aspose.Imaging voor Python API
Aspose.Imaging API is een beeldverwerkingsoplossing voor het maken, wijzigen, tekenen of converteren van afbeeldingen (foto’s) binnen applicaties. Het biedt: platformonafhankelijke beeldverwerking, inclusief maar niet beperkt tot conversies tussen verschillende beeldformaten (inclusief uniforme beeldverwerking van meerdere pagina’s of meerdere frames), aanpassingen zoals tekenen, werken met grafische primitieven, transformaties (formaat wijzigen, bijsnijden, spiegelen en roteren , binarisatie, grijswaarden, aanpassen), geavanceerde functies voor beeldmanipulatie (filteren, dithering, maskeren, rechtzetten) en strategieën voor geheugenoptimalisatie. Het is een op zichzelf staande bibliotheek en is niet afhankelijk van software voor beeldbewerkingen. Men kan eenvoudig hoogwaardige functies voor beeldconversie toevoegen met native API’s binnen projecten. Dit zijn 100% private on-premise API’s en afbeeldingen worden verwerkt op uw servers.Comprimeer EPS’s via online app
Comprimeer EPS-documenten door naar onze website voor livedemo’s te gaan. De live demo heeft de volgende voordelen:
EPS Wat is EPS Bestandsformaat
Bestanden met de extensie EPS beschrijven in wezen een Encapsulated PostScript-taalprogramma dat het uiterlijk van een enkele pagina beschrijft. De naam "Encapsulated" omdat deze kan worden opgenomen of ingekapseld in een paginabeschrijving van een andere PostScript-taal. Deze op scripts gebaseerde bestandsindeling kan elke combinatie van tekst, afbeeldingen en afbeeldingen bevatten. EPS-bestanden kunnen een voorbeeldafbeelding van een bitmap bevatten die is ingekapseld voor weergave door toepassingen die dergelijke bestanden kunnen openen. EPS-bestanden kunnen worden geconverteerd naar standaard afbeeldingsformaten zoals JPG, PNG, TIFF en PDF met behulp van verschillende toepassingen, b.v. Adobe Illustrator, Photoshop en PaintShop Pro. Vanwege een beveiligingsprobleem in EPS-bestanden hebben Office 2016, Office 2013, Office 2010 en Office 365 de mogelijkheid uitgeschakeld om EPS-bestanden in Office-documenten in te voegen.
Lees verderAndere ondersteunde compressieformaten
Met Python kan men gemakkelijk verschillende formaten comprimeren, waaronder.