PPTX DOCX XLSX PDF ODP
Aspose.Imaging  skirta Python
ICO

Naudokite Python ICO vaizdų fono pašalinimui

Kurkite Python programas, kad pašalintumėte ICO vaizdų ir nuotraukų foną naudodami serverio API

Kaip pašalinti ICO vaizdų ir nuotraukų foną naudojant Python

Norint pašalinti vaizdo ar nuotraukos foną, reikia tiksliai identifikuoti iškilius objektus. ICO vaizdams galimi įvairūs objekto apibrėžimo metodai. Paprastuose scenarijuose automatizuotas metodas efektyviai apdoroja vienodo fono vaizdus. Nepaisant to, dirbant su nuotraukomis, kuriose yra kelios figūros arba objektai, susiliejantys su fonu, rekomenduojama atlikti preliminarų objekto žymėjimą. Tam reikia rankiniu būdu nubrėžti stačiakampius plotus ir nurodyti objektų tipus, kuriuos reikia paryškinti. Sudėtingesniais automatinio objektų paskirstymo atvejais debesies API yra alternatyva. Ši debesimis pagrįsta programa identifikuoja objektus nuotraukoje ir naudoja gautus kontūrus, kad pašalintų foną. Pašalinus foną, padidinus likusių objektų kraštus, bendra vaizdo kokybė gali gerokai pagerėti. Jei norite pašalinti foną iš ICO failų, rekomenduojama naudoti 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 pašalinti foną iš ICO naudojant Python

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

  • Įkelkite ICO failus naudodami Image.Load metodą
  • Pašalinti 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ė.
 

Pašalinkite foną iš ICO vaizdų – 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()
 
  • 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.

    Pašalinkite ICO foną naudodami internetinę programą

    Pašalinkite ICO dokumentų foną apsilankę [tiesioginės demonstracinės versijos svetainėje] ( https://products.aspose.app/imaging/remove-background) . Tiesioginė demonstracinė versija turi šiuos privalumus

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

    ICO Kas yra ICO Failo formatas

    ICO failo formatas yra vaizdo failo formatas, skirtas kompiuterio piktogramoms „Microsoft Windows“. ICO failuose yra vienas ar daugiau mažų įvairių dydžių ir spalvų gylio vaizdų, kad juos būtų galima atitinkamai pakeisti. Sistemoje „Windows“ visuose vykdomuosiuose failuose, kuriuose vartotojui rodoma piktograma, darbalaukyje, meniu Pradėti arba „Windows Explorer“, turi būti piktograma ICO formatu.

    Skaityti daugiau

    Kiti palaikomi Pašalinkite fono formatus

    Naudojant Python, galima lengvai pašalinti foną iš įvairių formatų, įskaitant.

    APNG (Animuota nešiojama tinklo grafika)
    BMP (Bitmap paveikslėlis)
    JPG (Jungtinė fotografijos ekspertų grupė)
    DIB (Nuo įrenginio nepriklausomas bitmap)
    DICOM (Skaitmeninis vaizdas ir ryšiai)
    DJVU (Grafikos formatas)
    DNG (Skaitmeninio fotoaparato vaizdas)
    EMF (Patobulintas metafailo formatas)
    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)