Tutorial Deteksi Warna RGB Image Processing Java ~ Kumpulan Tutorial

Hai sob kali ini saya mau nerusin tentang project saya yaitu image processing berikut adalah screenshoot program yang pernah saya buat.seperti aplikasi photoshop ya sob hehehe,

Ya memang benar dulu waktu saya kulyah smester 4 saya ingin menciptakan aplikasi mirip dengan photoshop meskipun nggak mungkin :D. Akhirnya saya beli buku yang namanya “Dasar-dasar Image Processing”.dimana didalam buku tersebut ada beberapa project untuk menampilkan warna menampilkan warna memahami tentang Graphic 2D.oke langsung saja saya mau share tentang Source Code Image Sukanya Processing :D.

Sudah siap membuat project,langsung aja kita mulai coding awal :

1. Pertama kita buat project java Class dan beri nama “CostomFilter”.

package imageviewer, lalu ketikan code tersebut didalamnya.tentunya jangan Copas ya sob,masak calon programer males Ngetik Skript? :D.

Maksud Code dibawah ini adalah untuk memasukan image kedalam Canvas yaitu kedalam lembar kerja.

import java.awt.Container;

import java.awt.FlowLayout;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.image.BufferedImage;

import java.awt.image.BufferedImageOp;

import java.awt.image.ConvolveOp;

import java.awt.image.Kernel;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JTextField;

/**

* @author mohamed

public class CustomFilter extends JFrame{

/** Creates a new instance of CustomFilter */

public CustomFilter(BufferedImage buffImage) {

setTitle("Custom Filter");

setSize(400,200);

setLocation(250,250);

Orginal=buffImage;

Container cp=getContentPane();

cp.setLayout(new FlowLayout());

myPanel.setLayout(new GridLayout(5,5));

for(int i=0;i<5;i++)

for(int j=0;j<5;j++) {

myfilds[i][j]=new JTextField("0.08",5);

myPanel.add(myfilds[i][j]);

}

ok.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int count=0;

float foa;

for(int i=0;i<5;i++)

for(int j=0;j<5;j++) {

customfil[count] =Float.parseFloat(myfilds[i][j].getText());

count++;

}

int w =Orginal.getWidth();

int h = Orginal.getHeight();

biop = new ConvolveOp(new Kernel(dim[0][0],dim[0][1],customfil));

BufferedImage bi = new BufferedImage(w,h,Orginal.TYPE_INT_RGB);

biop.filter(Orginal,bi);

new ShowFrame(bi,"Custom Filter");

}

});

Cancel.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

dispose();

}

});

cp.add(myPanel);

cp.add(ok);

cp.add(Cancel);

}

private JTextField [][] myfilds=new JTextField[5][5];

private JPanel myPanel=new JPanel();

private JButton ok=new JButton("OK");

private JButton Cancel=new JButton("Cancel");

private float[] customfil = new float[25];

private BufferedImageOp biop;

private BufferedImage Orginal;

private int dim[][] = {{5,5}};

}

2. Terus buat Java Class lagi beri nama “EdgeDetector”

* * Please Visit us at www.codemiles.com *

* This Program was Developed by www.codemiles.com forums Team

* * Please Don't Remove This Comment *

package imageviewer;

/**

* @author mahmoud

import java.awt.*;

import java.awt.image.*;

import java.util.BitSet;

import javax.swing.ImageIcon;

public class EdgeDetector extends Component {

public EdgeDetector(int hi,int wd,Image image) {

threshold1 = 50;

threshold2 = 230;

width=wd;

height=hi;

setThreshold(128);

setWidGaussianKernel(15);

sourceImage = image;

try {

process();

} catch (EdgeDetectorException ex) {

ex.printStackTrace();

}

public void process() throws EdgeDetectorException {

if (threshold < 0 || threshold > 255)

throw new EdgeDetectorException("The value of the threshold is out of its valid range.");

if (widGaussianKernel < 3 || widGaussianKernel > 40)

throw new EdgeDetectorException("The value of the widGaussianKernel is out of its valid range.");

width = sourceImage.getWidth(this);

height = sourceImage.getHeight(this);

picsize = width * height;

data = new int[picsize];

magnitude = new int[picsize];

orientation = new int[picsize];

float f = 1.0F;

canny_core(f, widGaussianKernel);

thresholding_tracker(threshold1, threshold2);

for (int i = 0; i < picsize; i++)

if (data[i] > threshold)

data[i] = 0xff000000;

else

data[i] = -1;

edgeImage = pixels2image(data);

/*int w = edgeImage.getWidth(null);

int h = edgeImage.getHeight(null);

bi = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);

Graphics2D g2=(Graphics2D)edgeImage.getGraphics();*/

data = null;

magnitude = null;

orientation = null;

}

private void canny_core(float f, int i) {

boolean flag = false;

boolean flag1 = false;

derivative_mag = new int[picsize];

float af4[] = new float[i];

float af5[] = new float[i];

float af6[] = new float[i];

data = image2pixels(sourceImage);

int k4 = 0;

do {

if (k4 >= i)

break;

float f1 = gaussian(k4, f);

if (f1 <= 0.005F && k4 >= 2)

break;

float f2 = gaussian((float) k4 - 0.5F, f);

float f3 = gaussian((float) k4 + 0.5F, f);

float f4 = gaussian(k4, f * 0.5F);

af4[k4] = (f1 + f2 + f3) / 3F / (6.283185F * f * f);

af5[k4] = f3 - f2;

af6[k4] = 1.6F * f4 - f1;

k4++;

} while (true);

int j = k4;

float af[] = new float[picsize];

float af1[] = new float[picsize];

int j1 = width - (j - 1);

int l = width * (j - 1);

int i1 = width * (height - (j - 1));

for (int l4 = j - 1; l4 < j1; l4++) {

for (int l5 = l; l5 < i1; l5 += width) {

int k1 = l4 + l5;

float f8 = (float) data[k1] * af4[0];

float f10 = f8;

int l6 = 1;

int k7 = k1 - width;

for (int i8 = k1 + width; l6 < j; i8 += width) {

f8 += af4[l6] * (float) (data[k7] + data[i8]);

f10 += af4[l6] * (float) (data[k1 - l6] + data[k1 + l6]);

l6++;

k7 -= width;

}

af[k1] = f8;

af1[k1] = f10;

}

float af2[] = new float[picsize];

for (int i5 = j - 1; i5 < j1; i5++) {

for (int i6 = l; i6 < i1; i6 += width) {

float f9 = 0.0F;

int l1 = i5 + i6;

for (int i7 = 1; i7 < j; i7++)

f9 += af5[i7] * (af[l1 - i7] - af[l1 + i7]);

af2[l1] = f9;

}

af = null;

float af3[] = new float[picsize];

for (int j5 = k4; j5 < width - k4; j5++) {

for (int j6 = l; j6 < i1; j6 += width) {

float f11 = 0.0F;

int i2 = j5 + j6;

int j7 = 1;

for (int l7 = width; j7 < j; l7 += width) {

f11 += af5[j7] * (af1[i2 - l7] - af1[i2 + l7]);

j7++;

}

af3[i2] = f11;

}

af1 = null;

j1 = width - j;

l = width * j;

i1 = width * (height - j);

for (int k5 = j; k5 < j1; k5++) {

for (int k6 = l; k6 < i1; k6 += width) {

int j2 = k5 + k6;

int k2 = j2 - width;

int l2 = j2 + width;

int i3 = j2 - 1;

int j3 = j2 + 1;

int k3 = k2 - 1;

int l3 = k2 + 1;

int i4 = l2 - 1;

int j4 = l2 + 1;

float f6 = af2[j2];

float f7 = af3[j2];

float f12 = hypotenuse(f6, f7);

int k = (int) ((double) f12 * 20D);

derivative_mag[j2] = k >= 256 ? 255 : k;

float f13 = hypotenuse(af2[k2], af3[k2]);

float f14 = hypotenuse(af2[l2], af3[l2]);

float f15 = hypotenuse(af2[i3], af3[i3]);

float f16 = hypotenuse(af2[j3], af3[j3]);

float f18 = hypotenuse(af2[l3], af3[l3]);

float f20 = hypotenuse(af2[j4], af3[j4]);

float f19 = hypotenuse(af2[i4], af3[i4]);

float f17 = hypotenuse(af2[k3], af3[k3]);

float f5;

if (f6 * f7 <= (float) 0

? Math.abs(f6) >= Math.abs(f7)

? (f5 = Math.abs(f6 * f12))

>= Math.abs(f7 * f18 - (f6 + f7) * f16)

&& f5

> Math.abs(f7 * f19 - (f6 + f7) * f15) : (

f5 = Math.abs(f7 * f12))

>= Math.abs(f6 * f18 - (f7 + f6) * f13)

&& f5

> Math.abs(f6 * f19 - (f7 + f6) * f14) : Math.abs(f6)

>= Math.abs(f7)

? (f5 = Math.abs(f6 * f12))

>= Math.abs(f7 * f20 + (f6 - f7) * f16)

&& f5

> Math.abs(f7 * f17 + (f6 - f7) * f15) : (

f5 = Math.abs(f7 * f12))

>= Math.abs(f6 * f20 + (f7 - f6) * f14)

&& f5 > Math.abs(f6 * f17 + (f7 - f6) * f13)) {

magnitude[j2] = derivative_mag[j2];

orientation[j2] = (int) (Math.atan2(f7, f6) * (double) 40F);

}

derivative_mag = null;

af2 = null;

af3 = null;

}

private float hypotenuse(float f, float f1) {

if (f == 0.0F && f1 == 0.0F)

return 0.0F;

else

return (float) Math.sqrt(f * f + f1 * f1);

}

private float gaussian(float f, float f1) {

return (float) Math.exp((-f * f) / ((float) 2 * f1 * f1));

}

private void thresholding_tracker(int i, int j) {

for (int k = 0; k < picsize; k++)

data[k] = 0;

for (int l = 0; l < width; l++) {

for (int i1 = 0; i1 < height; i1++)

if (magnitude[l + width * i1] >= i)

follow(l, i1, j);

}

private boolean follow(int i, int j, int k) {

int j1 = i + 1;

int k1 = i - 1;

int l1 = j + 1;

int i2 = j - 1;

int j2 = i + j * width;

if (l1 >= height)

l1 = height - 1;

if (i2 < 0)

i2 = 0;

if (j1 >= width)

j1 = width - 1;

if (k1 < 0)

k1 = 0;

if (data[j2] == 0) {

data[j2] = magnitude[j2];

boolean flag = false;

int l = k1;

do {

if (l > j1)

break;

int i1 = i2;

do {

if (i1 > l1)

break;

int k2 = l + i1 * width;

if ((i1 != j || l != i)

&& magnitude[k2] >= k

&& follow(l, i1, k)) {

flag = true;

break;

}

i1++;

} while (true);

if (!flag)

break;

l++;

}

while (true);

return true;

} else {

return false;

}

private Image pixels2image(int ai[]) {

MemoryImageSource memoryimagesource =

new MemoryImageSource(

width,

height,

ColorModel.getRGBdefault(),

ai,

width);

return Toolkit.getDefaultToolkit().createImage(memoryimagesource);

}

private int[] image2pixels(Image image) {

int ai[] = new int[picsize];

PixelGrabber pixelgrabber =

new PixelGrabber(image, 0, 0, width, height, ai, 0, width);

try {

pixelgrabber.grabPixels();

} catch (InterruptedException interruptedexception) {

interruptedexception.printStackTrace();

}

boolean flag = false;

int k1 = 0;

do {

if (k1 >= 16)

break;

int i = (ai[k1] & 0xff0000) >> 16;

int k = (ai[k1] & 0xff00) >> 8;

int i1 = ai[k1] & 0xff;

if (i != k || k != i1) {

flag = true;

break;

}

k1++;

} while (true);

if (flag) {

for (int l1 = 0; l1 < picsize; l1++) {

int j = (ai[l1] & 0xff0000) >> 16;

int l = (ai[l1] & 0xff00) >> 8;

int j1 = ai[l1] & 0xff;

ai[l1] =

(int) (0.29799999999999999D * (double) j

+ 0.58599999999999997D * (double) l

+ 0.113D * (double) j1);

}

} else {

for (int i2 = 0; i2 < picsize; i2++)

ai[i2] = ai[i2] & 0xff;

}

return ai;

}

public void setSourceImage(Image image) {

sourceImage = image;

}

public Image getEdgeImage() {

return edgeImage;

}

public void setThreshold(int i) {

threshold = i;

}

public void setWidGaussianKernel(int i) {

widGaussianKernel = i;

}

final float ORIENT_SCALE = 40F;

private int height;

private int width;

private int picsize;

private int data[];

private int derivative_mag[];

private int magnitude[];

private int orientation[];

private Image sourceImage;

private Image edgeImage;

private int threshold1;

private int threshold2;

private int threshold;

private int widGaussianKernel;

private static ShowFrame myFrame;

}

class EdgeDetectorException extends Exception {

public EdgeDetectorException() {

//do something?

}

public EdgeDetectorException(String s) {

super(s);

}

* * Please Visit us at www.codemiles.com *

* This Program was Developed by www.codemiles.com forums Team

* * Please Don't Remove This Comment *

3. Langkah ke tiga kita buat java Class lagi dan berinama “EnhancementPanel”

* * Please Visit us at www.codemiles.com *

* This Program was Developed by www.codemiles.com forums Team

* * Please Don't Remove This Comment *

package imageviewer;

import EnhancementOpr.Binirization;

import imageviewer.NoiseFilters.NoiseFilter;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.image.BufferedImage;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JSlider;

/**

* @author Mohammed

public class EnhancementPanel extends JPanel {

/** Creates a new instance of EnhancementPanel */

public EnhancementPanel(BufferedImage newimg) {

img=newimg;

for(int j=0; j<EnhOper.length; j++)

EnCombo.addItem(EnhOper[j]);

EnCombo.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

EnhIndex=EnCombo.getSelectedIndex();

int w = img.getWidth();

int h = img.getHeight();

threshold=threSlid.getValue();

System.out.println("ThreShold" + threshold);

BufferedImage bi = new BufferedImage(w,h,BufferedImage.TYPE_3BYTE_BGR);

myBin=new Binirization(img);

if(EnhIndex==0){

myBin.setThreshold(threshold);

myBin.DoBinirization();

bi=myBin.getImg();

}else

{

bi=img;

}

// bi=myNoise.filter(img, bi);

new ShowFrame(bi,EnhOper[EnhIndex]);

}

});

setLayout(new FlowLayout());

add(EnCombo);

add(thresholdLab);

add(threSlid);

}

public void setImg(BufferedImage img) {

temp=this.img = img;

}

private JComboBox EnCombo = new JComboBox();

private int EnhIndex=0;

private BufferedImage img;

private BufferedImage temp;

private JSlider threSlid = new JSlider(0,255,150);

private JLabel thresholdLab = new JLabel("ThreShold :");

private static String EnhOper[]={"Binirization","Segmentation"};

private int threshold;

private Binirization myBin;

private NoiseFilter myNoise=new NoiseFilter();

}

* * Please Visit us at www.codemiles.com *

* This Program was Developed by www.codemiles.com forums Team

* * Please Don't Remove This Comment *

Penutup

Demikian tutorial Season Pertama tentang Tutorial Deteksi Warna RGB Image Processing Java,Untuk Langkah selanjutnya Silahkan Klik Link ##**## :

About Admin MC3

This is dummy text. It is not meant to be read. Accordingly, it is difficult to figure out when to end it. But then, this is dummy text. It is not meant to be read. Period.

Kumpulan Tutorial

Tutorial Deteksi Warna RGB Image Processing Java

About Admin MC3

Related Post