Pro odstranění pozadí obrázků ve formátu ICO použijte Python
Vytvářejte aplikace Python k odstranění pozadí obrázků a fotografií ICO prostřednictvím rozhraní API serveru
Jak odstranit pozadí obrázků a fotografií ve formátu ICO pomocí Python
Odstranění pozadí z obrázku nebo fotografie vyžaduje přesnou identifikaci nápadných objektů. Pro obrázky ve formátu ICO jsou k dispozici různé metody pro definici objektu. V jednoduchých scénářích automatizovaný přístup efektivně zpracovává obrázky s jednotným pozadím. Přesto se při práci s fotografiemi s více postavami nebo objekty splývajícími s pozadím doporučuje provést předběžné označení objektu. To znamená ruční nastínění obdélníkových oblastí a určení typů objektů, které mají být zvýrazněny. Ve složitějších případech automatizované alokace objektů je alternativou Cloud API. Tato cloudová aplikace identifikuje objekty na fotografii a využívá výsledné obrysy k odstranění pozadí. Po odstranění pozadí může vylepšení okrajů zbývajících objektů výrazně zlepšit celkovou kvalitu obrazu. Pro odstranění pozadí v souborech ICO se doporučuje použít Aspose.Imaging pro Python přes .NET API, které je funkčně bohaté, výkonné a snadno použitelné rozhraní API pro manipulaci a konverzi obrázků pro platformu Python. Můžete jej nainstalovat pomocí následujícího příkazu ze systémového příkazu.
Příkazový řádek systému
>> pip install aspose-imaging-python-net
Kroky k odstranění pozadí z ICOs prostřednictvím Python
K vyzkoušení následujícího pracovního postupu ve svém vlastním prostředí potřebujete aspose-imaging-python-net .
- Načíst soubory ICO metodou Image.Load
- Odebrat pozadí;
- Uložit obrázek na disk ve formátu podporovaném Aspose.Imaging
Požadavky na systém
Aspose.Imaging pro Python je podporován ve všech hlavních operačních systémech. Jen se ujistěte, že máte následující předpoklady.
- Microsoft Windows / Linux s .NET Core Runtime.
- Správce balíčků Python a PyPi.
Odebrat pozadí v obrázcích ICO – 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() |
O Aspose.Imaging pro Python API
Aspose.Imaging API je řešení pro zpracování obrázků pro vytváření, úpravu, kreslení nebo konverzi obrázků (fotografií) v rámci aplikací. Nabízí: multiplatformní zpracování obrazu, mimo jiné včetně převodů mezi různými formáty obrázků (včetně jednotného vícestránkového nebo vícesnímkového zpracování obrazu), úpravy jako kreslení, práci s grafickými primitivy, transformace (změna velikosti, oříznutí, převrácení a otočení). binarizace, stupně šedi, úprava), pokročilé funkce pro manipulaci s obrázky (filtrování, rozklad, maskování, vyrovnání sklonu) a strategie optimalizace paměti. Je to samostatná knihovna a není závislá na žádném softwaru pro operace s obrázky. V rámci projektů lze snadno přidat vysoce výkonné funkce pro konverzi obrázků s nativními rozhraními API. Jedná se o 100% soukromá on-premise API a obrázky se zpracovávají na vašich serverech.Odstraňte pozadí ve ICOs prostřednictvím online aplikace
Odeberte pozadí v dokumentech ICO na našem webu s živými ukázkami . Živé demo má následující výhody
ICO co je ICO Formát souboru
Formát souboru ICO je formát souboru obrázků pro počítačové ikony v systému Microsoft Windows. Soubory ICO obsahují jeden nebo více malých obrázků v různých velikostech a barevných hloubkách, takže je lze vhodně škálovat. Ve Windows musí všechny spustitelné soubory, které uživateli zobrazují ikonu, na ploše, v nabídce Start nebo v Průzkumníku Windows, nést ikonu ve formátu ICO.
Přečtěte si víceJiné podporované Odeberte formáty pozadí
Pomocí Python lze snadno odstranit pozadí z různých formátů včetně.