Subversion Repositories svnkaklik

/*
    AVRcamVIEW: A PC application to test out the functionallity of the
     AVRcam real-time image processing engine.
    Copyright (C) 2004    Brent A. Taylor

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public
    License along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

   For more information on the AVRcamVIEW, please contact:

   taylorba@comcast.net

   or go to www.jrobot.net for more details regarding the system.
*/

package avr.swing;

import java.awt.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.text.*;
import java.util.*;
import javax.swing.*;

import avr.device.event.*;
import avr.lang.*;

public class JTrackingPanel extends JPanel {

   private static final DateFormat DATE_FORMAT;

   static {
      DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd hh.mm.ss");
   }

   private ColorBlob[] blobs;
   private DataListener dataHandler;

   private Dimension preferredSize;

   private boolean recording;
   private boolean sendCameraData;

   private FileOutputStream outStream;
   private FileChannel outChannel;

   public JTrackingPanel() {
      super(null);

      recording = false;
      sendCameraData = false;

      setBackground(Color.BLACK);
      dataHandler = new TrackingHandler();

      preferredSize = null;
   }

   public void startRecording() throws FileNotFoundException {
      File recordFile = new File(DATE_FORMAT.format(new Date()) + ".trk");
      outStream = new FileOutputStream(recordFile);
      outChannel = outStream.getChannel();

      recording = true;

      AVRSystem.LOG.info("Started Recording");
   }

   public void stopRecording() throws IOException {

      recording = false;

      outStream.close();
      outChannel.close();

      AVRSystem.LOG.info("Stopped Recording");

   }

   public void startTracking() {
      AVRSystem.DEVICE.addDataListener(dataHandler);
   }

   public void stopTracking() {
      AVRSystem.DEVICE.removeDataListener(dataHandler);
   }

   public void startSendingCameraData() {
      sendCameraData = true;
   }

   public void stopSendingCameraData() {
      sendCameraData = false;
   }

   public Dimension getMinimumSize() {
      return getPreferredSize();
   }

   public Dimension getPreferredSize() {
      if(preferredSize == null) {
         Insets insets = this.getInsets();
         preferredSize = new Dimension(insets.left + AVRSystem.IMAGE_WIDTH + insets.right,
                                       insets.top + AVRSystem.IMAGE_HEIGHT + insets.bottom);
      }

      return preferredSize;
   }

   public Dimension getMaximumSize() {
      return getPreferredSize();
   }

   public void paintComponent(Graphics g) {

      super.paintComponent(g);

      Dimension size = getSize();

      Insets insets = getInsets();

      double xScale = size.width /
                      (double)(insets.left + 5 + AVRSystem.IMAGE_WIDTH + 5 +
                               insets.right);
      double yScale = size.height /
                      (double)(insets.top + 5 + AVRSystem.IMAGE_HEIGHT + 5 +
                               insets.bottom);
      double scale = Math.min(xScale, yScale);

      int imageWidth = (int)(AVRSystem.IMAGE_WIDTH * scale);
      int imageHeight = (int)(AVRSystem.IMAGE_HEIGHT * scale);

      // it is possible for the width or height to be 0 when
      // the window is resized.  If this occurs, don't try
      // to paint anything. just return
      if(imageWidth <= 0 || imageHeight <= 0) {
         return;
      }

      Image bufferedImage = createImage(imageWidth, imageHeight);

      Graphics2D bufferGraphics = (Graphics2D)bufferedImage.getGraphics();

      bufferGraphics.setColor(Color.WHITE);
      bufferGraphics.fillRect(0, 0, imageWidth, imageHeight);

      bufferGraphics.scale(scale, scale);

      for(int i = 0; (blobs != null) && (i < blobs.length); i++) {
         ColorBlob blob = blobs[i];
         if(blob != null) {
            bufferGraphics.setColor(AVRSystem.DEVICE.getMapColors()[blob.
                                    colorIndex]);
            bufferGraphics.fillRect(blob.center.x - 2, blob.center.y - 2, 4, 4);
            bufferGraphics.setColor(Color.BLACK);
            bufferGraphics.drawRect(blob.bounds.x, blob.bounds.y,
                                    blob.bounds.width, blob.bounds.height);
         }
      }

      g.drawImage(bufferedImage,
                  (size.width - imageWidth) / 2, (size.height - imageHeight) / 2,
                  imageWidth, imageHeight, this);


   }

   public void setTrackingData(ByteBuffer data) {
      blobs = new ColorBlob[data.get() & 0xFF];

      for(int i = 0; i < blobs.length; i++) {
         blobs[i] = new ColorBlob(data);
      }

      repaint();

      if(sendCameraData) {
         data.position(0);
         try {
            AVRSystem.DEVICE.sendCameraData(data);
         } catch(IOException ioe) {
            ioe.printStackTrace(System.err);
            AVRSystem.LOG.warning(ioe.getMessage());
         }
      }

   }

   private final class TrackingHandler extends DataAdapter {

      public void trackingData(ByteBuffer data) {
         setTrackingData(data);

         if(recording) {
            data.reset();
            try {
               outChannel.write(data);
            } catch(IOException ioe) {
               AVRSystem.LOG.warning("TRACKING: " + ioe.getMessage());
            }
         }

      }

   }

   private final static class ColorBlob {

      public final int colorIndex;
      public final Point center;
      public final Rectangle bounds;

      public ColorBlob(ByteBuffer data) {
         colorIndex = data.get();

         int x = data.get() & 0xFF;
         int y = data.get() & 0xFF;
         int width = (data.get() & 0xFF) - x;
         int height = (data.get() & 0xFF) - y;
         bounds = new Rectangle(x, y, width, height);

         center = new Point(x + (width / 2), y + (height / 2));
      }

      public String toString() {
         return "ColorBlob: " + colorIndex + " (" + center.x + ", " + center.y + ") " +
                " [" + bounds.x + ", " + bounds.y + ", " + bounds.width + ", " + bounds.height + "]";
      }


   }

}