PPTX DOCX XLSX PDF ODP
Aspose.Imaging skirta Python
EMF

Naudokite Python EMF vaizdų fono keitimui

Kurkite Python programas, kad pakeistumėte EMF vaizdų ir nuotraukų foną naudodami serverio API

 

Aspose.Imaging skirta Python Aspose.Imaging skirta Python

Overview

Kaip pakeisti EMF vaizdų ir nuotraukų foną naudojant Python

Dažnai redaguojant vaizdą EMF, reikia pakeisti jo foną. Pradinis žingsnis apima priekinio plano objektų pasirinkimą nuotraukoje ir jų atskyrimą nuo likusio vaizdo, kad būtų atskirtos fonui priskirtos vietos. Kai fonas sudaro vienodą plotą, objekto kontūrus galima nustatyti automatiškai. Tačiau jei nuotraukoje matomas netaisyklingas fonas arba kyla sunkumų atskiriant norimą objektą nuo fono, patartina naudoti preliminarų vaizdo žymėjimo metodą. Tai reiškia, kad nuotraukoje reikia pasirinkti stačiakampes sritis, kuriose yra numatyti objektai, ir nurodyti jų tipą. Tokius veiksmus galima atlikti rankiniu būdu arba palengvinti naudojant debesies API automatiniam objektų aptikimui. Pasirinkę objektus ir pašalinę pradinį foną, turite galimybę įvesti naują foną arba padaryti jį skaidrų. Norėdami pakeisti vaizdo foną EMF formatu, naudosime Aspose.Imaging for Python per .NET API, kuri yra daug funkcijų, galinga ir lengvai naudojama vaizdo apdorojimo ir konvertavimo API, skirta Python platformai. Jį galite įdiegti naudodami šią komandą iš savo sistemos komandos.

Sistemos komandų eilutė

>> pip install aspose-imaging-python-net

Veiksmai, kaip pakeisti foną EMFs naudojant Python

Jums reikia aspose-imaging-python-net , kad galėtumėte išbandyti toliau nurodytą darbo eigą savo aplinkoje.

  • Įkelkite EMF failus naudodami Image.Load metodą
  • Keisti foną;
  • Išsaugokite vaizdą į diską palaikomu Aspose.Imaging formatu

Sistemos reikalavimai

„Aspose.Imaging“, skirta Python, palaikoma visose pagrindinėse operacinėse sistemose. Tiesiog įsitikinkite, kad turite šias būtinas sąlygas.

  • Microsoft Windows / Linux su .NET Core Runtime.
  • Python ir PyPi paketų tvarkyklė.
 

Keisti foną EMF vaizduose – Python

from aspose.imaging import Image, RasterImage, Point, Rectangle, Color
from aspose.imaging.fileformats.png import PngColorType
from aspose.imaging.imageoptions import PngOptions
from aspose.imaging.masking import *
from aspose.imaging.masking.options import *
from aspose.imaging.masking.result import *
from aspose.imaging.sources import FileCreateSource
from aspose.pycore import as_of
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 remove_background_processing_with_manual_rectangles():
raster_formats = [
"jpg",
"png",
"bmp",
"apng",
"dicom",
"jp2",
"j2k",
"tga",
"webp",
"tif",
"gif",
"ico"
]
vector_formats = [
"svg",
"otg",
"odg",
"wmf",
"emf",
"wmz",
"emz",
"cmx",
"cdr"
]
all_formats: list = []
all_formats.extend(raster_formats)
all_formats.extend(vector_formats)
for format_ext in all_formats:
input_file = os.path.join(templates_folder, f"couple.{format_ext}")
if not os.path.exists(input_file):
continue
is_vector_format = format_ext in vector_formats
# Need to rasterize vector formats before background remove
if is_vector_format:
input_file = rasterize_vector_image(format_ext, input_file)
output_file = os.path.join(templates_folder, f"remove_background_manual_rectangles.{format_ext}.png")
print(f"Processing {format_ext}")
with as_of(Image.load(input_file), RasterImage) as image:
obj_init3 = AutoMaskingArgs()
obj_init3.objects_rectangles = [Rectangle(87, 47, 123, 308), Rectangle(180, 24, 126, 224)]
obj_init4 = PngOptions()
obj_init4.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
obj_init4.source = FileCreateSource(output_file, False)
obj_init5 = AutoMaskingGraphCutOptions()
obj_init5.feathering_radius = 2
obj_init5.method = SegmentationMethod.GRAPH_CUT
obj_init5.args = obj_init3
obj_init5.export_options = obj_init4
masking_options = obj_init5
with ImageMasking(image).create_session(masking_options) as masking_session:
# first run of segmentation
with masking_session.decompose() as _:
pass
args_with_user_markers = AutoMaskingArgs()
obj_init_list = [
# background markers
None,
# foreground markers
UserMarker()
# boy's head
.add_point(218, 48, 10)
# girl's head
.add_point(399, 66, 10)
# girs's body
.add_point(158, 141, 10)
.add_point(158, 209, 20)
.add_point(115, 225, 5)
.get_points()]
args_with_user_markers.objects_points = obj_init_list
with masking_session.improve_decomposition(args_with_user_markers) as masking_result:
with masking_result[1].get_image() as result_image:
result_image.save()
if delete_output:
os.remove(output_file)
# Remove rasterized vector image
if is_vector_format and delete_output:
os.remove(input_file)
def remove_background_auto_processing_with_assumed_objects():
raster_formats = [
"jpg",
"png",
"bmp",
"apng",
"dicom",
"jp2",
"j2k",
"tga",
"webp",
"tif",
"gif"]
vector_formats = [
"svg",
"otg",
"odg",
"eps",
"wmf",
"emf",
"wmz",
"emz",
"cmx",
"cdr"]
all_formats = []
all_formats.extend(raster_formats)
all_formats.extend(vector_formats)
for format_ext in all_formats:
input_file = os.path.join(templates_folder, f"couple.{format_ext}")
if not os.path.exists(input_file):
continue
is_vector_format = format_ext in vector_formats
# Need to rasterize vector formats before background remove
if is_vector_format:
input_file = rasterize_vector_image(format_ext, input_file)
output_file = os.path.join(templates_folder,
f"remove_background_auto_assumed_objects.{format_ext}.png")
print(f"Processing {format_ext}")
with as_of(Image.load(input_file), RasterImage) as image:
obj_init9 = list()
obj_init9.append(AssumedObjectData(DetectedObjectType.HUMAN, Rectangle(87, 47, 123, 308)))
obj_init9.append(AssumedObjectData(DetectedObjectType.HUMAN, Rectangle(180, 24, 126, 224)))
obj_init10 = PngOptions()
obj_init10.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
obj_init10.source = FileCreateSource(output_file, False)
obj_init11 = AutoMaskingGraphCutOptions()
obj_init11.assumed_objects = obj_init9
obj_init11.calculate_default_strokes = True
obj_init11.feathering_radius = 1
obj_init11.method = SegmentationMethod.GRAPH_CUT
obj_init11.export_options = obj_init10
obj_init11.background_replacement_color = Color.green
masking_options = obj_init11
with ImageMasking(image).decompose(masking_options) as masking_result:
with masking_result[1].get_image() as result_image:
result_image.save()
# Remove rasterized vector image
if is_vector_format and delete_output:
os.remove(input_file)
if delete_output:
os.remove(output_file)
def remove_background_auto_processing():
raster_formats = [
"jpg",
"png",
"bmp",
"apng",
"dicom",
"jp2",
"j2k",
"tga",
"webp",
"tif",
"gif"]
vector_formats = [
"svg",
"otg",
"odg",
"eps",
"wmf",
"emf",
"wmz",
"emz",
"cmx",
"cdr"]
all_formats: list = []
all_formats.extend(raster_formats)
all_formats.extend(vector_formats)
for format_ext in all_formats:
input_file = os.path.join(templates_folder, f"couple.{format_ext}")
if not os.path.exists(input_file):
continue
is_vector_format = format_ext in vector_formats
# Need to rasterize vector formats before background remove
if is_vector_format:
input_file = rasterize_vector_image(format_ext, input_file)
output_file = os.path.join(templates_folder, f"remove_background_auto.{format_ext}.png")
print(f"Processing {format_ext}")
with as_of(Image.load(input_file), RasterImage) as image:
obj_init14 = PngOptions()
obj_init14.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
obj_init14.source = FileCreateSource(output_file, False)
obj_init15 = AutoMaskingGraphCutOptions()
obj_init15.feathering_radius = 1
obj_init15.method = SegmentationMethod.GRAPH_CUT
obj_init15.export_options = obj_init14
obj_init15.background_replacement_color = Color.green
masking_options = obj_init15
with ImageMasking(image).decompose(masking_options) as masking_result:
with masking_result[1].get_image() as result_image:
result_image.save()
# Remove rasterized vector image
if is_vector_format and delete_output:
os.remove(input_file)
if delete_output:
os.remove(output_file)
def remove_background_generic_example():
raster_formats = [
"jpg",
"png",
"bmp",
"apng",
"dicom",
"jp2",
"j2k",
"tga",
"webp",
"tif",
"gif"]
vector_formats = [
"svg",
"otg",
"odg",
"wmf",
"emf",
"wmz",
"emz",
"cmx",
"cdr"]
all_formats: list = []
all_formats.extend(raster_formats)
all_formats.extend(vector_formats)
for format_ext in all_formats:
input_file = os.path.join(templates_folder, f"couple.{format_ext}")
if not os.path.exists(input_file):
continue
is_vector_format: bool = format_ext in vector_formats
# Need to rasterize vector formats before background remove
if is_vector_format:
input_file = rasterize_vector_image(format_ext, input_file)
output_file = os.path.join(templates_folder, f"remove_background.{format_ext}.png")
print(f"Processing {format_ext}")
with as_of(Image.load(input_file), RasterImage) as image:
obj_init18 = PngOptions()
obj_init18.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
obj_init18.source = FileCreateSource(output_file, False)
obj_init19 = AutoMaskingGraphCutOptions()
obj_init19.calculate_default_strokes = True
obj_init19.feathering_radius = 1
obj_init19.method = SegmentationMethod.GRAPH_CUT
obj_init19.export_options = obj_init18
obj_init19.background_replacement_color = Color.green
masking_options = obj_init19
with ImageMasking(image).decompose(masking_options) as masking_result:
with masking_result[1].get_image() as result_image:
result_image.save()
# Remove rasterized vector image
if is_vector_format and delete_output:
os.remove(input_file)
if delete_output:
os.remove(output_file)
def rasterize_vector_image(format_ext, input_file):
output_file: str = os.path.join(templates_folder, f"rasterized.{format_ext}.png")
with Image.load(input_file) as image:
image.save(output_file, PngOptions())
return output_file
class UserMarker:
def __init__(self):
self._list: list = []
def add_point(self, left, top, radius):
for y in range(top - radius, top + radius + 1):
for x in range(left - radius, left + radius + 1):
self._list.append(Point(x, y))
return self
def get_points(self):
return self._list
# Run examples
remove_background_auto_processing_with_assumed_objects()
remove_background_processing_with_manual_rectangles()
remove_background_auto_processing()
remove_background_generic_example()
view raw remove-change-background-generic-examples.py hosted with ❤ by GitHub
 

    • Apie „Aspose.Imaging“, skirta Python API

    Aspose.Imaging API yra vaizdo apdorojimo sprendimas, skirtas kurti, modifikuoti, piešti ar konvertuoti vaizdus (nuotraukas) programose. Ji siūlo: kelių platformų vaizdo apdorojimą, įskaitant, bet tuo neapsiribojant, konvertavimą tarp įvairių vaizdo formatų (įskaitant vienodą kelių puslapių arba kelių kadrų vaizdo apdorojimą), modifikacijas, tokias kaip piešimas, darbas su grafiniais primityvais, transformacijos (keisti dydį, apkarpyti, apversti ir pasukti). , dvejetainis, pilkos spalvos tonas, koregavimas), pažangios vaizdo apdorojimo funkcijos (filtravimas, keitimas, maskavimas, iškrypimas) ir atminties optimizavimo strategijos. Tai yra atskira biblioteka ir nepriklauso nuo jokios programinės įrangos vaizdo operacijoms. Projektuose galima lengvai pridėti didelio našumo vaizdo konvertavimo funkcijų naudojant vietines API. Tai yra 100 % privačios vietinės API, o vaizdai apdorojami jūsų serveriuose.

    Pakeiskite EMF foną naudodami internetinę programą

    Pakeiskite EMF dokumentų foną apsilankę Live Demos svetainėje . Tiesioginė demonstracinė versija turi šiuos privalumus

      Nereikia nieko atsisiųsti ar nustatyti
      Nereikia rašyti jokio kodo
      Tiesiog įkelkite EMF failus ir paspauskite mygtuką "Keisti foną dabar".
      Iškart gaukite gauto failo atsisiuntimo nuorodą

    EMF Kas yra EMF Failo formatas

    Patobulintas metafailo formatas (EMF) išsaugo grafinius vaizdus nepriklausomai nuo įrenginio. EMF metafailus sudaro kintamo ilgio įrašai chronologine tvarka, kurie gali pateikti saugomą vaizdą, išanalizuoti bet kuriame išvesties įrenginyje. Šie kintamo ilgio įrašai gali būti uždarų objektų apibrėžimai, piešimo komandos ir grafinės savybės, būtinos norint tiksliai atvaizduoti vaizdą. Kai įrenginys atidaro EMF metafailą naudodamas savo grafinę aplinką, pradinio vaizdo proporcijos, matmenys, spalvos ir kitos grafinės savybės išlieka tos pačios, neatsižvelgiant į atidarymo įrenginio platformą.

    Skaityti daugiau

    Kiti palaikomi keitimo fono formatai

    Naudojant Python, galima lengvai pakeisti foną įvairiais formatais, įskaitant.

    APNG (Animuota nešiojama tinklo grafika)
    BMP (Bitmap paveikslėlis)
    ICO (Windows piktograma)
    JPG (Jungtinė fotografijos ekspertų grupė)
    DIB (Nuo įrenginio nepriklausomas bitmap)
    DICOM (Skaitmeninis vaizdas ir ryšiai)
    DJVU (Grafikos formatas)
    DNG (Skaitmeninio fotoaparato vaizdas)
    EMZ („Windows“ suspaustas patobulintas metafailas)
    GIF (Grafinis mainų formatas)
    JP2 (JPEG 2000)
    J2K („Wavelet“ suspaustas vaizdas)
    PNG (Nešiojamoji tinklo grafika)
    TIFF (Pažymėtas vaizdo formatas)
    WEBP (Rastrinis žiniatinklio vaizdas)
    WMF (Microsoft Windows metafailas)
    WMZ (Suspausta Windows Media Player oda)
    TGA (Targa grafika)
    SVG (Keičiama vektorinė grafika)
    EPS (Inkapsuliuota PostScript kalba)
    CDR (Vektorinio piešimo vaizdas)
    CMX (Corel Exchange vaizdas)
    OTG (OpenDocument standartas)
    ODG (Apache OpenOffice Draw formatas)
    AVIF