PPTX DOCX XLSX PDF ODP
Aspose.Imaging  skirta Python
DJVU

Naudokite Python DJVU vaizdų fono keitimui

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

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

Dažnai redaguojant vaizdą DJVU, 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ą DJVU 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ą DJVUs naudojant Python

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

  • Įkelkite DJVU 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ą DJVU 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()
 
  • 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 DJVU foną naudodami internetinę programą

    Pakeiskite DJVU 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 DJVU failus ir paspauskite mygtuką "Keisti foną dabar".
      Iškart gaukite gauto failo atsisiuntimo nuorodą

    DJVU Kas yra DJVU Failo formatas

    DjVu, tariamas kaip DJVU, yra grafinis failo formatas, skirtas nuskaitytiems dokumentams ir knygoms, ypač tiems, kuriuose yra teksto, piešinių, vaizdų ir nuotraukų derinys. Jį sukūrė AT&T Labs. Jame naudojami keli būdai, pvz., teksto ir fono vaizdų atskyrimas vaizdo sluoksniais, laipsniškas įkėlimas, aritmetinis kodavimas ir nuostolingas bitoninių vaizdų glaudinimas. Kadangi DJVU faile gali būti suspaustų, tačiau aukštos kokybės spalvotų vaizdų, nuotraukų, teksto ir piešinių, todėl jį galima išsaugoti mažiau vietos, jis naudojamas žiniatinklyje kaip el. knygos, žinynai, laikraščiai, senoviniai dokumentai ir kt.

    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)
    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)