This example uses various 2D convolutions filters to find edges in an image. The example is ported from C examples in the OpenGL Programming Guide (known as the "red book").

-> Copyright and Permission Notice

 package glredbook12x;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import java.io.*;
import java.nio.*;

import javax.media.opengl.*;
import javax.media.opengl.glu.*;

import com.sun.opengl.util.*;

/**
 * Use various 2D convolutions filters to find edges in an image.
 * 
 * @author Kiet Le (Java port)
 */
public class convolution
  extends JFrame
    implements GLEventListener//
    , KeyListener //
// , MouseListener //
// , MouseMotionListener //
// , MouseWheelListener //
{
  private GLCapabilities caps;
  private GLCanvas canvas;
  private KeyEvent key;
  //
  private ByteBuffer pixels;
  // private int width; not reference as params...
  // private int height;...as are all Java primitives
  private Dimension dim = new Dimension(0, 0);
  private float horizontal[][] =
  {
  { 0, -1, 0 },
  { 0, 1, 0 },
  { 0, 0, 0 } };

  private float vertical[][] =
  {
  { 0, 0, 0 },
  { -1, 1, 0 },
  { 0, 0, 0 } };

  private float laplacian[][] =
  {
  { -0.125f, -0.125f, -0.125f },
  { -0.125f, 1.0f, -0.125f },
  { -0.125f, -0.125f, -0.125f } };

  private FloatBuffer horizontalBuf = BufferUtil
      .newFloatBuffer(horizontal.length * horizontal[0].length);
  private FloatBuffer verticalBuf = BufferUtil
      .newFloatBuffer(vertical.length * vertical[0].length);
  private FloatBuffer laplacianBuf = BufferUtil
      .newFloatBuffer(laplacian.length * laplacian[0].length);
  {
    for (int i = 0; i < 3; i++)
    {
      horizontalBuf.put(horizontal[i]);
      verticalBuf.put(vertical[i]);
      laplacianBuf.put(laplacian[i]);
    }
    horizontalBuf.rewind();
    verticalBuf.rewind();
    laplacianBuf.rewind();
  }

  public convolution()
  {
    super("convolution");

    caps = new GLCapabilities();
    canvas = new GLCanvas(caps);
    canvas.addGLEventListener(this);
    canvas.addKeyListener(this);
  
    add(canvas);
  }

  public void run()
  {
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(640, 480);
    setLocationRelativeTo(null);
    setVisible(true);
    canvas.requestFocusInWindow();
  }

  public static void main(String[] args)
  {
    new convolution().run();
  }

  public void init(GLAutoDrawable drawable)
  {
    GL gl = drawable.getGL();

    gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    if (gl.isExtensionAvailable("GL_ARB_imaging"))
    {
      if (gl.isFunctionAvailable("glConvolutionFilter2D"))
      {
        System.out.println("Using the horizontal filter");
        gl.glConvolutionFilter2D(GL.GL_CONVOLUTION_2D, GL.GL_LUMINANCE, //
            3, 3, GL.GL_LUMINANCE, GL.GL_FLOAT, horizontalBuf);
        gl.glEnable(GL.GL_CONVOLUTION_2D);
      }
    }
    else
    {
      String msg = "GL_ARB_imaging (optional) subset is is not available.";
      setTitle(getTitle() + " GL_ARB_imaging not available :(");
      System.err.println(msg);
      add(new JLabel(msg), BorderLayout.NORTH);
      SwingUtilities.updateComponentTreeUI(this);    }

    pixels = readImage("Data/leeds.bin", dim);
    System.out.println(pixels.toString());

  }

  public void display(GLAutoDrawable drawable)
  {
    GL gl = drawable.getGL();

    gl.glClear(GL.GL_COLOR_BUFFER_BIT);

    if (key != null) switch (key.getKeyChar()) {
      case 'h':
        System.out.println("Using a horizontal filter");
        gl.glConvolutionFilter2D(GL.GL_CONVOLUTION_2D, GL.GL_LUMINANCE, //
            3, 3, GL.GL_LUMINANCE, GL.GL_FLOAT, horizontalBuf);
        break;

      case 'v':
        System.out.println("Using the vertical filter\n");
        gl.glConvolutionFilter2D(GL.GL_CONVOLUTION_2D, GL.GL_LUMINANCE, //
            3, 3, GL.GL_LUMINANCE, GL.GL_FLOAT, verticalBuf);
        break;

      case 'l':
        System.out.println("Using the laplacian filter\n");
        gl.glConvolutionFilter2D(GL.GL_CONVOLUTION_2D, GL.GL_LUMINANCE, //
            3, 3, GL.GL_LUMINANCE, GL.GL_FLOAT, laplacianBuf);
        break;

    }// key sw

    gl.glRasterPos2i(1, 1);
    gl.glDrawPixels(dim.width, dim.height, //
        GL.GL_RGB, GL.GL_UNSIGNED_BYTE, pixels);

    gl.glFlush();

  }

  public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h)
  {
    GL gl = drawable.getGL();

    gl.glViewport(0, 0, w, h);
    gl.glMatrixMode(GL.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(0, w, 0, h, -1.0, 1.0);
    gl.glMatrixMode(GL.GL_MODELVIEW);
  }

  public void displayChanged(GLAutoDrawable drawable, boolean modeChanged,
      boolean deviceChanged)
  {
  }

  /**
   * Reads an image from an archived file and return it as ByteBuffer object.
   * 
   * @author Mike Butler, Kiet Le
   */
  private ByteBuffer readImage(String filename, Dimension dim)
  {
    if (dim == null) dim = new Dimension(0, 0);
    ByteBuffer bytes = null;
    try
    {
      DataInputStream dis = new DataInputStream(getClass().getClassLoader()
          .getResourceAsStream(filename));
      dim.width = dis.readInt();
      dim.height = dis.readInt();
      System.out.println("Creating buffer, width: " + dim.width + " height: "
                         + dim.height);
      // byte[] buf = new byte[3 * dim.height * dim.width];
      bytes = BufferUtil.newByteBuffer(3 * dim.width * dim.height);
      for (int i = 0; i < bytes.capacity(); i++)
      {
        bytes.put(dis.readByte());
      }
      dis.close();

    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    bytes.rewind();
    return bytes;
  }

  public void keyTyped(KeyEvent key)
  {
  }

  public void keyPressed(KeyEvent key)
  {
    this.key = key;
    switch (key.getKeyChar()) {
      case KeyEvent.VK_ESCAPE:
        System.exit(0);
        break;
    }
    canvas.display();
  }

  public void keyReleased(KeyEvent key)
  {
  }

}

Source: Kiet Le's The Red Book Examples using JOGL