PPTX DOCX XLSX PDF ODP
Aspose.Imaging  עבור Java
DNG

קריקטורה DNGs באמצעות Java

בנה יישומי Java משלך ל-Cartoonify קבצי DNG באמצעות ממשקי API בצד השרת.

כיצד לצייר קבצים ב-DNG באמצעות Java

לאפקטים מצוירים יש משיכה מובנית, לעתים קרובות מעוררים זיכרונות ילדות נוסטלגיים. כמעט כל מאמר בעיצוב גרפי משלב תמונות מצוירות כמרכיב חיוני. יצירת דיוקנאות מצוירת, כוונון עדין של תאורה, המרה לשחור ולבן, ניסויים בצבעים, ערבוב של טכניקות עריכה שונות ויצירת אפקטים מתוחכמים של תמונה ניתנים להשגה באמצעות מסנני תמונה כמו AdjustBrightness, BinarizeFixed, Filter, ReplaceColor ו-ApplyMask. ניתן להחיל מסננים אלה על התמונות המקוריות שנטענו. ללא קשר לנושא דף האינטרנט שלך, תמונות בסגנון קריקטורה מתאימות למטרות המחשה. מאמר מדעי מקבל חיוניות, בעוד שתוכן מגוון הופך מפתה יותר למשתמשים, ובכך מגביר את התנועה לאתר. כדי לצייר קבצים DNG, נשתמש Aspose.Imaging for Java API שהוא עשיר בתכונות, חזק וקל לשימוש למניפולציה והמרה של תמונות עבור פלטפורמת Java. אתה יכול להוריד את הגרסה האחרונה שלו ישירות מ- Maven ולהתקין אותה בתוך ה-Maven שלך פרויקט מבוסס על ידי הוספת התצורות הבאות לקובץ pom.xml.

מאגר

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

תלות

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

שלבים ליצירת קריקטורה של DNG באמצעות Java

אתה צריך את aspose-imaging-version-jdk16.jar כדי לנסות את זרימת העבודה הבאה בסביבה שלך.

  • טען קבצים DNG בשיטת Image.Load
  • תמונות מצוירות;
  • שמור תמונה דחוסה לדיסק בפורמט הנתמך על ידי Aspose.Imaging

דרישות מערכת

Aspose.Imaging עבור Java נתמך בכל מערכות ההפעלה העיקריות. רק ודא שיש לך את התנאים המוקדמים הבאים.

  • מותקן JDK 1.6 ומעלה.
 

תמונות קריקטורהDNG - 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 } });
}
}
 
  • אודות Aspose.Imaging עבור API של Java

    Aspose.Imaging API הוא פתרון לעיבוד תמונה ליצירה, שינוי, ציור או המרת תמונות (תמונות) בתוך יישומים. הוא מציע: עיבוד תמונה חוצה פלטפורמות, כולל אך לא רק המרות בין פורמטים שונים של תמונה (כולל עיבוד תמונה אחיד מרובה עמודים או ריבוי מסגרות), שינויים כגון ציור, עבודה עם פרימיטיבים גרפיים, טרנספורמציות (שינוי גודל, חיתוך, הפוך וסיבוב , בינאריזציה, גווני אפור, התאמה), תכונות מתקדמות של מניפולציה של תמונות (סינון, שיטוט, מיסוך, ביטול הטיה) ואסטרטגיות אופטימיזציה של זיכרון. זוהי ספרייה עצמאית ואינה תלויה בתוכנה כלשהי לפעולות תמונה. אפשר להוסיף בקלות תכונות המרת תמונה בעלות ביצועים גבוהים עם ממשקי API מקוריים בתוך פרויקטים. אלו הם 100% ממשקי API פרטיים מקומיים ותמונות מעובדות בשרתים שלך.

    קריקטורה DNGs באמצעות אפליקציה מקוונת

    קריקטורה DNG מסמכים על ידי ביקור ב[אתר הדגמות חיות] שלנו ( https://products.aspose.app/imaging/image-Cartoonify) . להדגמה החיה יש את היתרונות הבאים

      אין צורך להוריד או להגדיר שום דבר
      אין צורך לכתוב שום קוד
      פשוט העלה את קבצי DNG שלך ולחץ על הלחצן קריקטורה.
      קבל מיד את קישור ההורדה עבור הקובץ שנוצר

    DNG מה זה DNG פורמט קובץ

    DNG הוא פורמט תמונה של מצלמה דיגיטלית המשמש לאחסון קבצי גלם. הוא פותח על ידי אדובי בספטמבר 2004. הוא פותח בעיקרו עבור צילום דיגיטלי. DNG הוא הרחבה של פורמט תקן TIFF/EP ומשתמש במטא נתונים באופן משמעותי. על מנת לתפעל נתונים גולמיים ממצלמות דיגיטליות בקלות גמישות ושליטה אמנותית, צלמים בוחרים בקבצי מצלמה גולמיים. פורמטים JPEG ו-TIFF מאחסנים תמונות המעובדות על ידי המצלמה, ולכן אין הרבה מקום לשינויים בפורמטים כאלה.

    קרא עוד

    פורמטים נתמכים אחרים של קריקטורה

    באמצעות Java, אפשר בקלות לצייר פורמטים שונים כולל.

    APNG (גרפיקת רשת ניידת מונפשת)
    BMP (תמונת מפת סיביות)
    ICO (סמל של Windows)
    JPG (קבוצת מומחי צילום משותפת)
    JPEG (קבוצת מומחי צילום משותפת)
    DIB (מפת סיביות בלתי תלויה בהתקן)
    DICOM (הדמיה דיגיטלית ותקשורת)
    DJVU (פורמט גרפי)
    EMF (פורמט Metafile משופר)
    EMZ (Metafile משופר דחוס של Windows)
    GIF (פורמט מחלף גרפי)
    JP2 (JPEG 2000)
    J2K (תמונה דחוסה של Wavelet)
    PNG (גרפיקת רשת ניידת)
    TIFF (פורמט תמונה מתויג)
    TIF (פורמט תמונה מתויג)
    WEBP (תמונה ברשת רסטר)
    WMF (Microsoft Windows Metafile)
    WMZ (עור דחוס של Windows Media Player)
    TGA (טארגה גרפיקה)
    SVG (גרפיקה וקטורית ניתנת להרחבה)
    EPS (שפת PostScript מובלעת)
    CDR (תמונה של ציור וקטור)
    CMX (תמונת Corel Exchange)
    OTG (OpenDocument Standard)
    ODG (Apache OpenOffice Draw Format)