Java - captura de punto en pixeles en una imagen

tengo este codigo que encripta .. pero ahora quiero que con este mismo codigo me pueda capturar los punto de las intersecciones de las lineas de imagen
import javax.swing.*;
import java.awt.Image.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.lang.String;
import java.io.*;
import javax.imageio.ImageIO;

public class Imagenes extends JFrame
{

private PanelImagen PI = new PanelImagen();

// Constructor de la clase
public Imagenes ()
{
setTitle("Imagenes");
setLocation(100, 50);
setSize(800, 700);
Container Cpane = this.getContentPane();
Cpane.setLayout(new BorderLayout());
this.getContentPane().add(PI);
setDefaultCloseOperation(EXIT_ON_CLOSE);

}

public static void main(String [] args)
{
Imagenes b = new Imagenes();
b.show();
}
}

class PanelImagen extends JPanel
{
Image homer = null;
BufferedImage bi, enc, denc;
int ancho; //ancho de la imagen
int alto; // alto de la imagen
int x, y;
int matriz [][]; // matriz de pixeles encriptados
int matriz2 [][]; // matriz de pixeles desencriptados
int rgbs []; // matriz de pixeles de la imagen
int ingresar []; // matriz de pixeles de la imagen encriptados
int desenc []; // matriz de pixeles desencriptados debe ser igual a rgbs
int f, p, clave, largo; // f numero fragmentos, p numero que desordena
int l; // total de pixeles a fragmentar
int cont = 0;
boolean opcion = false;

public PanelImagen()
{
//Ingreso de datos
String nombre = JOptionPane.showInputDialog("Ingrese el nonbre de imagen a encriptar");
String an = JOptionPane.showInputDialog("Ingrese el ancho en pixeles de la imagen ");
String al = JOptionPane.showInputDialog("Ingrese el alto en pixeles de la imagen ");
String input = JOptionPane.showInputDialog("Ingrese el Nº de fragmentos");
String pasword = JOptionPane.showInputDialog("Ingrese clave de 4 dígitos");
String caso = JOptionPane.showInputDialog("Ingrese e:encriptar d:desencriptar ");

// convertir string a valor entero

if (input == null || input.equalsIgnoreCase(""))
f = 50; // Nº de fragmentos por defecto
else
f = Integer.parseInt(input); //Nº de fragmentos

if (pasword == null || pasword.equalsIgnoreCase(""))
clave = 1597; // Clave por defecto
else
clave = Integer.parseInt(pasword);
//Verificar opción
if (caso == null || caso.equalsIgnoreCase(""))
System.out.println("Opcion por defecto encriptar");
else
{
if (caso.equalsIgnoreCase("d"))
System.out.println("desencriptar");

else
{
System.out.println("encriptar");
opcion = true;
}
}

if (an == null || an.equalsIgnoreCase(""))
ancho = 10; // ancho en pixeles por defecto
else
ancho = Integer.parseInt(an); //ancho de la imagen

if (al == null || al.equalsIgnoreCase(""))
alto = 10; // alto en pixeles por defecto
else
alto = Integer.parseInt(al); // alto de la imagen

homer = Toolkit.getDefaultToolkit().getImage(nombre);

//Intento de adquirir el ancho y alto de la imagen

//if (homer != null)
//{
//ancho = homer.getHeight(this);
//alto = homer.getHeight(this);
//System.out.println( "ancho y alto son" + ancho + alto);
//}

p = clave % f;
while (p == 0)
{
clave = clave + 3;
p = clave % f;
}
if ((p % 2) == 0 && p > 1 && (f % 2) == 0)
p = p - 1;
if ((p % 2) != 0 && (f % 2) != 0 && p > 1)
p = p - 1;

l = f * ((ancho * alto) / f);
largo = l / f; // largo en pixeles de cada fragmento
}

// Metodo que guarda la imagen dentro de un buffer
public static BufferedImage toBufferedImage(Image image)
{
if (image instanceof BufferedImage)
{
return (BufferedImage)image;
}
// Aqui se asegura quee todos los pixeles de la imagen sean cargados
image = new ImageIcon(image).getImage();
// Se crea un BufferedImage con un formato que sea compatible con la
// ventana a visualizar
BufferedImage bimage = null;
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
try
{
// Se le entrega un tipo de transparencia al BufferedImage
int transparency = Transparency.OPAQUE;
// Se llena el BufferedImage
GraphicsDevice gs = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gs.getDefaultConfiguration();
bimage = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null)
, transparency);
}
catch (Exception e)
{
// El sistema no permite visualizar
}
if (bimage == null)
{
// Se crea el BufferedImage usando un color Model por defecto
int type = BufferedImage.TYPE_INT_RGB;
bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
}
// Se prepara al buffer para copiar la imagen
Graphics g = bimage.createGraphics();
// Se pinta la imagen dentro del buffer
g.drawImage(image, 0, 0, null);
g.dispose();
return bimage;
}

public void paintComponent (Graphics g)
{
int red, green, blue;
super.paintComponent(g); // paint background
Graphics2D g2 = (Graphics2D)g; // Se necesito a Graphics 2D

if (homer != null)
{
bi = toBufferedImage(homer); // Se copia la imagen al buffer
}

g2.drawImage(bi, 10, 10, this); // Dibuja la imagen dentro del panel
enc = bi; // Se copia la imagen en otro buffer para luego encriptar

// Para encriptar
if (opcion == true)
{
// Arreglo que guardara los valores de pixeles de la imagen
rgbs = new int[ancho * alto];
// Se copia en el arreglo el valor de cada pixel
bi.getRGB(0, 0, ancho, alto, rgbs, 0, ancho);
// Se llama a encriptar la imagen en el arreglo matriz
encriptaImagen();
// Se copia el nuevo valor de cada pixel en el buffer
if (matriz != null)
{
cont = 0;
for (int i = 0; i < alto; i++)
{
for (int j = 0; j < ancho; j++)
{
enc.setRGB(j, i, ingresar[cont]);
cont = cont + 1;
}
}
}
// Se dibuja en el panel la imagen encriptada
g2.drawImage(enc, 250, 320, this);
try
{
// Se guarda la imagen encriptada en una archivo .jpg
File outputFile = new File("imencrip.jpg");
ImageIO.write(enc, "JPG", outputFile);
}
catch (IOException e)
{
System.out.println(e);
}
}
else
{
// Para desencriptar
rgbs = new int[ancho * alto];
//denc = enc; // Se copia la imagen en otro buffer para luego desencriptar
denc = enc;
// Copiamos en rgbs los pixeles ahora encriptados

enc.getRGB(0, 0, ancho, alto, rgbs, 0, ancho);

// LLamamos a desencriptaImagen

desencriptaImagen();

// Se copia el valor desencriptado de cada pixel en el buffer denc

if (matriz2 != null)
{
cont = 0;
for (int i = 0; i < alto; i++)
{
for (int j = 0; j < ancho; j++)
{
denc.setRGB(j, i, desenc[cont]);
cont = cont + 1;
}
}
}
// Se dibuja en el panel la imagen desencriptada
g2.drawImage(denc, 250, 320, this);

try
{
// Se guarda la imagen encriptada en una archivo .jpg
File outputFile = new File("imdesenc.jpg");
ImageIO.write(denc, "JPG", outputFile);
}

catch (IOException e)
{
System.out.println(e);
}
}
}

// Metodo que encripta el la imagen que se copio al arreglo rgbs[]
public void encriptaImagen ()
{
int cont = 0;
int a[][] = new int [largo][f];

// Guarda la imagen por fragmentos de filas en otro arreglo de columnas
for (int i = 0; i < f; i++)
{
for (int j = 0; j < largo; j++)
{
a [j][i] = rgbs[cont];
cont = cont + 1;
}
}
// Matriz tendra los valores desordenados de los pixeles de la imagen original
matriz = new int [largo][f];

// Se procede a encriptar los fragmentos de la imagen
for (int i = 1; i <= f; i++)
{
for (int j = 0; j < largo; j++)
{
matriz[j][(i * p) % f] = a[j][i - 1];
}
}

// Se copia la imagen encriptada en un arreglo unidimensional para
// despues almacenarlos en el buffer

cont = 0;
ingresar = new int [ancho * alto];
for (int i = 0; i < f; i++)
{
for (int j = 0; j < largo; j++)
{
ingresar [cont] = matriz[j][i];
cont = cont + 1;
}
}
}

public void desencriptaImagen ()
{
// Tenemos en el buffer enc la imagen encriptada
// Se procede a desencriptar la imagen
int b [][] = new int [largo][f];
int cont = 0;
for (int i = 0; i < f; i++)
{
for (int j = 0; j < largo; j++)
{
b [j][i] = rgbs[cont];
cont = cont + 1;
}
}

// matriz que tendra los valores ordenados nuevamente
matriz2 = new int [largo][f];
for (int i = 1; i <= f; i++)
{
for (int j = 0; j < largo; j++)
{
matriz2[j][i - 1] = b[j][(i * p) % f];
}
}

// Se copia la imagen desencriptada en un arreglo unidimensional para
// despues almacenarlos en el buffer final
cont = 0;
desenc = new int [ancho * alto];

for (int i = 0; i < f; i++)
{
for (int j = 0; j < largo; j++)
{
desenc [cont] = matriz2[j][i];
cont = cont + 1;
}
}
} // fin del metodo
} // fin de la clase

y q algoritmo de encripcion usa?

se utiliza solo arreglos para capturar los pixiles y luego desordenarlos
en otro arreglo asi como estas en el codigo

Lo que quiero por favor es que me ayudes en lo siguiente:
ahora lo que quiero es que ya "no encripte" sino solo pueda reconocer los puntos de interseccion en la imagen GIF o TIR que se va ingresar.
Como se ve en el codigo anterior todo se va hacer hasta antes de encriptar ahora en ves de incriptar se va a reconocer los puntos de interseccion de la imagen ... es parecido a una huella digital.
si cargamos una imagen y deseo comprarar con esa misma imagen pero distorcionada en programa me tiene que avisar que la imagen no corresponde ò no son iguales, porque los punto de interccion que que se capturo antes te va permitir comparar eso ... espero me ayas entendido
te voy agradecer que me respondas
como dije solo quiero el capturar pixeles de intersecion para comparar con otro
encriptar ya no

gracias

atte:Jimy

kisiera saber como puedo sacar la matriz & no puedo¡¡**
alguein me puede ayudar 8-)...grasiias los amoo
saludos para todo ke anden bienn (K)

kisiera saber como puedo sacar la matriz & no puedo¡¡**
alguein me puede ayudar 8-)...grasiias los amoo
saludos para todo ke anden bienn (K)