Die Funktionen dieser Werkzeugklasse: Bilder zoomen, Bilder schneiden, Bildtypumwandlung, Farbe auf Schwarzweiß, Textwasserzeichen, Bildwasserzeichen usw. Farbe
Die Codekopie lautet wie folgt:
Paket net.kitbox.util;
Import Java.awt.Alphacomposite;
Import Java.awt.Color;
import Java.awt.font;
importieren java.awt.graphics;
Import Java.awt.Graphics2d;
import Java.awt.image;
importieren java.awt.renderingHINDINTS;
import Java.awt.toolkit;
import Java.awt.color.ColorSpace;
Import Java.awt.image.BuffenedImage;
import Java.awt.image.ColorConvertop;
Import Java.awt.image.CropimageFilter;
Import Java.awt.image.FilteredimageSource;
Import Java.awt.image.imageFilter;
import Java.awt.image.imagingopexception;
Import Java.io.file;
importieren java.io.fileoutputStream;
importieren java.io.ioException;
import Javax.imageo.imageo;
/**
* Autor: lldy
* Zeit: 2012-5-6 18:37:18 Uhr
* Kategorie für Bildverarbeitungstool: <br>
* Funktionen: Bild zoomen, Bild schneiden, Bildtypumwandlung, Farbe auf Schwarzweiß, Textwasserzeichen, Bildwasserzeichen usw.
*/
öffentliche Klasse Imageutils {
/**
* Relativ zum Ort des Bildes
*/
private statische endgültige int Position_upperleft = 0;
private statische endgültige int Position_upperright = 10;
private statische endgültige int Position_lowerleft = 1;
private statische endgültige int Position_lowerright = 11;
/**
* Mehrere gemeinsame Bildformate
*/
public static String image_type_gif = "gif"; // Grafikaustauschformat
public static string image_type_jpg = "jpg"; // gemeinsame Fotoer Expertengruppe
public static String image_type_jpeg = "jpeg"; // gemeinsame Fotoer Expertengruppe
public static String image_type_bmp = "bmp"; // englische Bitmap (Bitmap), es ist das Standard -Bilddateiformat im Windows -Betriebssystem
public static string image_type_png = "png"; // tragbare Netzwerkgrafiken
private statische ImageUtils -Instanz;
private ImageUtils () {
Instance = this;
}
/**
* Holen Sie sich eine Instanz
* @zurückkehren
*/
public static imageutils getInstance () {
if (instance == null) {
Instance = new ImageUtils ();
}
Rückkehrinstanz;
}
public bufferedImage Image2BuffenedImage (Bildbild) {
System.out.println (Image.getWidth (null));
System.out.println (Image.Getheight (null));
Bufferedimage bufferedimage = new bufferedImage (image.getWidth (null), image.getheight (null), bufferedimage.type_int_argb);
Graphics2d g = bufferedimage.createGraphics ();
G.Drawimage (Bild, NULL, NULL);
g.disponse ();
System.out.println (bufferedimage.getWidth ());
System.out.println (bufferedimage.getheight ());
zurückgepufferterImage;
}
/**
* Format skalieren und konvertieren und speichern
* @param srcPath Source -Pfad
* @param destpath Zielweg
* @param Breite: Zielbreite
* @param Höhe: hohes Ziel
* @param Format: Dateiformat
* @zurückkehren
*/
public static boolean scaletofile (String srcPath, String destpath, int width, inthohe, String -Format) {
boolesche Flagge = Falsch;
versuchen {
Datei Datei = neue Datei (SRCPath);
Datei destfile = new Datei (destpath);
if (! destfile.getParentFile (). existiert ()) {
destfile.getParentFile (). Mkdir ();
}
Bufferedimage src = imageio.read (Datei);
Image Image = src.getScaledInstance (Breite, Höhe, Image.Scale_Default);
Bufferedimage tag = new bufferedimage (width, Höhe, bufferedimage.type_int_rgb);
Grafik g = Tag.getGraphics ();
G.Drawimage (Bild, 0, 0, Null);
g.disponse ();
flag = imageio.write (Tag, Format, neuer FileOutputStream (destfile)); // Ausgabe zum Dateistrom ausgabe
} catch (ioException e) {
E. printstacktrace ();
}
Rückflagge;
}
/**
* Diese Methode skaliert das Bild, das Bild zurückgibt, nachdem das Quellbild nach Prozentsatz skaliert wurde.
* @param InputImage
* @param prozentualanteil zulässiger Input 0 <Prozentsatz <10000
* @zurückkehren
*/
public static bufferedImage scaleBypercentage (bufferedImage InputImage, int Prozent) {
// Prozentsatz erlaubt
if (0> Prozentsatz || Prozentsatz> 10000) {
Neue Imagingopexception werfen ("Fehler :: illegale Parameter: Prozentsatz->"+Prozent+", Prozentsatz sollte größer als 0 ~ weniger als 10000" sein);
}
// Erhalten Sie den Originalbild -Transparenztyp
int type = inputImage.getColormodel (). GetTransparenz ();
// Erhalten Sie die Zielbildgröße
int w = inputImage.getWidth ()*Prozentsatz;
int H = InputImage.Getheight ()*Prozentsatz;
// Offene Anti-Aliasing
RenderingHints RenderingHints = neue RenderingHints (RenderingHints.key_interpolation,
RenderingHINTHINTS.Value_antialias_on);
// Verwenden Sie hochwertige Komprimierung
renderingHints.put (renderingHints.key_interpolation, renderingHints.value_render_quality);
Bufferedimage img = neuer bufferedimage (w, h, type);
Graphics2d Graphics2d = img.createGraphics ();
Graphics2d.SetRenderingHints (RenderingHints);
Graphics2d.Drawimage (InputImage, 0, 0, W, H, 0, 0, InputImage
.Getwidth (), InputImage.Getheight (), null);
Graphics2D.DiSonS ();
zurück img;
/*Dieser Code gibt den Bildtyp zurück
return InputImage.getScaledInstance (InputImage.getWidth ()*Prozentsatz,
inputImage.getheight ()*Prozent, image.scale_smooth);
*/
}
/**
* Skalierende Bild gibt diese Methode das Bild zurück, nachdem das Quellbild unter der gegebenen maximalen Breitgrenze proportional skaliert wurde.
* @param InputImage
* @param maxwidth: maximal zulässige Breite nach der Komprimierung
* @param maxheight: maximal zulässige Höhe nach der Komprimierung
* @throws java.io.ioxception
* zurückkehren
*/
public static bufferedImage scastalbypixelrate (bufferedImage InputImage, int maxwidth, int maxheight) löst Ausnahme {aus {
// Erhalten Sie den Originalbild -Transparenztyp
int type = inputImage.getColormodel (). GetTransparenz ();
int width = inputImage.getWidth ();
int height = inputImage.getheight ();
int newwidth = maxwidth;
int newHeight = maxheight;
// Wenn die angegebene maximale Breite den Anteil überschreitet
if (width*maxheight <Höhe*maxwidth) {
newwidth = (int) (newHeight*width/Höhe);
}
// Wenn die angegebene maximale Höhe den Anteil überschreitet
if (width*maxHeight> Höhe*maxwidth) {
newHeight = (int) (newwidth*Höhe/Breite);
}
// Offene Anti-Aliasing
RenderingHints RenderingHints = neue RenderingHints (RenderingHints.key_interpolation,
RenderingHINTHINTS.Value_antialias_on);
// Verwenden Sie hochwertige Komprimierung
renderingHints.put (renderingHints.key_interpolation, renderingHints.value_render_quality);
Bufferedimage img = new bufferedimage (newwidth, newHeight, type);
Graphics2d Graphics2d = img.createGraphics ();
Graphics2d.SetRenderingHints (RenderingHints);
Graphics2d.Drawimage (InputImage, 0, 0, NewWidth, NewHeight, 0, 0, Breite, Höhe, NULL);
Graphics2D.DiSonS ();
zurück img;
}
/**
* Diese Methode skaliert Bild, diese Methode gibt das Bild zurück, nachdem das Quellbild durch die angegebene Breite und Höhengrenze skaliert wurde.
* @param InputImage
* @param maxwidth: Breite nach der Komprimierung
* @Param MaxHeight: Höhe nach der Komprimierung
* @throws java.io.ioxception
* zurückkehren
*/
public static bufferedImage scaleByPixel (bufferedimage InputImage, int newwidth, int newHeight) löst Ausnahme {aus {
// Erhalten Sie den Originalbild -Transparenztyp
int type = inputImage.getColormodel (). GetTransparenz ();
int width = inputImage.getWidth ();
int height = inputImage.getheight ();
// Offene Anti-Aliasing
RenderingHINDINTS RELENDERINGHINTS = NEUE RELENDERINGHINTS (RenderingHints.key_antialiasing,
RenderingHINTHINTS.Value_antialias_on);
// Verwenden Sie hochwertige Komprimierung
renderingHints.put (renderingHints.key_rendering, renderingHints.value_render_quality);
Bufferedimage img = new bufferedimage (newwidth, newHeight, type);
Graphics2d Graphics2d = img.createGraphics ();
Graphics2d.SetRenderingHints (RenderingHints);
Graphics2d.Drawimage (InputImage, 0, 0, NewWidth, NewHeight, 0, 0, Breite, Höhe, NULL);
Graphics2D.DiSonS ();
zurück img;
}
/**
* Schneiden Sie das Bild aus und geben Sie das Bild im angegebenen Bereich zurück
* @param InputImage
* @param x Startpunkt Horizontale Achse
* @param y Startpunkt vertikale Koordinate
* @param breitgeschnittene Bildbreite: Wenn die Breite das Bild überschreitet, wird es in das Bild von x verbleibender Breite geändert
* @Param Height Cut Bildhöhe: Wenn die Höhe das Bild überschreitet, wird es in die verbleibende Höhe des Bildes geändert
* @Param FILL gibt an, ob die Zielbildgröße die Größe überschreitet.
* @zurückkehren
*/
public static bufferedImage cut (bufferedimage InputImage, int x, int y, int breit, inthöhe, boolean fill) {
// Erhalten Sie den Originalbild -Transparenztyp
int type = inputImage.getColormodel (). GetTransparenz ();
int w = inputImage.getWidth ();
int h = inputImage.getheight ();
int endx = x+width;
int endy = y+Höhe;
if (x> w)
Neue Imagingopexception werfen ("Die horizontale Achse des Startpunkts überschreitet den Bereich des Quellbildes");
if (y> h)
Neue Imagingopexception werfen ("Die vertikale Koordinate des Startpunkts überschreitet den Quellbildbereich");
Bufferedimage img;
// Weiß ausfüllen
if (fill) {
IMG = neuer BufferedImage (Breite, Höhe, Typ);
// Die Breite übersteigt die Grenze
if ((wx) <width) {
width = wx;
endx = w;
}
// Höhe überschreitet die Grenze
if ((hy) <Höhe) {
Höhe = hy;
endy = h;
}
// nicht repariert
}anders{
// Die Breite übersteigt die Grenze
if ((wx) <width) {
width = wx;
endx = w;
}
// Höhe überschreitet die Grenze
if ((hy) <Höhe) {
Höhe = hy;
endy = h;
}
IMG = neuer BufferedImage (Breite, Höhe, Typ);
}
// Offene Anti-Aliasing
RenderingHints RenderingHints = neue RenderingHints (RenderingHints.key_interpolation,
RenderingHINTHINTS.Value_antialias_on);
// Verwenden Sie hochwertige Komprimierung
renderingHints.put (renderingHints.key_interpolation, renderingHints.value_render_quality);
Graphics2d Graphics2d = img.createGraphics ();
Graphics2d.SetRenderingHints (RenderingHints);
Graphics2d.Drawimage (InputImage, 0, 0, Breite, Höhe, x, y, endx, endy, null);
Graphics2D.DiSonS ();
zurück img;
}
/**
* Schneiden Sie das Bild aus und geben Sie die angegebene Startpunktposition und das angegebene Bildgrößenbild zurück
* @param InputImage
* @param Startpoint Startpunkt: Oben links: 0, oben rechts: 10, unten links: 1, unten rechts: 11
* @Param Breite geschnittene Bildbreite
* @Param Height Cut Bildhöhe
* @Param FILL gibt an, ob die Zielbildgröße die Größe überschreitet.
* @zurückkehren
*/
public static bufferedImage cut (bufferedimage InputImage, int -Startpoint, int Breite, inthöhe, boolean fill) {
// Erhalten Sie den Originalbild -Transparenztyp
int type = inputImage.getColormodel (). GetTransparenz ();
int w = inputImage.getWidth ();
int h = inputImage.getheight ();
Bufferedimage img;
// Weiß ausfüllen
if (fill) {
IMG = neuer BufferedImage (Breite, Höhe, Typ);
if (Breite> W)
Breite = w;
if (Höhe> H)
Höhe = H;
// nicht repariert
}anders{
if (Breite> W)
Breite = w;
if (Höhe> H)
Höhe = H;
IMG = neuer BufferedImage (Breite, Höhe, Typ);
}
// Offene Anti-Aliasing
RenderingHints RenderingHints = neue RenderingHints (RenderingHints.key_interpolation,
RenderingHINTHINTS.Value_antialias_on);
// Verwenden Sie hochwertige Komprimierung
renderingHints.put (renderingHints.key_interpolation, renderingHints.value_render_quality);
Graphics2d Graphics2d = img.createGraphics ();
Graphics2d.SetRenderingHints (RenderingHints);
Switch (Startpoint) {
// nach rechts
case Position_upperright:
Graphics2d.Drawimage (InputImage, W-Width, 0, W, Höhe, 0, 0, Breite, Höhe, Null);
brechen;
// links unten
case Position_lowerleft:
Graphics2d.Drawimage (InputImage, 0, H-Höhe, Breite, H, 0, 0, Breite, Höhe, NULL);
brechen;
// unten rechts
case Position_lowerRight:
Graphics2d.Drawimage (InputImage, W-Width, H-Height, W, H, 0, 0, Breite, Höhe, NULL);
brechen;
// Standard links standardmäßig
case Position_upperleft:
Standard:
Graphics2d.Drawimage (InputImage, 0, 0, Breite, Höhe, 0, Breite, Höhe, Null);
}
Graphics2D.DiSonS ();
zurück img;
}
/**
* Drehen Sie das Bild in einem bestimmten Winkel: Verwenden Sie mit Theta den Punkt auf der positiven x-Achse in Richtung der positiven y-Achse.
* @param InputImage
* @param Grad Angle: in Grad
* @zurückkehren
*/
Public Static BufferedImage RotateImage (Final BufferedImage InputImage,
endgültiger int Grad) {
int w = inputImage.getWidth ();
int h = inputImage.getheight ();
int type = inputImage.getColormodel (). GetTransparenz ();
Bufferedimage img = neuer bufferedimage (w, h, type);
Graphics2d Graphics2d = img.createGraphics ();
// Offene Anti-Aliasing
RenderingHints RenderingHints = neue RenderingHints (RenderingHints.key_interpolation,
RenderingHINTHINTS.Value_antialias_on);
// Verwenden Sie hochwertige Komprimierung
renderingHints.put (renderingHints.key_interpolation, renderingHints.value_render_quality);
Graphics2d.SetRenderingHints (RenderingHints);
Graphics2d.Rotate (Math.Toradians (Grad), w / 2, h / 2);
Graphics2D.Drawimage (InputImage, 0, 0, Null);
Graphics2D.DiSonS ();
zurück img;
}
/**
* Drehen Sie das Bild horizontal um
*
* @param bufferedImage Zielbild
* @zurückkehren
*/
public static bufferedImage Fliphorizontalimage (endgültige Bufferedimage InputImage) {
int w = inputImage.getWidth ();
int h = inputImage.getheight ();
Bufferedimage img;
Graphics2d Graphics2d;
(Graphics2d = (IMG = New BufferedImage (W, H, InputImage
.GetColormodel (). getTransparent ())). createGraphics ())
.Drawimage (InputImage, 0, 0, W, H, W, 0, 0, H, Null);
Graphics2D.DiSonS ();
zurück img;
}
/**
* Drehen Sie das Bild vertikal um
*
* @param bufferedImage Zielbild
* @zurückkehren
*/
public static bufferedImage FlipverticalImage (endgültige BufferedImage InputImage) {
int w = inputImage.getWidth ();
int h = inputImage.getheight ();
Bufferedimage img;
Graphics2d Graphics2d;
(Graphics2d = (IMG = New BufferedImage (W, H, InputImage
.GetColormodel (). getTransparent ())). createGraphics ())
.Drawimage (InputImage, 0, 0, W, H, 0, H, W, 0, Null);
Graphics2D.DiSonS ();
zurück img;
}
/**
* Bild Wasserzeichen
*
* @param InputImage
* Bilder zu verarbeiten
* @param markimage
* Wasserzeichenbild
* @param x
* Das Wasserzeichen befindet sich in der oberen linken Ecke des Bildes.
* @param y
* Das Wasserzeichen befindet sich in der oberen linken Ecke des Bildes.
* @param alpha
* Wasserzeichentransparenz 0,1F ~ 1,0F
* *//
öffentliches statisches Bufferedimage -Wasserzeichen (BufferedImage InputImage, BufferedImage Markimage, Int X, Int y,
float alpha) {
Bufferedimage image = new bufferedImage (inputImage.getWidth (), InputImage
.Getheight (), bufferedimage.type_int_argb);
Graphics2d g = Bild.CreateGraphics ();
G.Drawimage (InputImage, 0, 0, Null);
// laden Sie das Wasserzeichenbild
G.SetComposite (Alphacomposite.getInstance (Alphacomposite.src_atop,,
Alpha));
g.drawimage (markimage, x, y, null);
g.disponse ();
Return Image;
}
/**
* Textwasserzeichen
*
* @param InputImage
* Bilder zu verarbeiten
* @param Text
* Wasserzeichen Text
* @param Schriftart
* Information von Wasserzeichen Schriftart
* @param Farbe
* Wasserzeichen -Schriftfarbe
* @param x
* Das Wasserzeichen befindet sich in der oberen linken Ecke des Bildes.
* @param y
* Das Wasserzeichen befindet sich in der oberen linken Ecke des Bildes.
* @param alpha
* Wasserzeichentransparenz 0,1F ~ 1,0F
*/
Public Static BufferedImage Textmark (BufferedImage InputImage, Stringtext, Schriftart der Schriftart,
Farbfarbe, int x, int y, float alpha) {
Font dfont = (font == null)?
Bufferedimage image = new bufferedImage (inputImage.getWidth (), InputImage
.Getheight (), bufferedimage.type_int_argb);
Graphics2d g = Bild.CreateGraphics ();
G.Drawimage (InputImage, 0, 0, Null);
G.SetColor (Farbe);
G.SetFont (DFONT);
G.SetComposite (Alphacomposite.getInstance (Alphacomposite.src_atop,,
Alpha));
G.Drawstring (Text, x, y);
g.disponse ();
Return Image;
}
/**
* Bildfarbe zu Schwarz und Weiß
* @param InputImage
* @Return konvertiertes PufferedImage
*/
öffentliches endgültiges statisches Bufferedimage -Togray (BufferedImage InputImage)
{
ColorSpace CS = ColorSpace.getInstance (ColorSpace.cs_gray);
// Farbkonvertierung von Quellgepufferter. Wenn das Zielbild null ist,
// Erstellen Sie eine gepufferte Aufgabe, die auf dem entsprechenden Colormodel basiert.
ColorConvertop op = new ColorConvertop (CS, NULL);
return op.filter (InputImage, NULL);
}
/**
* Bildfarbe wird schwarz und weiß
* @param srcimageFile
* Quellbildadresse
* @param destimageFile
* Zielbildadresse
* @param formattype
* Zielbildformat: Wenn Formattype null ist;
*/
öffentliches endgültiges statisches Leerzeichen (String srcimageFile, String destimageFile, String -Formattype)
{
versuchen
{
Bufferedimage src = imageio.read (neue Datei (srcimageFile));
ColorSpace CS = ColorSpace.getInstance (ColorSpace.cs_gray);
ColorConvertop op = new ColorConvertop (CS, NULL);
src = op.filter (src, null);
// Wenn Formattype null ist;
if (formattype == null) {
formattype = "png";
}
Imageio.Write (SRC, FormatType, neue Datei (DestimageFile));
} catch (ioException e)
{
E. printstacktrace ();
}
}
/**
* Konvertierung des Bildtyps: Gif-> JPG, GIF-> PNG, PNG-> JPG, PNG-> GIF (X), BMP-> PNG
*
* @param InputImage
* Quellbildadresse
* @param formattype
* Zeichenfolge mit informellen Namen von Formaten: wie JPG, JPEG, GIF usw.
* @param destimageFile
* Zielbildadresse
*/
Öffentliche endgültige statische Leere Konvertierung (BufferedImage InputImage, String FormatType, String DestimageFile)
{
versuchen
{
ImageIo.Write (InputImage, FormatType, neue Datei (DestimageFile));
} catch (Ausnahme E)
{
E. printstacktrace ();
}
}
/**
* Bildschneidung (Geben Sie die Anzahl der Zeilen und Spalten von Scheiben an)
*
* @param srcimageFile
* Quellbildadresse
* @param destdir
* Schneiden Sie den Zielordner an
* @param formattype
* Zielformat
* @param Zeilen
* Anzahl der Zeilen von Zielscheiben. Standard 2 muss innerhalb von Reichweite liegen [1, 20]
* @param cols
* Anzahl der Spalten der Zielscheiben. Standard 2 muss innerhalb von Reichweite liegen [1, 20]
*/
öffentliche endgültige statische Leereausschnitt (BufferedImage InputImage, String Destdir,
String -Formattype, int Zeilen, int cols)
{
versuchen
{
if (Zeilen <= 0 || Zeilen> 20)
Zeilen = 2;
if (cols <= 0 || cols> 20)
cols = 2;
// Quellbild lesen
// bufferedimage bi = imageio.read (neue Datei (srcimageFile));
int w = inputImage.getheight ();
int h = inputImage.getWidth ();
if (w> 0 && h> 0)
{
Bild img;
ImageFilter Curtfilter;
Image Image = inputImage.getScaledInstance (W, H,
Image.Scale_Default);
int destwidth = w;
int destheeight = h;
// Berechnen Sie die Breite und Höhe der Scheibe
if (w % cols == 0)
{
destwidth = w / cols;
} anders
{
destwidth = (int) math.floor (w / cols) + 1;
}
if (H % Zeilen == 0)
{
Destheeight = H / Zeilen;
} anders
{
Destheight = (int) math.floor (h / Zeilen) + 1;
}
// Scheiben in der Schleife erstellen
// Idee der Verbesserung: Ob Multithreading verwendet werden kann, um die Schnittgeschwindigkeit zu beschleunigen
für (int i = 0; i <Zeilen; i ++)
{
für (int j = 0; j <cols; j ++)
{
// Die vier Parameter sind die Ausgangspunktkoordinate von Bild, Breite und Höhe
// Das heißt: CropimageFilter (int x, int y, int breit, inthöhe)
Curtfilter = neuer CropimageFilter (j * destwidth, i
* Destheeight, Destwidth, Destheeight);
IMG = Toolkit.getDefaulttoolkit (). createImage (
Neue Filteredimagesource (Image.getSource (),
Curtfilter));
BufferedImage -Tag = neuer BufferedImage (Destwidth,
Destheeight, bufferedimage.type_int_argb);
Grafik g = Tag.getGraphics ();
G.Drawimage (IMG, 0, 0, NULL);
g.disponse ();
// Ausgabe als Datei
Imageio.write (Tag, FormatType, neue Datei (destdir + "_r" + i
+ "_c" + j + "." + formattype.tolowerCase ()));
}
}
}
} catch (Ausnahme E)
{
E. printstacktrace ();
}
}
/**
* Fügen Sie dem Bild Textwasserzeichen hinzu
*
* @Param PressText
* Wasserzeichen Text
* @param srcimageFile
* Quellbildadresse
* @param destimageFile
* Zielbildadresse
* @param fontName
* Schriftart des Wasserzeichens
* @param fontStyle
* Schriftstil des Wasserzeichens
* @param Farbe
* Schriftfarbe des Wasserzeichens
* @param fontsize
* Schriftgröße des Wasserzeichens
* @param x
* Korrigierter Wert
* @param y
* Korrigierter Wert
* @param alpha
* Transparenz: Alpha muss eine schwimmende Punktzahl innerhalb des Bereichs [0,0, 1,0] sein (einschließlich der Grenzwerte)
* @param formattype
* Zielformat
*/
public Final Static Void PressTeText (String PressText, String srcimageFile,
String destimageFile, String FontName, int fontStyle, Farbe, Farbe,
int fontsize, int x, int y, float alpha, String -Formattype)
{
versuchen
{
Datei img = neue Datei (srcimageFile);
Bild src = imageio.read (IMG);
int width = src.getwidth (null);
int height = src.getheight (null);
Bufferedimage Bild = neuer BufferedImage (Breite, Höhe,
Bufferedimage.type_int_argb);
Graphics2d g = Bild.CreateGraphics ();
G.Drawimage (SRC, 0, 0, Breite, Höhe, Null);
G.SetColor (Farbe);
G.SetFont (neue Schriftart (FontName, fontStyle, fontsize));
G.SetComposite (Alphacomposite.getInstance (Alphacomposite.src_atop,,
Alpha));
// Wasserzeichen -Text in bestimmten Koordinaten zeichnen
g.drawstring (pressText, (width - (getLength (pressText) * fontsize))
/ 2 + x, (Höhe - fontsize) / 2 + y);
g.disponse ();
Imageio.Write ((BufferedImage) Bild, Formattype,
Neue Datei (DestimageFile)); // Ausgabe zum Dateistrom ausgabe
} catch (Ausnahme E)
{
E. printstacktrace ();
}
}
/**
* Fügen Sie dem Bild Bild Wasserzeichen hinzu
*
* @param pressimg
* Wasserzeichenbild
* @param srcimageFile
* Quellbildadresse
* @param destimageFile
* Zielbildadresse
* @param x
* Fester Wert. Standard ist in der Mitte
* @param y
* Fester Wert. Standard ist in der Mitte
* @param alpha
* Transparenz: Alpha muss eine schwimmende Punktzahl innerhalb des Bereichs [0,0, 1,0] sein (einschließlich der Grenzwerte)
* @param formattype
* Zielformat
*/
öffentliche endgültige statische Leere Pressimage (String Pressimg, String SrcimageFile,
String destimageFile, int x, int y, float alpha, String -Formattype)
{
versuchen
{
Datei img = neue Datei (srcimageFile);
Bild src = imageio.read (IMG);
int wideth = src.getwidth (null);
int height = src.getheight (null);
Bufferedimage Bild = neuer Bufferedimage (Wideth, Höhe,
Bufferedimage.type_int_argb);
Graphics2d g = Bild.CreateGraphics ();
G.Drawimage (SRC, 0, 0, Wideth, Höhe, Null);
// Wasserzeichendatei
Bild src_biao = imageio.read (neue Datei (Pressimg));
int wideth_biao = src_biao.getwidth (null);
int height_biao = src_biao.getheight (null);
G.SetComposite (Alphacomposite.getInstance (Alphacomposite.src_atop,,
Alpha));
g.drawimage (src_biao, (wideth - wideth_biao) / 2,
(Höhe - Höhe_Biao) / 2, wideth_biao, height_biao, null);
// Ende der Wasserzeichendatei
g.disponse ();
Imageio.Write ((BufferedImage) Bild, Formattype,
neue Datei (DestimageFile));
} catch (Ausnahme E)
{
E. printstacktrace ();
}
}
/**
* Berechnen Sie die Textlänge (ein chinesischer zählt zwei Zeichen)
*
* @param Text
* @zurückkehren
*/
öffentliche endgültige statische Int GetLength (Stringtext)
{
int länge = 0;
für (int i = 0; i <text.length (); i ++)
{
if (neuer String (text.charat (i) + "") .getBytes (). Länge> 1)
{
Länge += 2;
} anders
{
Länge += 1;
}
}
Rücklauflänge / 2;
}
}
Sehr praktische Bildverarbeitungsfunktion, ich hoffe es gefällt euch.