PPTX DOCX XLSX PDF ODP

WEBP

Cartoonify WEBPs über Java

Erstellen Sie Ihre eigenen Java-Apps, um WEBP-Dateien mit serverseitigen APIs zu cartoonisieren.

Wie man WEBP-Dateien mit Java karikiert

Cartoon-Effekte haben einen natürlichen Reiz und wecken oft nostalgische Kindheitserinnerungen. Fast jeder Grafikdesign-Artikel integriert Cartoon-Bilder als wesentliches Element. Mit Bildfiltern wie „AdjustBrightness“, „BinarizeFixed“, „Filter“, „ReplaceColor“ und „ApplyMask“ können Sie Porträts karikieren, die Beleuchtung verfeinern, in Schwarzweiß konvertieren, mit Farben experimentieren, verschiedene Bearbeitungstechniken mischen und anspruchsvolle Bildeffekte erstellen. Diese Filter können auf die ursprünglich geladenen Fotos angewendet werden. Unabhängig vom Thema Ihrer Webseite erweisen sich Bilder im Cartoon-Stil für Illustrationszwecke als geeignet. Ein wissenschaftlicher Artikel gewinnt an Lebendigkeit, vielfältige Inhalte werden für Nutzer attraktiver und steigern so den Website-Traffic. Zum Cartoonisieren von WEBP-Dateien verwenden wir Aspose.Imaging für Java API, die eine funktionsreiche, leistungsstarke und einfach zu verwendende Bildbearbeitungs- und Konvertierungs-API für die Java Plattform ist. Sie können die neueste Version direkt von herunterladen Maven und installieren Sie es in Ihrem Maven-basierten Projekt, indem Sie der pom.xml die folgenden Konfigurationen hinzufügen.

Repository<repository>
<id>Aspose Java API</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>

Abhängigkeit<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-imaging</artifactId>
<version>version of aspose-imaging API</version>
<classifier>jdk16</classifier>
</dependency>

Schritte zum Cartoonisieren von WEBPs über Java

Du brauchst die aspose-imaging-version-jdk16.jar um den folgenden Workflow in Ihrer eigenen Umgebung auszuprobieren.

Laden Sie WEBP-Dateien mit der Image.Load-Methode
Cartoonify-Bilder;
Speichern Sie komprimierte Bilder im von Aspose.Imaging unterstützten Format auf Disc

System Anforderungen

Aspose.Imaging für Java wird auf allen wichtigen Betriebssystemen unterstützt. Stellen Sie einfach sicher, dass Sie die folgenden Voraussetzungen erfüllen.

JDK 1.6 oder höher ist installiert.

Cartoonify WEBP-Bilder - Java

	import com.aspose.imaging.*;
	import com.aspose.imaging.fileformats.png.PngImage;
	import com.aspose.imaging.imagefilters.filteroptions.FilterOptionsBase;
	import com.aspose.imaging.imagefilters.filteroptions.MedianFilterOptions;
	import com.aspose.imaging.imageoptions.PngOptions;
	import com.aspose.imaging.masking.ImageMasking;
	import com.aspose.imaging.masking.options.MaskingOptions;
	import java.io.File;
	import java.util.*;
	import java.util.function.Consumer;
	import java.util.function.Function;
	import java.util.stream.Collectors;



	cartoonify();

	public static void cartoonify()
	{
	filterImages(image ->
	{
	try (PngImage processedImage = new PngImage(image))
	{
	image.resize(image.getWidth() * 2, image.getHeight(), ResizeType.LeftTopToLeftTop);
	ImageFilterExtensions.cartoonify(processedImage);
	Graphics gr = new Graphics(image);
	gr.drawImage(processedImage, processedImage.getWidth(), 0);
	gr.drawLine(new Pen(Color.getDarkRed(), 3), processedImage.getWidth(), 0, processedImage.getWidth(), image.getHeight());
	}
	}, "cartoonify");
	}

	static String templatesFolder = "D:\\TestData\\";

	public static void filterImages(Consumer<RasterImage> doFilter, String filterName)
	{
	List<String> rasterFormats = Arrays.asList("jpg", "png", "bmp", "apng", "dicom",
	"jp2", "j2k", "tga", "webp", "tif", "gif", "ico");
	List<String> vectorFormats = Arrays.asList("svg", "otg", "odg", "eps", "wmf", "emf", "wmz", "emz", "cmx", "cdr");

	List<String> allFormats = new LinkedList<>(rasterFormats);
	allFormats.addAll(vectorFormats);

	allFormats.forEach(
	formatExt ->
	{
	String inputFile = templatesFolder + "template." + formatExt;
	boolean isVectorFormat = vectorFormats.contains(formatExt);

	//Need to rasterize vector formats before background remove
	if (isVectorFormat)
	{
	inputFile = rasterizeVectorImage(formatExt, inputFile);
	}

	String outputFile = templatesFolder + String.format("%s_%s.png", filterName, formatExt);

	System.out.println("Processing " + formatExt);

	try (RasterImage image = (RasterImage) Image.load(inputFile))
	{
	doFilter.accept(image);

	//If image is multipage save each page to png to demonstrate results
	if (image instanceof IMultipageImage && ((IMultipageImage) image).getPageCount() > 1)
	{
	IMultipageImage multiPage = (IMultipageImage) image;
	final int pageCount = multiPage.getPageCount();
	final Image[] pages = multiPage.getPages();
	for (int pageIndex = 0; pageIndex < pageCount; pageIndex++)
	{
	String fileName = String.format("%s_page%d_%s.png", filterName, pageIndex, formatExt);
	pages[pageIndex].save(fileName, new PngOptions());
	}
	}
	else
	{
	image.save(outputFile, new PngOptions());
	}
	}

	//Remove rasterized vector image
	if (isVectorFormat)
	{
	new File(inputFile).delete();
	}
	}
	);
	}

	private static String rasterizeVectorImage(String formatExt, String inputFile)
	{
	String outputFile = templatesFolder + "rasterized." + formatExt + ".png";
	try (Image image = Image.load(inputFile))
	{
	image.save(outputFile, new PngOptions());
	}

	return outputFile;
	}

	interface IImageDataContext
	{
	void applyData();
	}


	class ImageFilterExtensions
	{
	public static void cartoonify(RasterImage image)
	{
	try (RasterImage outlines = detectOutlines(image, Color.getBlack()))
	{
	image.adjustBrightness(30);
	image.filter(image.getBounds(), new MedianFilterOptions(7));

	Graphics gr = new Graphics(image);
	gr.drawImage(outlines, Point.getEmpty());
	}
	}

	public static RasterImage detectOutlines(RasterImage image, Color outlineColor)
	{
	PngImage outlines = new PngImage(image);

	IImageDataContext ctx = getDataContext(outlines);
	applyConvolutionFilter(ctx, ConvolutionFilterOptions.getBlur());
	applyConvolutionFilter(ctx, ConvolutionFilterOptions.getOutline());
	ctx.applyData();

	outlines.binarizeFixed((byte)30);
	ImageMasking.applyMask(outlines, outlines, new MaskingOptions()
	{{
	setBackgroundReplacementColor(Color.getTransparent());
	}});
	outlines.replaceColor(Color.fromArgb(255, 255, 255), (byte)0, outlineColor);
	applyConvolutionFilter(outlines, ConvolutionFilterOptions.getBlur());
	return outlines;
	}

	public static RasterImage applyOperationToRasterImage(RasterImage image, Consumer<RasterImage> operation)
	{
	if (image instanceof IMultipageImage)
	{
	IMultipageImage multipage = (IMultipageImage) image;
	for (Image page : multipage.getPages())
	{
	operation.accept((RasterImage) page);
	}
	}
	else
	{
	operation.accept(image);
	}

	return image;
	}

	public static RasterImage applyFilter(RasterImage image, FilterOptionsBase filterOptions)
	{
	return applyOperationToRasterImage(image, img ->
	img.filter(img.getBounds(), filterOptions));
	}

	public static RasterImage applyConvolutionFilter(RasterImage image, ConvolutionFilterOptions filterOptions)
	{
	return applyOperationToRasterImage(image, img ->
	{
	ImagePixelsLoader pixelsLoader = new ImagePixelsLoader(img.getBounds());
	img.loadPartialArgb32Pixels(img.getBounds(), pixelsLoader);
	PixelBuffer outBuffer = new PixelBuffer(img.getBounds(), new int[img.getWidth() * img.getHeight()]);
	ConvolutionFilter.doFiltering(pixelsLoader.getPixelsBuffer(), outBuffer, filterOptions);
	img.saveArgb32Pixels(outBuffer.getRectangle(), outBuffer.getPixels());
	});
	}

	public static IImageDataContext getDataContext(RasterImage image)
	{
	if (image instanceof IMultipageImage)
	{
	return new MultipageDataContext(
	Arrays.stream(((IMultipageImage)image).getPages()).map(page -> {
	ImageDataContext buf = new ImageDataContext((RasterImage) page);
	buf.setBuffer(getImageBuffer((RasterImage)page));
	return buf;
	}).collect(Collectors.toList()));
	}

	ImageDataContext buf = new ImageDataContext(image);
	buf.setBuffer(getImageBuffer(image));
	return buf;
	}

	static IPixelBuffer getImageBuffer(RasterImage img)
	{
	ImagePixelsLoader pixelsLoader = new ImagePixelsLoader(img.getBounds());
	img.loadPartialArgb32Pixels(img.getBounds(), pixelsLoader);
	return pixelsLoader.getPixelsBuffer();
	}

	public static IImageDataContext applyToDataContext(IImageDataContext dataContext,
	Function<IPixelBuffer, IPixelBuffer> processor)
	{
	if (dataContext instanceof MultipageDataContext)
	{
	for (ImageDataContext context : (MultipageDataContext) dataContext)
	{
	context.setBuffer(processor.apply(context.getBuffer()));
	}
	}

	if (dataContext instanceof ImageDataContext)
	{
	ImageDataContext ctx = (ImageDataContext)dataContext;
	ctx.setBuffer(processor.apply(ctx.getBuffer()));
	}

	return dataContext;
	}

	public static IImageDataContext applyConvolutionFilter(IImageDataContext dataContext,
	ConvolutionFilterOptions filterOptions)
	{
	return applyToDataContext(dataContext, buffer ->
	{
	PixelBuffer outBuffer = new PixelBuffer(buffer.getRectangle(), new int[buffer.getRectangle().getWidth() * buffer.getRectangle().getHeight()]);
	ConvolutionFilter.doFiltering(buffer, outBuffer, filterOptions);
	return outBuffer;
	});
	}
	}

	class ImageDataContext implements IImageDataContext
	{
	private final RasterImage image;
	private IPixelBuffer buffer;

	public ImageDataContext(RasterImage image)
	{
	this.image = image;
	}

	public RasterImage getImage()
	{
	return image;
	}

	public IPixelBuffer getBuffer()
	{
	return buffer;
	}

	public void setBuffer(IPixelBuffer buffer)
	{
	this.buffer = buffer;
	}

	public void applyData()
	{
	this.buffer.saveToImage(this.image);
	}
	}

	class MultipageDataContext extends LinkedList<ImageDataContext> implements IImageDataContext
	{
	public MultipageDataContext(Collection<ImageDataContext> enumerable)
	{
	addAll(enumerable);
	}

	public void applyData()
	{
	for (ImageDataContext context : this)
	{
	context.applyData();
	}
	}
	}

	class ImagePixelsLoader implements IPartialArgb32PixelLoader
	{
	private final CompositePixelBuffer pixelsBuffer;

	public ImagePixelsLoader(Rectangle rectangle)
	{
	this.pixelsBuffer = new CompositePixelBuffer(rectangle);
	}

	public CompositePixelBuffer getPixelsBuffer()
	{
	return pixelsBuffer;
	}

	@Override
	public void process(Rectangle pixelsRectangle, int[] pixels, Point start, Point end)
	{
	this.pixelsBuffer.addPixels(pixelsRectangle,pixels);
	}
	}

	interface IPixelBuffer
	{
	Rectangle getRectangle();
	int get(int x, int y);
	void set(int x, int y, int value);
	void saveToImage(RasterImage image);
	}

	class PixelBuffer implements IPixelBuffer
	{
	private final Rectangle rectangle;
	private final int[] pixels;
	public PixelBuffer(Rectangle rectangle,int[] pixels)
	{
	this.rectangle = rectangle;
	this.pixels = pixels;
	}

	@Override
	public com.aspose.imaging.Rectangle getRectangle()
	{
	return rectangle;
	}

	public int[] getPixels()
	{
	return pixels;
	}

	@Override
	public int get(int x, int y)
	{
	return pixels[getIndex(x,y)];
	}

	@Override
	public void set(int x, int y, int value)
	{
	pixels[getIndex(x,y)] = value;
	}

	public void saveToImage(RasterImage image)
	{
	image.saveArgb32Pixels(this.rectangle, this.pixels);
	}

	public boolean contains(int x,int y)
	{
	return this.rectangle.contains(x,y);
	}

	private int getIndex(int x,int y)
	{
	x -= this.rectangle.getLeft();
	y -= this.rectangle.getTop();
	return x + y * this.rectangle.getWidth();
	}
	}

	class CompositePixelBuffer implements IPixelBuffer
	{
	private final List<PixelBuffer> _buffers = new ArrayList<>();
	private final Rectangle rectangle;

	public CompositePixelBuffer(Rectangle rectangle)
	{
	this.rectangle = rectangle;
	}

	@Override
	public com.aspose.imaging.Rectangle getRectangle()
	{
	return rectangle;
	}

	@Override
	public int get(int x, int y)
	{
	return getBuffer(x,y).get(x, y);
	}

	@Override
	public void set(int x, int y, int value)
	{
	getBuffer(x, y).set(x, y, value);
	}

	@Override
	public void saveToImage(RasterImage image)
	{
	for (PixelBuffer buffer : this._buffers)
	{
	buffer.saveToImage(image);
	}
	}

	public void addPixels(Rectangle rectangle,int[] pixels)
	{
	if(rectangle.intersectsWith(rectangle))
	{
	this._buffers.add(new PixelBuffer(rectangle,pixels));
	}
	}

	private PixelBuffer getBuffer(int x,int y)
	{
	return this._buffers.stream().filter(b -> b.contains(x,y)).findFirst().get();
	}
	}

	class ConvolutionFilter
	{
	public static void doFiltering(
	IPixelBuffer inputBuffer,
	IPixelBuffer outputBuffer,
	ConvolutionFilterOptions options)
	{
	double factor = options.getFactor();
	int bias = options.getBias();
	double[][] kernel = options.getKernel();
	int filterWidth = kernel[0].length;
	int filterCenter = (filterWidth - 1) / 2;

	int x, y;
	int filterX, filterY, filterPx, filterPy, filterYPos, pixel;
	double r, g, b, kernelValue;

	int top = inputBuffer.getRectangle().getTop();
	int bottom = inputBuffer.getRectangle().getBottom();
	int left = inputBuffer.getRectangle().getLeft();
	int right = inputBuffer.getRectangle().getRight();

	for (y = top; y < bottom; y++)
	{
	for (x = left; x < right; x++)
	{
	r = 0;
	g = 0;
	b = 0;

	for (filterY = -filterCenter; filterY <= filterCenter; filterY++)
	{
	filterYPos = filterY + filterCenter;
	filterPy = filterY + y;

	if (filterPy >= top && filterPy < bottom)
	{
	for (filterX = -filterCenter; filterX <= filterCenter; filterX++)
	{
	filterPx = filterX + x;
	if (filterPx >= left && filterPx < right)
	{
	kernelValue = kernel[filterYPos][filterX + filterCenter];
	pixel = inputBuffer.get(filterPx, filterPy);
	r += ((pixel >> 16) & 0xFF) * kernelValue;
	g += ((pixel >> 8) & 0xFF) * kernelValue;
	b += (pixel & 0xFF) * kernelValue;
	}
	}
	}
	}

	r = (factor * r) + bias;
	g = (factor * g) + bias;
	b = (factor * b) + bias;
	r = r > 255 ? 255 : (r < 0 ? 0 : r);
	g = g > 255 ? 255 : (g < 0 ? 0 : g);
	b = b > 255 ? 255 : (b < 0 ? 0 : b);

	outputBuffer.set(x, y, (inputBuffer.get(x, y) & 0xFF000000) \| ((int)r << 16) \| ((int)g << 8) \| (int)b);
	}
	}
	}
	}

	class ConvolutionFilterOptions
	{
	private double factor = 1.0;

	public double getFactor()
	{
	return factor;
	}

	public void setFactor(double factor)
	{
	this.factor = factor;
	}

	private int bias = 0;

	public int getBias()
	{
	return bias;
	}

	public void setBias(int bias)
	{
	this.bias = bias;
	}

	private double[][] kernel;

	public double[][] getKernel()
	{
	return kernel;
	}

	public void setKernel(double[][] kernel)
	{
	this.kernel = kernel;
	}

	public ConvolutionFilterOptions()
	{

	}

	public ConvolutionFilterOptions(double[][] kernel)
	{
	this.kernel = kernel;
	}

	public static ConvolutionFilterOptions getBlur()
	{
	ConvolutionFilterOptions filterOptions = new ConvolutionFilterOptions();
	filterOptions.setKernel(new double[][] { { 1, 2, 1 }, { 2, 4, 2 }, { 1, 2, 1 } });
	filterOptions.setFactor(0.25 * 0.25);
	return filterOptions;
	}

	public static ConvolutionFilterOptions getSharpen()
	{
	return new ConvolutionFilterOptions(new double[][] { { 0, -1, 0 }, { -1, 5, -1 }, { 0, -1, 0 } });
	}

	public static ConvolutionFilterOptions getEmboss()
	{
	return new ConvolutionFilterOptions(new double[][] { { -2, -1, 0 }, { -1, 1, 1 }, { 0, 1, 2 } });
	}

	public static ConvolutionFilterOptions getOutline()
	{
	return new ConvolutionFilterOptions(new double[][] { { -1, -1, -1 }, { -1, 8, -1 }, { -1, -1, -1 } });
	}

	public static ConvolutionFilterOptions getBottomSobel()
	{
	return new ConvolutionFilterOptions(new double[][] { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } });
	}

	public static ConvolutionFilterOptions getTopSobel()
	{
	return new ConvolutionFilterOptions(new double[][] { { 1, 2, 1 }, { 0, 0, 0 }, { -1, -2, -1 } });
	}

	public static ConvolutionFilterOptions getLeftSobel()
	{
	return new ConvolutionFilterOptions(new double[][] { { 1, 0, -1 }, { 2, 0, -2 }, { 1, 0, -1 } });
	}

	public static ConvolutionFilterOptions getRightSobel()
	{
	return new ConvolutionFilterOptions(new double[][] { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } });
	}
	}

view raw cartoonify-images.java hosted with ❤ by GitHub

Über Aspose.Imaging für die Java-API

Aspose.Imaging API ist eine Bildverarbeitungslösung zum Erstellen, Ändern, Zeichnen oder Konvertieren von Bildern (Fotos) in Anwendungen. Es bietet: plattformübergreifende Bildverarbeitung, einschließlich, aber nicht beschränkt auf Konvertierungen zwischen verschiedenen Bildformaten (einschließlich einheitlicher Mehrseiten- oder Multiframe-Bildverarbeitung), Modifikationen wie Zeichnen, Arbeiten mit grafischen Grundelementen, Transformationen (Größe ändern, Zuschneiden, Spiegeln und Drehen , Binarisierung, Graustufen, Anpassen), erweiterte Bildbearbeitungsfunktionen (Filtern, Dithering, Maskieren, Entzerren) und Strategien zur Speicheroptimierung. Es ist eine eigenständige Bibliothek und hängt von keiner Software für Bildoperationen ab. Mit nativen APIs können innerhalb von Projekten problemlos hochleistungsfähige Bildkonvertierungsfunktionen hinzugefügt werden. Dies sind 100 % private lokale APIs und Bilder werden auf Ihren Servern verarbeitet.

Cartoonify WEBPs über die Online-App

Cartoonifizieren Sie WEBP-Dokumente, indem Sie unsere [Website für Live-Demos] ( https://products.aspose.app/imaging/image-Cartoonify ) besuchen. Die Live-Demo hat die folgenden Vorteile

Sie müssen nichts herunterladen oder einrichten

Es muss kein Code geschrieben werden

Laden Sie einfach Ihre WEBP-Dateien hoch und klicken Sie auf die Schaltfläche "Cartoonify now".

Erhalten Sie sofort den Download-Link für die resultierende Datei

WEBP Was ist WEBP Datei Format

WebP, eingeführt von Google, ist ein modernes Raster-Webbild-Dateiformat, das auf verlustfreier und verlustbehafteter Komprimierung basiert. Es bietet die gleiche Bildqualität, während die Bildgröße erheblich reduziert wird. Da die meisten Webseiten Bilder als effektive Darstellung von Daten verwenden, führt die Verwendung von WebP-Bildern auf Webseiten zu einem schnelleren Laden von Webseiten. Laut Google sind verlustfreie WebP-Bilder im Vergleich zu PNGs 26 % kleiner, während verlustbehaftete WebP-Bilder 25–34 % kleiner sind als vergleichbare JPEG-Bilder. Bilder werden basierend auf dem Index der strukturellen Ähnlichkeit (SSIM) zwischen WebP und anderen Bilddateiformaten verglichen. WebP ist ein Schwesterprojekt des Multimedia-Containerformats WebM.

Wesen

Andere unterstützte Cartoonify-Formate

Mit Java kann man verschiedene Formate leicht karikieren, einschließlich.

APNG (Animierte tragbare Netzwerkgrafiken)

BMP (Bitmap-Bild)

ICO (Windows-Symbol)

JPG (Gemeinsame fotografische Expertengruppe)

JPEG (Gemeinsame fotografische Expertengruppe)

DIB (Geräteunabhängige Bitmap)

DICOM (Digitale Bildgebung und Kommunikation)

DJVU (Grafikformat)

DNG (Digitalkamera-Bild)

EMF (Verbessertes Metafile-Format)

EMZ (Windows komprimierte erweiterte Metadatei)

GIF (Grafisches Austauschformat)

JP2 (JPEG2000)

J2K (Wavelet-komprimiertes Bild)

PNG (Portable Netzwerkgrafiken)

TIFF (Markiertes Bildformat)

TIF (Markiertes Bildformat)

WMF (Microsoft Windows-Metadatei)

WMZ (Komprimierte Windows Media Player-Skin)

TGA (Targa-Grafik)

SVG (Skalierbare Vektorgrafiken)

EPS (Gekapselte PostScript-Sprache)

CDR (Vektor-Zeichenbild)

CMX (Corel Exchange-Bild)

OTG (OpenDocument-Standard)

ODG (Apache OpenOffice Draw-Format)

AVIF