Projeto esta dando erro

ola bom dia galera . . . sou novato em java alguem me pode dar uma ajuda o meu programa não esta correndo e não entendo porque

ReconhecimentoPlaca.java

import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.awt.image.WritableRaster;
import java.awt.image.renderable.ParameterBlock;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.imageio.ImageIO;
import javax.media.jai.JAI;
import javax.media.jai.KernelJAI;
import javax.media.jai.PlanarImage;
import javax.media.jai.RenderedOp;
import javax.media.jai.iterator.RandomIter;
import javax.media.jai.iterator.RandomIterFactory;
import javax.swing.JFrame;

import ocr.CharacterExtractor;

public class ReconhecimentoPlaca {

    private static final String OUTPUT_FOLDER = "output";

    public static void main(String[] args) throws IOException {
        System.setProperty("com.sun.media.jai.disableMediaLib", "true");
        System.setProperty("com.sun.media.imageio.disableCodecLib", "true");

        String placa = "placa1.jpg";

        PlanarImage imagemOriginal = JAI.create("fileload", "imagens/" + placa);
        float[] kernelMatrix = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

        KernelJAI kernel = new KernelJAI(7, 7, kernelMatrix);

        List<RenderedImage> images = new ArrayList<RenderedImage>();

        // TOP-HAT abertura
        PlanarImage erodidaAbertura = JAI.create("erode", imagemOriginal,
                kernel);
        PlanarImage dilatadaAbertura = JAI.create("dilate", erodidaAbertura,
                kernel);
        // PlanarImage aberturaTopHat = JAI.create("subtract", imagemOriginal,
        // dilatadaAbertura);

        // TOP-HAT fechamento
        PlanarImage dilatadaFechamento = JAI.create("dilate", imagemOriginal,
                kernel);
        PlanarImage erodidaFechamento = JAI.create("erode", dilatadaFechamento,
                kernel);
        // PlanarImage fechamentoTopHat = JAI.create("subtract",
        // erodidaFechamento, imagemOriginal);

        File f = new File("imagens/" + placa);
        BufferedImage imagem = ImageIO.read(f);
        RandomIter iterator = RandomIterFactory.create(erodidaFechamento, null);

        int width = imagem.getWidth();
        int height = imagem.getHeight();

        BufferedImage saida = new BufferedImage(width, height,
                BufferedImage.TYPE_BYTE_GRAY);
        WritableRaster raster = saida.getRaster();

        int[] pixel = new int[3];
        int[] corSaida = new int[3];
        for (int h = 0; h < height; h++) {
            for (int w = 0; w < width; w++) {
                iterator.getPixel(w, h, pixel);

                int valorPixel = 0 + pixel[0];
                corSaida[0] = valorPixel;
                corSaida[1] = valorPixel;
                corSaida[2] = valorPixel;

                raster.setPixel(w, h, corSaida);
            }
        }

        ParameterBlock pb = new ParameterBlock();
        pb.addSource(saida);
        pb.add(127.0);
        PlanarImage binarizada = JAI.create("binarize", pb);

        JFrame frame = new JFrame("Teste");

        // MASTER GAMBI MODE ON
        // o algoritmo ocr se perde se a imagem tem bordas.
        // realizando um CROP(recorte) na imagem binarizada para retirar as
        // borda.
        ParameterBlock cropPB = new ParameterBlock();
        cropPB.addSource(binarizada);
        cropPB.add(10.0f); // x inicial
        cropPB.add(10.0f); // y inicial
        cropPB.add(binarizada.getWidth() - 20f); // expansão em x
        cropPB.add(binarizada.getHeight() - 20f); // expansão em y
        PlanarImage binarizadaSemBordas = JAI.create("crop", cropPB);
        // TODO: encontrar umas forma melhor de fazer essa bagaça
        // MASTER GAMBI MODE OFF

        // adicionando todas as imagens na lista pra ver as diferenças
        images.add(imagemOriginal);
        images.add(erodidaAbertura);
        images.add(dilatadaAbertura);
        images.add(dilatadaFechamento);
        images.add(erodidaFechamento);
        images.add(binarizada);
        images.add(binarizadaSemBordas);

        // efetuando a identificação dos caracteres na imagem binarizada
        CharacterExtractor charExtractor = new CharacterExtractor();
        List<BufferedImage> slices = charExtractor.slice(
                binarizadaSemBordas.getAsBufferedImage(), 30, 30);

        // gravando a saída
        for (int i = 0; i < slices.size(); i++) {
            File outputfile = new File(OUTPUT_FOLDER + File.separator + "char_" + i + ".png");
            outputfile.mkdir();
            ImageIO.write(slices.get(i), "png", outputfile);
        }

        frame.add(new DisplayTwoSynchronizedImages(images));
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

    }

}

DisplayTwoSynchronizedImages.java

import java.awt.GridLayout;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.image.RenderedImage;
import java.util.List;

import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;

import com.sun.media.jai.widget.DisplayJAI;

/**
 * This class represents a JPanel which contains two scrollable instances of
 * DisplayJAI. The scrolling bars of both images are synchronized so scrolling
 * one image will automatically scroll the other.
 */
class DisplayTwoSynchronizedImages extends JPanel implements AdjustmentListener {
    /**
         * 
         */
    private static final long serialVersionUID = -3942207120738859247L;
    /** The DisplayJAI for the first image. */
    protected DisplayJAI dj1;
    /** The DisplayJAI for the second image. */
    protected DisplayJAI dj2;
    /** The JScrollPane which will contain the first of the images */
    protected JScrollPane jsp1;
    /** The JScrollPane which will contain the second of the images */
    protected JScrollPane jsp2;

    /**
     * Creates an instance of this class, setting the components' layout,
     * creating two instances of DisplayJAI for the two images and
     * creating/registering event handlers for the scroll bars.
     * 
     * @param im1
     *            the first image (left side)
     * @param im2
     *            the second image (right side)
     */
    public DisplayTwoSynchronizedImages(RenderedImage im1, RenderedImage im2) {
        super();
        setLayout(new GridLayout(1, 2));
        dj1 = new DisplayJAI(im1); // Instances of DisplayJAI for the
        dj2 = new DisplayJAI(im2); // two images
        jsp1 = new JScrollPane(dj1); // JScrollPanes for the both
        jsp2 = new JScrollPane(dj2); // instances of DisplayJAI
        add(jsp1);
        add(jsp2);
        // Retrieve the scroll bars of the images and registers adjustment
        // listeners to them.
        // Horizontal scroll bar of the first image.
        jsp1.getHorizontalScrollBar().addAdjustmentListener(this);
        // Vertical scroll bar of the first image.
        jsp1.getVerticalScrollBar().addAdjustmentListener(this);
        // Horizontal scroll bar of the second image.
        jsp2.getHorizontalScrollBar().addAdjustmentListener(this);
        // Vertical scroll bar of the second image.
        jsp2.getVerticalScrollBar().addAdjustmentListener(this);
    }

    public DisplayTwoSynchronizedImages(List<RenderedImage> images) {
        super();
        setLayout(new GridLayout(images.size()/2, 2));
        for (RenderedImage image : images) {
            DisplayJAI dj = new DisplayJAI(image); // Instances of DisplayJAI
                                                   // for the
            JScrollPane jsp = new JScrollPane(dj); // JScrollPanes for the both
            add(jsp);
            jsp.getHorizontalScrollBar().addAdjustmentListener(this);
            jsp.getVerticalScrollBar().addAdjustmentListener(this);
        }
    }

//    /**
//     * This method changes the first image to be displayed.
//     * 
//     * @param newImage
//     *            the new first image.
//     */
//    public void setImage1(RenderedImage newimage) {
//      dj1.set(newimage);
//      repaint();
//    }
//
//    /**
//     * This method changes the second image to be displayed.
//     * 
//     * @param newImage
//     *            the new second image.
//     */
//    public void setImage2(RenderedImage newimage) {
//      dj2.set(newimage);
//      repaint();
//    }
//
//    /**
//     * This method returns the first image.
//     * 
//     * @return the first image.
//     */
//    public RenderedImage getImage1() {
//      return dj1.getSource();
//    }
//
//    /**
//     * This method returns the second image.
//     * 
//     * @return the second image.
//     */
//    public RenderedImage getImage2() {
//      return dj2.getSource();
//    }

    /**
     * This method will be called when any of the scroll bars of the instances
     * of DisplayJAI are changed. The method will adjust the scroll bar of the
     * other DisplayJAI as needed.
     * 
     * @param e
     *            the AdjustmentEvent that occurred (meaning that one of the
     *            scroll bars position has changed.
     */
    public void adjustmentValueChanged(AdjustmentEvent e) {
//      // If the horizontal bar of the first image was changed...
//      if (e.getSource() == jsp1.getHorizontalScrollBar()) {
//          // We change the position of the horizontal bar of the second image.
//          jsp2.getHorizontalScrollBar().setValue(e.getValue());
//      }
//      // If the vertical bar of the first image was changed...
//      if (e.getSource() == jsp1.getVerticalScrollBar()) {
//          // We change the position of the vertical bar of the second image.
//          jsp2.getVerticalScrollBar().setValue(e.getValue());
//      }
//      // If the horizontal bar of the second image was changed...
//      if (e.getSource() == jsp2.getHorizontalScrollBar()) {
//          // We change the position of the horizontal bar of the first image.
//          jsp1.getHorizontalScrollBar().setValue(e.getValue());
//      }
//      // If the vertical bar of the second image was changed...
//      if (e.getSource() == jsp2.getVerticalScrollBar()) {
//          // We change the position of the vertical bar of the first image.
//          jsp1.getVerticalScrollBar().setValue(e.getValue());
//      }
    } // end adjustmentValueChanged

obrigados

se for necessario enviar o resto dos ficheiros digam algo . . .

amigão, coloca seu código dentro das tags [ code ] e [ /code]

Obs: do jeito que está o pessoal costuma nem olhar.

ele esta me dando erro em primeiro na linha 31 do arquivo ReconhecimentoPlaca.java
alguem me consegue explicar porque

[quote=raimens]ele esta me dando erro em primeiro na linha 31 do arquivo ReconhecimentoPlaca.java
alguem me consegue explicar porque[/quote]
raimens,

Vamos lá: a gente não vai explicar nada se não soubermos o que está acontecendo. Você está usando o Eclipse? Tem como rodar a aplicação em modo DEBUG?
Não precisa de mais código, manda o erro pra gente. Sabe pegar o erro? Onde isso está rodando, você chama diretamente o jar?

[quote=raimens]ele esta me dando erro em primeiro na linha 31 do arquivo ReconhecimentoPlaca.java
alguem me consegue explicar porque[/quote]Qual é o erro? Passe o stackTrace para observarmos.

Quanto a stacktraces, dê uma olhada em http://dojo.objectos.com.br/caixa/java-01-stack-traces.html