項目記錄：
1.圖像原理
通常圖像都是2D，對一副圖像，可以看做其寬ｗ＊高ｈ的一個二維數組， 即 圖像＝int[w][h]，在ｗ和ｈ位置的每一個 int 值，就是這個點的像素值。
圖像處理的本質是：對代表圖像二維數組中的值進行重新計算。
2.思路：
將一張圖片轉化成一個int型癿二維數組
對于每一個像素點大小和顏色進行計算達到圖像處理的效果。
在畫筆中設置好顏色，填充形狀然后將新的圖片畫出。
3.實現效果
獲取像素點方法，首先利用文件imageIO讀取圖片，然后根據圖片長寬進行遍歷得到每個像素點的顏色，最后return一個二維數組為處理做準備。
/**
* 根據圖片路徑，獲取該該圖片的每個像素點并保存到對應的二維數組中
* @param path 圖片路徑
* @return 保存像素點的二維數組
*/
public int[][] getImgPixel(String path){
File file = new File(path);
BufferedImage buffImg = null; //緩沖圖片
try {
buffImg = ImageIO.read(file);
} catch (IOException e) {
e.printStackTrace();
}
int w = buffImg.getWidth();
int h = buffImg.getHeight();
//定義二維數組，保存像素點
int[][] pixelArray = new int[w][h];
//讀取每個位置的像素點
for(int i=0;i<w;i++){
for(int j=0;j<h;j++){
int pixel = buffImg.getRGB(i, j); //獲取每個位置像素值
pixelArray[i][j] = pixel;
}
}
return pixelArray;
}
原圖
根據之前得到的二維數組進行遍歷，然后使用Color對象的get方法得到圖片顏色，最后再使用畫筆畫出圖像。
//原圖
public void drawImg(String path, Graphics gr){
//得到圖片路徑
int[][] img = getImgPixel(path);
for(int i=0;i<img.length;i++){
for(int j=0;j<img[i].length;j++){
int pixel = img[i][j];
//原圖顏色不變
Color c = new Color(pixel);
gr.setColor(c);
//使用rectangle填充每一個點
gr.fillRect(i, j, 1,1);
}
}
}
黑白
主要是尋找一個值作為黑白分界線。
//黑白
public void drawBw(String path, Graphics gr){
int [][] img = getImgPixel(path);
// 此處buffG為存儲圖片做準備
buffG = new BufferedImage(img.length, img[0].length, 1);
Graphics buff=buffG.getGraphics();
for(int i=0; i<img.length; i++){
for(int j=0; j<img[i].length; j++){
int pixel =img[i][j];
Color c = new Color(pixel);
int r=c.getRed(); int g=c.getGreen(); int b=c.getBlue();
//將小于某一值的顏色作為界限區分黑白
if(b<100){
buff.setColor(Color.BLACK);
}else {
buff.setColor(Color.white);
}
buff.fillRect(i,j,3,3);
}
}
gr.drawImage(buffG,0,0,null);
}
馬賽克 ：
馬賽克不用遍歷每一個點，主要目的是將像素點模糊，所以可以在原來遍歷的基礎上i++變成i+10, 每10個像素點獲取一個。 然后再將每個像素點放大相應的倍數。
//馬賽克實現
public void drawPixel(String path, Graphics gr){
int[][] pixelArray = getImgPixel(path);
buffG = new BufferedImage(pixelArray.length, pixelArray[0].length, 1);
Graphics buff=buffG.getGraphics();
//減少像素數量
for(int i=0;i<pixelArray.length;i+=10){
for(int j=0;j<pixelArray[0].length;j+=10){
int pixel = pixelArray[i][j];
Color color = new Color(pixel);
buff.setColor(color);
//放大像素點大小
buff.fillRect(i, j, 10, 10);
}
}
gr.drawImage(buffG,0,0,null);
}
灰度圖
主要取原圖顏色RGP的平均值設置為新顏色畫出。
//灰度圖實現
public void drawGrayScale(String path, Graphics gr){
int[][] img = getImgPixel(path);
buffG = new BufferedImage(img.length, img[0].length, 1);
Graphics buff=buffG.getGraphics();
for(int i=0; i<img.length;i++){
for(int j=0;j<img[i].length;j++) {
int pixel =img[i][j];
Color c = new Color (pixel);
// 取rgp平均值
int r = c.getRed();
int g = c.getGreen();
int b = c.getBlue();
int sum = (r+g+b)/3;
Color newc= new Color(sum,sum,sum);
buff.setColor(newc);
buff.fillRect(i,j,1,1);
}
}
gr.drawImage(buffG,0,0,null);
}
去背景
只畫大于某一值的顏色，原圖綠色比較多，所以對g進行比較。
//去背景實現
public void drawRemoveBg(String path, Graphics gr){
int[][] img = getImgPixel(path);
buffG = new BufferedImage(img.length, img[0].length, 1);
Graphics buff=buffG.getGraphics();
for(int i=0;i<img.length;i++){
for(int j=0;j<img[i].length;j++){
int pixel = img[i][j];
Color c = new Color(pixel);
//去背景，只畫大于某一值的顏色去背景效果
int r=c.getRed();int g=c.getGreen();int b=c.getBlue();
if(g>150){
Color nc=new Color(r,g,b);
buff.setColor(nc);
buff.fillRect(i, j, 1,1);
}
}
}
gr.drawImage(buffG,0,0,null);
}
網格化
與馬賽克有點類似，改變填充方法為原點
//網格化實現
public void drawGrid(String path, Graphics gr){
int [][] img = getImgPixel(path);
buffG = new BufferedImage(img.length, img[0].length, 1);
Graphics buff=buffG.getGraphics();
//減少像素數量
for(int i=0;i<img.length;i+=10){
for(int j=0;j<img[i].length;j+=10){
int pixel = img[i][j];
Color c = new Color(pixel);
int r=c.getRed(); int g=c.getGreen(); int b=c.getBlue();
Color nc = new Color(r,g,b);
buff.setColor(nc);
//放大像素數量
buff.fillOval(i, j, 8,8 );
}
}
gr.drawImage(buffG,0,0,null);
}
油畫
像素點數量不變，主要是填充隨機大小癿色塊。
//油畫效果
public void drawPainting(String path, Graphics gr){
int[][] img =getImgPixel(path);
buffG = new BufferedImage(img.length, img[0].length, 1);
Graphics buff=buffG.getGraphics();
for(int i=0; i<img.length; i++){
for(int j=0; j<img[i].length; j++){
int pixel = img[i][j];
Color c = new Color(pixel);
buff.setColor(c);
///填充隨機大小癿色塊
Random random =new Random();
int r = random.nextInt(20)+5;
buff.fillOval(i,j,r,r);
}
}
gr.drawImage(buffG,0,0,null);
}
雙圖合并
選取兩張圖片，然后從2張圖片中獲取其長和寬的最小值。之后以更小的圖片為大小進行處理，主要對顏色進行透明處理才能更好地得到合并效果。
//雙圖
public void drawDouble(String path1, String path2, Graphics gr ){
//選取a,b兩張照片, 給顏色不同權值
int[][] img1=getImgPixel(path1);
int[][] img2=getImgPixel(path2);
// 取其寬高癿最小值，防數組越界
int w =Math.min(img1.length,img2.length);
int h =Math.min(img1[0].length, img2.length);
buffG = new BufferedImage(w,h, 1);
Graphics buff=buffG.getGraphics();
//更大的圖片在前循環
for(int i=0; i<w; i+=1){
for(int j=0;j<h;j+=1){
Color c1 = new Color(img1[i][j]);
Color c2 = new Color(img2[i][j]);
//透明處理
int r=(int)(c1.getRed()*0.7+c2.getRed()*0.3);
int g=(int)(c1.getGreen()*0.3+c2.getGreen()*0.7);
int b=(int)(c1.getBlue()*0.3+c2.getBlue()*0.7);
Color cn = new Color(r,g,b);
buff.setColor(cn);
buff.drawLine(i,j,i,j);
}
}
gr.drawImage(buffG,0,0,null);
}
卷積效果
卷積算法，就是對圖像二維數組，乘以不同的卷積核，以獲取不同的特征圖像。
對一幅圖像的卷積處理有如下三步：
１．將原圖像轉為二維數組
２．尋找合適的卷積核二維數組（百度之）
３．按卷積規則，相乘這兩個二維數組，得到第三個二維數組即是。
//卷積核癿二維數組：邊緣化
float[][] kArray= {{-1,-1,-1,-1,-1},
{-1,-1,-1,-1,-1},{-1,-1,25,-1,-1},
{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1}};
/**
* 卷積計算
* @param src :圖片數組
* @param filter :卷積核數組
* @return 計算后癿數組
*/
public static int[][] valide(int[][] src,float[][] filter){
int[][]tem = new int[filter.length][filter[0].length];
int valideWidth = src[0].length - filter[0].length+1;
int valideheight = src.length - filter.length+1;
int[][] valide = new int[valideheight][valideWidth];
for(int i=0;i<valideheight;i+=1){
for(int j=0;j<valideWidth;j+=1){
for(int y=0;y<filter.length;y++){
for(int z=0;z<filter[0].length;z++){
tem[y][z] =(int)((src[i+y][j+z])*(filter[y][z]));
}
}
int kk=0;
for(int y=0;y<filter.length;y++){
for(int z=0;z<filter[0].length;z++){
kk += tem[y][z];
}
}
if(kk<0)kk=0; if(kk>255)kk=255;
valide[i][j]=(byte)kk;
}
}
return valide;
}
//卷積效果
public void drawJJ(String path){
DrawMouse mouse= new DrawMouse();
int[][] ia= mouse.getImgPixel(path);
ia=valide(ia, kArray);
buffG = new BufferedImage(ia.length, ia[0].length, 1);
Graphics buff=buffG.getGraphics();
for(int i=0;i<ia.length;i++){
for(int j=0;j<ia[0].length;j++){
int pixel = ia[i][j];
Color color = new Color(pixel);
buff.setColor(color);
//放大像素點大小 保證減少的倍數與放大倍數相同，否則是網格化
buff.fillRect(i, j, 10, 10);
}
}
//在界面上畫出ia數組圖像，即卷積結果：
gr.drawImage(buffG,0,0,null);
}
4.關于重繪
jframe 類中的 repaint()方法： 我的理解當窗體尺寸發生變化或者已經移動到屏幕外時或者需要刷新一下界面，此時應該使用重繪。
比如，我的代碼是使用了動作監聽器，每次點擊具體的圖像效果或是打開某張圖片，那么此時就需要添加重匯到動作監聽器中。
5.圖片打開
主要使用JfileChooser類中的showOpenDialog對圖片進行選擇，會彈出文件選擇器挑選所要打開的圖像，并且對文件后綴進行過濾，只使用jpg文件。
public void openFile(){
JFileChooser jfc = new JFileChooser();
jfc.setAcceptAllFileFilterUsed(false);//取消顯示所有文件過濾選項
//后綴名過濾器
FileNameExtensionFilter filter = new FileNameExtensionFilter("(*.jpg)", "jpg");
jfc.setFileFilter(filter);
jfc.setDialogTitle("打開文件");
jfc.showOpenDialog(null);
File file = jfc.getSelectedFile();
if(file!=null){
fPath=file.getPath();
System.out.print(fPath);
drawImg(fPath, gr);
}else {
System.out.println("未選擇文件");
}
}
6.圖片保存
對文件進行保存，之前畫在畫布上的圖片都儲存在 BufferedImage buffG里，此時使用JFileChooser類中的showSaveDialog方法，然后選擇要保存的路徑以及圖片名字。
public void saveFile(){
JFileChooser jfc = new JFileChooser();
//后綴名過濾器
FileNameExtensionFilter filter = new FileNameExtensionFilter(
"(*.jpg)", "jpg");
jfc.setFileFilter(filter);
jfc.setDialogTitle("保存文件");
jfc.showSaveDialog(null);
File file = jfc.getSelectedFile();
try {
ImageIO.write(buffG,"jpg", file);
System.out.print("保存成功" );
} catch (IOException ex) {
ex.printStackTrace();
}
}
初學swing歡迎大家指正。
補充知識：回歸java8-java進階-對象容器集合
對象容器——集合
當獲得多個對象后，需要一個容器將它們管理起來，這個容器就是集合。
集合本質上是基于某種數據結構的數據容器。常見的數據結構有：
數組Array、集合Set、隊列Queue、鏈表Linkedlist、樹Tree、堆Heap、棧Stack、映射Map…
java中提供了豐富的集合接口和類，來自java.util包。
java集合類型分為Collection和Map，Collection子接口有Set、Queue和List等接口，每一種集合接口描述了一種數據結構。
java SE中List名稱的類型有兩個：
java.util.List 是一個接口，下面的List集合，
java.awt.List 是一個類，用于圖形用戶界面開發，是一個圖形界面中的組件。
學習java中的集合，首先從接口入手，重點掌握List、Set和Map三個接口，熟悉這些接口中提供的方法。然后再熟悉這些接口的實現類，并了解不同實現類之間的區別。
List集合
List集合中的元素是有序的，可以重復出現。（下標從0開始）。強調有序。
List接口的實現類有：
ArrayList 基于動態數組數據結構的實現，訪問元素速度優于LinkedList；
LinkedList 基于鏈表數據結構的實現，占用空間內存比較大，在批量插入或刪除數據時優于ArrayList。
不同的結構對應于不同的算法，魚與熊掌不可兼得。提高運行速度往往以犧牲空間為代價；節省占用空間往往以犧牲運行速度為代價。
常用方法
List接口繼承自Collection接口，List接口中常用方法如下：
操作元素：
get(int index) 返回List集合中指定位置的元素。
set(int index, Object element) 用指定元素替換List集合中指定位置的元素。
add(Object element) 在List集合的尾部添加指定的元素。該方法從Collection集合繼承而來。
add(int index, Object element) 在List集合的指定位置插入指定元素。
remove(int index) 移除List集合中指定位置的元素。
remove(Object element) 如果List集合中存在指定元素，則從List集合中移除第一次出現的指定元素。該方法從Collection集合繼承而來。
clear() 從List集合中移除所有元素。該方法從Collection集合繼承而來。
判斷元素：
isEmpty() 判斷List集合中是否有元素，沒有返回true，有返回false。該方法從Collection集合繼承而來。
contains(Object element) 判斷List集合中是否包含指定元素，包含返回true，不包含返回false。該方法從Collection集合繼承而來。
查詢元素：
indexOf(Object o) 從前往后查找List集合元素，返回第一次出現指定元素的索引，若此列表不包含該元素返回-1。
lastIndexOf(Object o) 從后往前查找List集合元素，返回第一次出現指定元素的索引，若此列表不包含該元素返回-1。
其他：
iterator() 返回迭代器對象，迭代器對象用于遍歷集合。該方法從Collection集合繼承而來。
size() 返回List集合中的元素數，返回值是int類型。該方法從Collection集合繼承而來。
subList(int fromIndex, int toIndex) 返回List集合中指定的fromIndex（包括）和toIndex（不包括）之間的元素集合，返回值為List集合。
// 聲明List類型集合變量list，使用ArrayList類實例化list，List接口不能實例化
List list = new ArrayList();
String b = "B";
list.add("A");
list.add(b);
list.clear(); // [] 清空集合，變量list所引用的對象還在，不是null，只是集合中沒有了元素
list.add(1); // 發生自動裝箱
int item = (Integer)list.get(0); // 發生自動拆箱
java中任何集合中存放的都是對象，即引用數據類型，基本數據類型不能放到集合中。
從集合中取出的也是對象。
遍歷集合
遍歷：將集合中的每一個元素取出來，進行操作或計算。
List集合遍歷三種方法：
for循環。
for (int i = 0; i < list.size(); i++) {
System.out.println(i, list.gei(i));
}
增強for循環。是針對遍歷各種類型集合而退出的，推薦使用。
for (Object item : list) {
String s = (String) item;
System.out.println(s);
}
迭代器。java提供了多種迭代器，List集合可以使用Iterator和ListIterator迭代器。
Iterator it = list.iterator(); // 迭代器對象
while (it.hasNext()) { // 判斷集合中是否還有元素可以迭代，有true，沒有false
Object item = it.next(); // 返回迭代的下一元素
String s = (String) item;
System.out.println(s);
}
Set集合
Set集合是由一串無序的，不能重復的相同類型元素構成的集合。強調不重復。
Set接口直接實現類主要是HashSet，HashSet是基于散列表數據結構的實現。
常用方法
Set接口繼承自Collection接口，Set接口中常用方法如下：
操作元素：
add(Object element) 在Set集合的尾部添加指定元素。該方法從Collection集合繼承而來。
remove(Object element) 如果Set集合中存在指定元素，則從Set集合中移該元素。該方法從Collection集合繼承而來。
clear() 從Set集合中移除所有元素。該方法從Collection集合繼承而來。
判斷元素：
isEmpty() 判斷Set集合中是否有元素，沒有返回true，有返回false。該方法從Collection集合繼承而來。
contains(Object element) 判斷Set集合中是否包含指定元素，包含返回true，不包含返回false。該方法從Collection集合繼承而來。
其他：
iterator() 返回迭代器對象，迭代器對象用于遍歷集合。該方法從Collection集合繼承而來。
size() 返回Set集合中的元素數，返回值是int類型。該方法從Collection集合繼承而來。
Set set = new HashSet(); // []
遍歷集合
Set集合中的元素由于沒有序號，所以不能使用for循環進行遍歷，
但可以使用增強for循環和迭代器進行遍歷，這兩種遍歷方法繼承自Collection集合，
所有的Collection集合類型都有這兩種遍歷方式。
Map集合
Map（映射）集合表示一種非常復雜的集合，允許按照某個鍵來訪問元素。
Map集合由兩個集合構成，鍵（key）集合，值（value）集合。
鍵集合是Set類型，不能有重復元素；值集合是Collection類型，可以有重復元素。
Map集合中的鍵和值是成對出現的。
適合通過鍵快速訪問值。
Map接口直接實現類主要是HashMap，HashMap是基于散列表數據結構的實現。
常用方法
操作元素：
get(Object key) 返回指定鍵所對應的值；如果Map集合中不包含該鍵值對，返回null。
put(Object key, Object value) 指定鍵值對添加到集合中。
remove(Object key) 移除鍵值對。
clear() 移除Map集合中所有鍵值對。
判斷元素：
isEmpty() 判斷Map中是否有鍵值對，沒有返回true，有返回false。
containsKey(Object key) 判斷鍵集合中是否包含指定元素，包含返回true，不包含返回false。
containsValue(Object key) 判斷值集合中是否包含指定元素，包含返回true，不包含返回false。
查看集合：
keySet() 返回Map中的所有鍵集合，返回值是Set類型。
values() 返回Map中的所有值集合，返回值是Collection類型。
size() 返回Map集合中鍵值對數。
Map map = new HashMap();
map.put(102, "張三")；
map.put(105, "李四")；
map.put(102, "王五")； // 102鍵已存在，替換原來值
map.get(102); // 王五
map.clear(); // {}
遍歷集合
Map有兩個集合，可以只遍歷值的集合、鍵的集合、同時遍歷。
使用增強for循環
Set keys = map.keySet();
for (Object key : keys) {
int ikey = (Integer) key; // 自動拆箱
String value = (String) map.get(ikey); // 自動拆箱
}
使用迭代器
Collection values = map.values(); // 獲得值集合
Iterator it = values.iterator(); // 遍歷值集合
while (it.hasNext()) {
Object item = it.next();
String s = (String) item;
}
以上這篇Java swing 圖像處理多種效果實現教程就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持服務器之家。
原文鏈接：https://blog.csdn.net/weixin_49857492/article/details/108522713
