PPTX DOCX XLSX PDF ODP
Aspose.Imaging  dla Java
EMZ

Cartoonify EMZ przez Java

Twórz własne aplikacje Java do Cartoonify plików EMZ za pomocą interfejsów API po stronie serwera.

Jak rysować pliki EMZ za pomocą Java

Efekty kreskówek mają swój urok i często przywołują nostalgiczne wspomnienia z dzieciństwa. Prawie każdy artykuł dotyczący projektowania graficznego zawiera obrazy kreskówkowe jako istotny element. Kreskowanie portretów, dostrajanie oświetlenia, konwersja do czerni i bieli, eksperymentowanie z kolorami, mieszanie różnych technik edycji i tworzenie wyrafinowanych efektów obrazu są możliwe do osiągnięcia dzięki filtrom obrazu, takim jak RegulacjaBrightness, BinarizeFixed, Filtr, ZamieńKolor i ApplyMask. Filtry te można zastosować do oryginalnie załadowanych zdjęć. Niezależnie od tematyki Twojej strony internetowej, obrazy w stylu kreskówek nadają się do celów ilustracyjnych. Artykuł naukowy zyskuje na dynamice, a różnorodna treść staje się bardziej atrakcyjna dla użytkowników, co zwiększa ruch na stronie. W celu kreskowania plików EMZ użyjemy Aspose.Imaging dla Javy API, który jest bogatym w funkcje, wydajnym i łatwym w użyciu interfejsem API do obróbki i konwersji obrazów dla platformy Java. Możesz pobrać jego najnowszą wersję bezpośrednio z Maven i zainstaluj go w swoim projekcie opartym na Maven, dodając następujące konfiguracje do pom.xml.

Repozytorium

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

Zależność

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

Kroki do rysowania EMZ za pomocą Java

Potrzebujesz aspose-imaging-version-jdk16.jar aby wypróbować następujący przepływ pracy we własnym środowisku.

  • Załaduj pliki EMZ za pomocą metody Image.Load
  • Obrazy kreskówkowe;
  • Zapisz skompresowany obraz na dysku w formacie obsługiwanym przez Aspose.Imaging

wymagania systemowe

Aspose.Imaging dla Java jest obsługiwane we wszystkich głównych systemach operacyjnych. Tylko upewnij się, że masz następujące wymagania wstępne.

  • JDK 1.6 lub nowszy jest zainstalowany.
 

Cartoonify obrazy EMZ - 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 } });
}
}
 
  • Informacje o Aspose.Imaging dla Java 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.

    Cartoonify EMZs za pośrednictwem aplikacji online

    Przygotuj dokumenty w formacie EMZ, odwiedzając naszą witrynę demonstracyjną na żywo . Demo na żywo ma następujące zalety

      Nie musisz niczego pobierać ani konfigurować
      Nie musisz pisać żadnego kodu
      Po prostu prześlij swoje pliki EMZ i naciśnij przycisk „Cartoonify now”
      Natychmiast uzyskaj link do pobrania pliku wynikowego

    EMZ Co jest EMZ Format pliku

    Plik z rozszerzeniem EMZ to skompresowany plik obrazu, dokładniej nazywany plikiem Windows Compressed Enhanced Metafile

    Czytaj więcej

    Inne obsługiwane formaty Cartoonify

    Używając Java, można łatwo rysować różne formaty, w tym.

    APNG (Animowana przenośna grafika sieciowa)
    BMP (Obraz bitmapowy)
    ICO (Ikona Windows)
    JPG (Wspólna Grupa Ekspertów Fotograficznych)
    JPEG (Wspólna Grupa Ekspertów Fotograficznych)
    DIB (Mapa bitowa niezależna od urządzenia)
    DICOM (Obrazowanie cyfrowe i komunikacja)
    DJVU (Format graficzny)
    DNG (Obraz z aparatu cyfrowego)
    EMF (Ulepszony format metapliku)
    GIF (Graficzny format wymiany)
    JP2 (JPEG 2000)
    J2K (Skompresowany obraz falkowy)
    PNG (Przenośna Grafika Sieciowa)
    TIFF (Oznaczony format obrazu)
    TIF (Oznaczony format obrazu)
    WEBP (Obraz rastrowy w sieci Web)
    WMF (Metaplik Microsoft Windows)
    WMZ (Skompresowana skórka Windows Media Player)
    TGA (Targa grafika)
    SVG (Skalowalna Grafika wektorowa)
    EPS (Enkapsulowany język PostScript)
    CDR (Obraz rysunku wektorowego)
    CMX (Obraz wymiany firmy Corel)
    OTG (Standard OpenDocument)
    ODG (Apache OpenOffice Draw format)