Użyj języka Python, aby zmienić tło obrazów w formacie J2K
Twórz aplikacje Python do zmiany tła obrazów i zdjęć w formacie J2K za pośrednictwem interfejsów API serwera
Jak zmienić tło obrazów i zdjęć w formacie J2K za pomocą Python
Często podczas edycji obrazu w formacie J2K pojawia się konieczność zmiany jego tła. Początkowy krok polega na wybraniu obiektów pierwszego planu na zdjęciu i odróżnieniu ich od reszty obrazu w celu wyodrębnienia obszarów przypisanych do tła. Gdy tło stanowi jednolity obszar, kontury obiektu można ustalić automatycznie. Jeśli jednak zdjęcie ma nieregularne tło lub pojawiają się trudności w odróżnieniu pożądanego obiektu od tła, wskazane jest zastosowanie metody wstępnego zaznaczenia obrazu. Polega to na wybraniu na zdjęciu prostokątnych obszarów, w których znajdują się przewidywane obiekty i określeniu ich typu. Takie działania można wykonać ręcznie lub ułatwić poprzez Cloud API w celu automatycznego wykrywania obiektów. Po wybraniu obiektów i usunięciu pierwotnego tła istnieje możliwość wprowadzenia nowego tła lub nadania mu przezroczystości. Aby zmodyfikować tło obrazu w formacie J2K, użyjemy Aspose.Imaging for Python via .NET API, które jest bogatym w funkcje, potężnym i łatwym w użyciu interfejsem API do manipulacji i konwersji obrazów dla platformy Python. Możesz go zainstalować za pomocą następującego polecenia z polecenia systemowego.
Systemowy wiersz poleceń
>> pip install aspose-imaging-python-net
Kroki, aby zmienić tło w J2Ks przez Python
Potrzebujesz aspose-imaging-python-net , aby wypróbować następujący przepływ pracy we własnym środowisku.
- Załaduj pliki J2K za pomocą metody Image.Load
- Zmień tło;
- Zapisz obraz na dysku w formacie obsługiwanym przez Aspose.Imaging
wymagania systemowe
Aspose.Imaging dla Python jest obsługiwane we wszystkich głównych systemach operacyjnych. Tylko upewnij się, że masz następujące wymagania wstępne.
- Microsoft Windows / Linux ze środowiskiem wykonawczym .NET Core.
- Menedżer pakietów Python i PyPi.
Zmień tło w obrazach J2K – 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() |
Informacje o Aspose.Imaging dla Python API
Aspose.Imaging API to rozwiązanie do przetwarzania obrazów do tworzenia, modyfikowania, rysowania lub konwertowania obrazów (zdjęć) w aplikacjach. Oferuje: wieloplatformowe przetwarzanie obrazu, w tym między innymi konwersje między różnymi formatami obrazu (w tym jednolite przetwarzanie obrazu wielostronicowego lub wieloklatkowego), modyfikacje takie jak rysowanie, praca z prymitywami graficznymi, przekształcenia (zmiana rozmiaru, przycinanie, odwracanie i obracanie , binaryzacja, skala szarości, dostosowanie), zaawansowane funkcje manipulacji obrazem (filtrowanie, dithering, maskowanie, prostowanie) oraz strategie optymalizacji pamięci. Jest to samodzielna biblioteka i nie zależy od żadnego oprogramowania do obsługi obrazów. W projektach można łatwo dodać wysokowydajne funkcje konwersji obrazów za pomocą natywnych interfejsów API. Są to w 100% prywatne lokalne interfejsy API, a obrazy są przetwarzane na Twoich serwerach.Zmień tło w J2Ks za pomocą aplikacji online
Zmień tło w dokumentach J2K, odwiedzając naszą witrynę demonstracyjną na żywo . Demo na żywo ma następujące zalety
J2K Co jest J2K Format pliku
Plik J2K to obraz skompresowany przy użyciu kompresji falkowej zamiast kompresji DCT.
Czytaj więcejInne obsługiwane formaty zmiany tła
Za pomocą Python można łatwo zmienić tło w różnych formatach, w tym.