このツールクラスの機能：画像のズーム、画像の切断、画像タイプの変換、白黒の色、テキスト透かし、画像の透かしなど。
コードコピーは次のとおりです。
パッケージnet.kitbox.util;
java.awt.alphacompositeをインポートします。
java.awt.colorをインポートします。
java.awt.fontをインポートします。
java.awt.graphicsをインポートします。
java.awt.graphics2dをインポートします。
java.awt.imageをインポートします。
Java.awt.RenderingHintsをインポートします。
java.awt.toolkitをインポートします。
java.awt.color.colorspaceをインポートします。
java.awt.image.bufferedimageをインポートします。
java.awt.image.colorconvertopをインポートします。
java.awt.image.cropimagefilterをインポートします。
java.awt.image.filteredimagesourceをインポートします。
java.awt.image.imagefilterをインポートします。
java.awt.image.imagingopexceptionをインポートします。
java.io.fileをインポートします。
java.io.fileoutputStreamをインポートします。
java.io.ioexceptionをインポートします。
javax.imageio.imageioをインポートします。
/**
*著者：Lldy
*時間：2012-5-6 6:37:18 PM
*画像処理ツールカテゴリ：<br>
*機能：ズーム画像、カット画像、画像タイプの変換、色から白黒、テキスト透かし、画像の透かしなど。
*/
パブリッククラスのImageUtils {
/**
*写真の位置に関連しています
*/
private static final int position_upperleft = 0;
private static final int position_upperright = 10;
プライベート静的最終int position_lowerleft = 1;
プライベート静的最終int position_lowerright = 11;
/**
*いくつかの一般的な画像形式
*/
public static string image_type_gif = "gif"; //グラフィック交換形式
public static string image_type_jpg = "jpg"; //共同写真の専門家グループ
public static string image_type_jpeg = "jpeg"; //共同写真の専門家グループ
public static string image_type_bmp = "bmp"; //英語Bitmap（bitmap）、これはWindowsオペレーティングシステムの標準画像ファイル形式です
public static string image_type_png = "png"; //ポータブルネットワークグラフィックス
Private Static ImageUtilsインスタンス。
privateImageUtils（）{
instance = this;
}
/**
*インスタンスを取得します
* @戻る
*/
public static imageutils getInstance（）{
if（instance == null）{
instance = new ImageUtils（）;
}
インスタンスを返す;
}
public bufferedimage image2bufferedimage（画像）{
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（画像、null、null）;
g.dispose（）;
system.out.println（bufferedimage.getWidth（））;
system.out.println（bufferedimage.getheight（））;
bufferedimageを返します。
}
/**
*フォーマットを拡大および変換し、保存します
* @Param SRCPATHソースパス
* @Param DestPathターゲットパス
* @param幅：ターゲット幅
* @Param Height：高ターゲット
* @param形式：ファイル形式
* @戻る
*/
public static boolean scaletofile（string srcpath、string destpath、int width、int height、string形式）{
ブールフラグ= false;
試す {
file file = new file（srcpath）;
ファイルdestfile = new File（destPath）;
if（！destfile.getParentFile（）。exists（））{
destfile.getParentFile（）。mkdir（）;
}
bufferedimage src = imageio.read（file）;
画像画像= src.getScaledInstance（幅、高さ、image.scale_default）;
bufferedimage tag = new BufferedImage（幅、高さ、bufferedimage.type_int_rgb）;
グラフィックg = tag.getgraphics（）;
G.Drawimage（Image、0、0、Null）;
g.dispose（）;
flag = imageio.write（tag、format、new fileoutputStream（destfile））; //ファイルストリームへの出力
} catch（ioException e）{
e.printstacktrace（）;
}
フラグを返します。
}
/**
*スケール画像、このメソッドは、ソース画像がパーセンテージでスケーリングされた後に画像を返します。
* @param inputImage
* @paramパーセンテージ許容入力0 <パーセンテージ<10000
* @戻る
*/
public static bufferedimage scalebypercentage（bufferedimage inputimage、intパーセンテージ）{
//許可された割合
if（0>パーセンテージ||パーセンテージ> 10000）{
新しいImagimingopexception（ "error ::違法パラメーター：パーセンテージ - >"+パーセンテージ+"、パーセンテージは0〜10000未満である必要があります）;
}
//元の画像透明度タイプを取得します
int type = inputImage.getColormodel（）。getTransparency（）;
//ターゲット画像サイズを取得します
int w = inputimage.getWidth（）*パーセンテージ;
int h = inputimage.getheigh（）*パーセンテージ;
//アンチアリアシングを開きます
renderinghints renderinghints = new renderinghints（renderinghints.key_interpolation、
renderinghints.value_antialias_on）;
//高品質の圧縮を使用します
renderinghints.put（renderinghints.key_interpolation、renderinghints.value_render_quality）;
BufferedImage IMG = new BuffereDimage（W、H、Type）;
Graphics2d Graphics2d = img.creategraphics（）;
graphics2d.setrenderinghints（renderinghints）;
Graphics2d.drawimage（inputimage、0、0、w、h、0、0、inputImage
.getWidth（）、inputimage.getheigh（）、null）;
graphics2d.dispose（）;
IMGを返します。
/*このコードは画像タイプを返します
inputImage.getScaledInstance（inputImage.getWidth（）*パーセンテージ、
inputImage.getheight（）*パーセンテージ、image.scale_smooth）;
*/
}
/**
*画像のスケーリング、このメソッドは、特定の最大幅の制限の下でソース画像が比例してスケーリングされた後に画像を返します。
* @param inputImage
* @Param MaxWidth：圧縮後の最大許容幅
* @param maxheight：圧縮後の最大許容高さ
* @Throws java.io.ioexception
* 戻る
*/
public static bufferedimage scallebypixelrate（bufferedimage inputimage、int maxwidth、int maxheight）をスローする{
//元の画像透明度タイプを取得します
int type = inputImage.getColormodel（）。getTransparency（）;
int width = inputimage.getWidth（）;
int height = inputImage.getheigh（）;
int newWidth = maxwidth;
int newheight = maxheight;
//指定された最大幅が割合を超える場合
if（width*maxheight <height*maxwidth）{
newWidth =（int）（newHeight*width/height）;
}
//指定された最大高さが割合を超える場合
if（width*maxheight> height*maxwidth）{
newHeight =（int）（newWidth*高さ/幅）;
}
//アンチアリアシングを開きます
renderinghints renderinghints = new renderinghints（renderinghints.key_interpolation、
renderinghints.value_antialias_on）;
//高品質の圧縮を使用します
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、width、height、null）;
graphics2d.dispose（）;
IMGを返します。
}
/**
*画像のスケーリング、このメソッドは、特定の幅と高さの制限によってソース画像がスケーリングされた後に画像を返します。
* @param inputImage
* @param maxwidth：圧縮後の幅
* @param maxheight：圧縮後の高さ
* @Throws java.io.ioexception
* 戻る
*/
public static bufferedimage scalebypixel（bufferedimage inputimage、int newwidth、int newheight）をスローする{
//元の画像透明度タイプを取得します
int type = inputImage.getColormodel（）。getTransparency（）;
int width = inputimage.getWidth（）;
int height = inputImage.getheigh（）;
//アンチアリアシングを開きます
renderinghints renderinghints = new renderinghints（renderinghints.key_antialiasing、
renderinghints.value_antialias_on）;
//高品質の圧縮を使用します
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、width、height、null）;
graphics2d.dispose（）;
IMGを返します。
}
/**
*画像をカットし、指定された範囲で画像を返します
* @param inputImage
* @param x出発点水平軸
* @param y開始点垂直座標
* @param widthカット画像幅：幅が画像を超えた場合、xの残りの幅から画像に変更されます
* @param高さの画像の高さ：高さが画像を超えた場合、画像の残りの高さに変更されます
* @param fillターゲットの画像がサイズを超える場合、falseが充填されないことを意味します。
* @戻る
*/
public static bufferedimageカット（bufferedimage inputimage、int x、int y、int width、int height、boolean fill）{
//元の画像透明度タイプを取得します
int type = inputImage.getColormodel（）。getTransparency（）;
int w = inputimage.getWidth（）;
int h = inputimage.getheight（）;
int endx = x+width;
int endy = y+height;
if（x> w）
新しいImagimingopexception（「開始点の水平軸は、ソース画像の範囲を超えています」）を投げます）;
if（y> h）
新しいImagIngingopexception（「開始点の垂直座標がソース画像範囲を超える」）を投げる）;
BufferedImage IMG;
//白を埋めます
if（fill）{
IMG = new BuffereDimage（幅、高さ、タイプ）;
//幅は制限を超えます
if（（wx）<width）{
width = wx;
endx = w;
}
//高さは制限を超えています
if（（hy）<height）{
height = hy;
endy = h;
}
//修理されていません
}それ以外{
//幅は制限を超えます
if（（wx）<width）{
width = wx;
endx = w;
}
//高さは制限を超えています
if（（hy）<height）{
height = hy;
endy = h;
}
IMG = new BuffereDimage（幅、高さ、タイプ）;
}
//アンチアリアシングを開きます
renderinghints renderinghints = new renderinghints（renderinghints.key_interpolation、
renderinghints.value_antialias_on）;
//高品質の圧縮を使用します
renderinghints.put（renderinghints.key_interpolation、renderinghints.value_render_quality）;
Graphics2d Graphics2d = img.creategraphics（）;
graphics2d.setrenderinghints（renderinghints）;
Graphics2d.drawimage（inputImage、0、0、width、height、x、y、endx、endy、null）;
graphics2d.dispose（）;
IMGを返します。
}
/**
*画像をカットし、指定された開始点位置と指定されたサイズの画像を返します
* @param inputImage
* @paramスタートポイント開始点：左上：0、右上：10、左下：1、右下：11
* @param widthカット画像幅
* @param高さの画像の高さ
* @param fillターゲットの画像がサイズを超える場合、falseが充填されないことを意味します。
* @戻る
*/
public static bufferedimageカット（bufferedimage inputimage、int startpoint、int width、int height、boolean fill）{
//元の画像透明度タイプを取得します
int type = inputImage.getColormodel（）。getTransparency（）;
int w = inputimage.getWidth（）;
int h = inputimage.getheight（）;
BufferedImage IMG;
//白を埋めます
if（fill）{
IMG = new BuffereDimage（幅、高さ、タイプ）;
if（width> w）
width = w;
if（height> h）
高さ= h;
//修理されていません
}それ以外{
if（width> w）
width = w;
if（height> h）
高さ= h;
IMG = new BuffereDimage（幅、高さ、タイプ）;
}
//アンチアリアシングを開きます
renderinghints renderinghints = new renderinghints（renderinghints.key_interpolation、
renderinghints.value_antialias_on）;
//高品質の圧縮を使用します
renderinghints.put（renderinghints.key_interpolation、renderinghints.value_render_quality）;
Graphics2d Graphics2d = img.creategraphics（）;
graphics2d.setrenderinghints（renderinghints）;
switch（startpoint）{
//右に
case position_upperright：
Graphics2d.drawimage（inputimage、w-width、0、w、height、0、0、width、height、null）;
壊す;
//左下
case position_lowerleft：
Graphics2d.drawimage（inputImage、0、h-height、width、h、0、0、width、height、null）;
壊す;
//右下
ケースPosition_lowerright：
Graphics2d.drawimage（inputimage、w-width、h-height、w、h、0、0、width、height、null）;
壊す;
//左上のデフォルト
case position_upperleft：
デフォルト：
Graphics2d.drawimage（inputImage、0、0、width、height、0、width、height、null）;
}
graphics2d.dispose（）;
IMGを返します。
}
/**
*指定された角度で画像を回転します。Thetaを使用して、正のX軸の点を正のY軸に向けて回転させます。
* @param inputImage
* @param学位角度：程度
* @戻る
*/
public static bufferedimage rotateimage（最終的な緩衝液入力項目、
最終的な学位）{
int w = inputimage.getWidth（）;
int h = inputimage.getheight（）;
int type = inputImage.getColormodel（）。getTransparency（）;
BufferedImage IMG = new BuffereDimage（W、H、Type）;
Graphics2d Graphics2d = img.creategraphics（）;
//アンチアリアシングを開きます
renderinghints renderinghints = new renderinghints（renderinghints.key_interpolation、
renderinghints.value_antialias_on）;
//高品質の圧縮を使用します
renderinghints.put（renderinghints.key_interpolation、renderinghints.value_render_quality）;
graphics2d.setrenderinghints（renderinghints）;
graphics2d.rotate（math.toradians（degree）、w / 2、h / 2）;
graphics2d.drawimage（inputimage、0、0、null）;
graphics2d.dispose（）;
IMGを返します。
}
/**
*画像を水平に裏返します
*
* @param bufferedimageターゲット画像
* @戻る
*/
public static bufferedimage fliphorizontalimage（最終的な緩衝留めintimage）{
int w = inputimage.getWidth（）;
int h = inputimage.getheight（）;
BufferedImage IMG;
Graphics2d Graphics2d;
（Graphics2d =（img = new BufferedImage（W、H、inputImage」
.getColormodel（）。getTransparency（））。creategraphics（）））
.drawimage（inputImage、0、0、w、h、w、w、0、0、h、null）;
graphics2d.dispose（）;
IMGを返します。
}
/**
*画像を垂直に裏返します
*
* @param bufferedimageターゲット画像
* @戻る
*/
public static bufferedimage flipverticalimage（最終的な緩衝液入力）{
int w = inputimage.getWidth（）;
int h = inputimage.getheight（）;
BufferedImage IMG;
Graphics2d Graphics2d;
（Graphics2d =（img = new BufferedImage（W、H、inputImage」
.getColormodel（）。getTransparency（））。creategraphics（）））
.drawimage（inputImage、0、0、w、h、0、h、w、w、0、null）;
graphics2d.dispose（）;
IMGを返します。
}
/**
*ピクチャーウォーターマーク
*
* @param inputImage
*処理する画像
* @param Markimage
*透かし画像
* @param x
*透かしは、写真の左上隅にあります。
* @param y
*透かしは、Y座標値の左上隅にあります
* @Param Alpha
*透明度0.1f〜1.0f
* */
public static bufferedimage透かし（bufferedimage inputimage、bufferedimage markimage、int x、int y、
float alpha）{
bufferedimage image = new bufferedimage（inputimage.getWidth（）、inputImage
.getheight（）、bufferedimage.type_int_argb）;
graphics2d g = image.creategraphics（）;
g.drawimage（inputImage、0、0、null）;
//ウォーターマーク画像をロードします
g.setComposite（alphacomposite.getInstance（alphacomposite.src_atop）
アルファ））;
G.drawimage（Markimage、x、y、null）;
g.dispose（）;
画像を返します。
}
/**
*テキスト透かし
*
* @param inputImage
*処理する画像
* @paramテキスト
*透かしテキスト
* @paramフォント
*透かし式フォント情報
* @param色
*透かし式フォントの色
* @param x
*透かしは、写真の左上隅にあります。
* @param y
*透かしは、Y座標値の左上隅にあります
* @Param Alpha
*透明度0.1f〜1.0f
*/
public static bufferedimageテキストマーク（bufferedimage inputimage、string text、font font、
色の色、int x、int y、float alpha）{
font dfont =（font == null）？
bufferedimage image = new bufferedimage（inputimage.getWidth（）、inputImage
.getheight（）、bufferedimage.type_int_argb）;
graphics2d g = image.creategraphics（）;
g.drawimage（inputImage、0、0、null）;
G.SetColor（色）;
g.setfont（dfont）;
g.setComposite（alphacomposite.getInstance（alphacomposite.src_atop）
アルファ））;
G.DrawString（Text、X、Y）;
g.dispose（）;
画像を返します。
}
/**
*画像の色から白黒
* @param inputImage
* @return変換されたbufferedimage
*/
パブリック最終静的bufferedimage togray（bufferedimage inputimage）
{
Colorspace cs = colorspace.getInstance（colorspace.cs_gray）;
//ソースBufferedImageの色変換。ターゲット画像がnullの場合、
//適切なColormodelに基づいてBufferedImageを作成します。
ColorConvertop op = new ColorConvertop（CS、NULL）;
return op.filter（inputImage、null）;
}
/**
*画像の色は白黒になります
* @param srcimagefile
*ソース画像アドレス
* @param destimagefile
*ターゲット画像アドレス
* @param formattype
*ターゲット画像形式：formattypeがnullの場合
*/
public final static void togray（string srcimagefile、string destimagefile、string formattype）
{
試す
{
bufferedimage src = imageio.read（new file（srcimageFile））;
Colorspace cs = colorspace.getInstance（colorspace.cs_gray）;
ColorConvertop op = new ColorConvertop（CS、NULL）;
src = op.filter（src、null）;
// formattypeがnullの場合
if（formattype == null）{
formattype = "png";
}
Imageio.write（src、formattype、new file（destimageFile））;
} catch（ioexceptione）
{
e.printstacktrace（）;
}
}
/**
*画像タイプ変換：gif-> jpg、gif-> png、png-> jpg、png-> gif（x）、bmp-> png
*
* @param inputImage
*ソース画像アドレス
* @param formattype
*フォーマットの非公式名を含む文字列：JPG、JPEG、GIFなど。
* @param destimagefile
*ターゲット画像アドレス
*/
public final static void convert（bufferedimage inputimage、string formattype、string destimageFile）
{
試す
{
Imageio.write（inputImage、formattype、new file（destimageFile））;
} catch（例外e）
{
e.printstacktrace（）;
}
}
/**
*画像切断（スライスの行と列の数を指定）
*
* @param srcimagefile
*ソース画像アドレス
* @param destdir
*ターゲットフォルダーをスライスします
* @param formattype
*ターゲット形式
* @param rows
*ターゲットスライスの行数。デフォルト2は範囲内でなければなりません[1、20]
* @Param Cols
*ターゲットスライス列の数。デフォルト2は範囲内でなければなりません[1、20]
*/
パブリック最終静的ボイドカット（bufferedimage inputimage、string destdir、
string formattype、int rows、int cols）
{
試す
{
if（rows <= 0 || rows> 20）
行= 2; //スライスの数
if（cols <= 0 || cols> 20）
cols = 2; //スライス列の数
//ソース画像を読みます
// bufferedimage bi = imageio.read（new file（srcimageFile））;
int w = inputimage.getheight（）;
int h = inputimage.getWidth（）;
if（w> 0 && h> 0）
{
画像IMG;
ImageFilter CropFilter;
画像画像= inputImage.getScaledInstance（W、H、
image.scale_default）;
int destwidth = w; //幅
int destheight = h; //各スライスの高さ
//スライスの幅と高さを計算します
if（w％cols == 0）
{
destWidth = w / col;
} それ以外
{
destWidth =（int）math.floor（w / cols） + 1;
}
if（h％rows == 0）
{
destheight = h / rows;
} それ以外
{
destheight =（int）math.floor（h / rows） + 1;
}
//ループでスライスを作成します
//改善のアイデア：マルチスレッドを使用して切断速度を高速化できるかどうか
for（int i = 0; i <rows; i ++）
{
for（int j = 0; j <cols; j ++）
{
// 4つのパラメーターは、画像開始ポイント座標と幅と高さです
//つまり：cropimagefilter（int x、int y、int width、int height）
cropfilter = new CropimageFilter（j * destWidth、i
* Destheight、DestWidth、DestHeight）;
img = toolkit.getDefaultToolkit（）。createimage（
new filteredimagesource（image.getSource（）、
cropfilter））;
bufferedimageタグ= new bufferedimage（destwidth、
destheight、bufferedimage.type_int_argb）;
グラフィックg = tag.getgraphics（）;
G.Drawimage（IMG、0、0、null）;
g.dispose（）;
//ファイルとして出力
imageio.write（tag、formattype、new file（destdir + "_r" + i
+ "_c" + j + "。" + formattype.tolowercase（）））;
}
}
}
} catch（例外e）
{
e.printstacktrace（）;
}
}
/**
*写真にテキストの透かしを追加します
*
* @param presstext
*透かしテキスト
* @param srcimagefile
*ソース画像アドレス
* @param destimagefile
*ターゲット画像アドレス
* @param fontname
*透かしのフォント名
* @param fontstyle
*透かしのフォントスタイル
* @param色
*透かしのフォント色
* @param fontsize
*透かしのフォントサイズ
* @param x
*修正値
* @param y
*修正値
* @Param Alpha
*透明性：アルファは範囲内の浮動小数点数[0.0、1.0]でなければなりません（境界値を含む）
* @param formattype
*ターゲット形式
*/
public final static void presstext（string presstext、string srcimagefile、
文字列destimageFile、string fontname、int fontstyle、color Color、
int fontsize、int x、int y、float alpha、string formattype）
{
試す
{
ファイルimg = new file（srcimageFile）;
画像src = imageio.read（img）;
int width = src.getWidth（null）;
int height = src.getheight（null）;
bufferedimage画像=新しいbufferedimage（幅、高さ、
bufferedimage.type_int_argb）;
graphics2d g = image.creategraphics（）;
G.Drawimage（SRC、0、0、幅、高さ、ヌル）;
G.SetColor（色）;
g.setFont（new Font（fontname、fontstyle、fontsize））;
g.setComposite（alphacomposite.getInstance（alphacomposite.src_atop）
アルファ））;
//指定された座標で透かしテキストを描画します
G.DrawString（pressText、（width-（getLength（pressText） * fontsize）））
/ 2 + x、（height -fontsize） / 2 + y）;
g.dispose（）;
Imageio.write（（bufferedimage）画像、formattype、
新しいファイル（DestImageFile））; //ファイルストリームへの出力
} catch（例外e）
{
e.printstacktrace（）;
}
}
/**
*画像に画像の透かしを追加します
*
* @param pressimg
*透かしの写真
* @param srcimagefile
*ソース画像アドレス
* @param destimagefile
*ターゲット画像アドレス
* @param x
*固定値。 デフォルトは中央にあります
* @param y
*固定値。 デフォルトは中央にあります
* @Param Alpha
*透明性：アルファは範囲内の浮動小数点数[0.0、1.0]でなければなりません（境界値を含む）
* @param formattype
*ターゲット形式
*/
public final static void pressimage（string pressimg、string srcimagefile、
文字列DestimageFile、int x、int y、float alpha、string formattype）
{
試す
{
ファイルimg = new file（srcimageFile）;
画像src = imageio.read（img）;
int wideth = src.getWidth（null）;
int height = src.getheight（null）;
bufferedimage画像=新しいbufferedimage（wideth、height、
bufferedimage.type_int_argb）;
graphics2d g = image.creategraphics（）;
G.drawimage（Src、0、0、Wideth、height、null）;
//透かしファイル
画像src_biao = imageio.read（new file（pressimg））;
int wideth_biao = src_biao.getWidth（null）;
int height_biao = src_biao.getheight（null）;
g.setComposite（alphacomposite.getInstance（alphacomposite.src_atop）
アルファ））;
G.drawimage（src_biao、（wideth -wideth_biao） / 2、
（height -height_biao） / 2、wideth_biao、height_biao、null）;
//透かしファイルの終わり
g.dispose（）;
Imageio.write（（bufferedimage）画像、formattype、
新しいファイル（DestImageFile））;
} catch（例外e）
{
e.printstacktrace（）;
}
}
/**
*テキストの長さを計算します（1人の中国人が2文字を数えます）
*
* @paramテキスト
* @戻る
*/
public final static int getLength（文字列テキスト）
{
int length = 0;
for（int i = 0; i <text.length（）; i ++）
{
if（new String（text.Charat（i） + ""）.getBytes（）。長さ> 1）
{
長さ += 2;
} それ以外
{
長さ += 1;
}
}
RETURN LENGTH / 2;
}
}
非常に実用的な画像処理機能、あなたがそれを気に入ってくれることを願っています。