Vision update

build.gradle

@@ -42,6 +42,8 @@ dependencies {
 	// Poofs library and its dependencies
 	compile name: 'json-simple-1.1.1'
 	compile name: 'poofs.2017'
+	compile group: 'log4j', name: 'log4j', version: '1.2.17'
+	compile 'org.json:json:20090211'
 	testCompile group: 'junit', name: 'junit', version: '4.12'
 	testCompile group: 'org.mockito', name: 'mockito-all', version: '1.10.19'
 }
@@ -65,4 +67,4 @@ jar {
 
 task wrapper(type: Wrapper) {
     gradleVersion = '4.4'
-}
+}

src/main/java/org/ilite/frc/common/util/NamedThreadFactory.java

@@ -0,0 +1,18 @@
+package org.ilite.frc.common.util;
+
+import java.util.concurrent.ThreadFactory;
+
+public class NamedThreadFactory implements ThreadFactory {
+
+    private String mThreadName;
+
+    public NamedThreadFactory(String pThreadName) {
+        mThreadName = pThreadName;
+    }
+
+    @Override
+    public Thread newThread(Runnable pR) {
+        return new Thread(pR, mThreadName);
+    }
+
+}

src/main/java/org/ilite/frc/vision/api/messages/RobotVisionMsg.java

@@ -0,0 +1,33 @@
+package org.ilite.frc.vision.api.messages;
+
+import java.awt.image.BufferedImage;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.ilite.frc.vision.camera.opencv.OpenCVUtils;
+
+/**
+ * Contains data coming from the camera
+ * @author Daniel Christopher
+ * @version 2/1/15
+ *
+ */
+public final class RobotVisionMsg {
+    private final BufferedImage rawImage;
+    private final List<VisibleObject> visibleObjects;
+
+    public RobotVisionMsg(BufferedImage rawImage) {
+        this.rawImage = rawImage;
+
+        visibleObjects = new LinkedList<VisibleObject>();
+    }
+
+    public BufferedImage getRawImage() {
+        return OpenCVUtils.deepCopy(rawImage);
+    }
+
+    public List<VisibleObject> getVisibleObjects() {
+        return Collections.unmodifiableList(visibleObjects);
+    }
+}

src/main/java/org/ilite/frc/vision/api/messages/VisibleObject.java

@@ -0,0 +1,36 @@
+package org.ilite.frc.vision.api.messages;
+
+import java.awt.Point;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 
+ * @author Daniel Christopher
+ * @version 2/1/15
+ *
+ */
+public final class VisibleObject {
+    private final String name;
+    private final LinkedList<Point> points;
+    private final Point centerPoint;
+
+    public VisibleObject(String name, LinkedList<Point> points, Point centerPoint) {
+        this.name = name;
+        this.points = points;
+        this.centerPoint = centerPoint;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Point> getPoints() {
+        return Collections.unmodifiableList(points);
+    }
+
+    public Point getCenterPoint() {
+        return new Point(centerPoint);
+    }
+}

src/main/java/org/ilite/frc/vision/api/system/IVisionSystem.java

@@ -0,0 +1,34 @@
+package org.ilite.frc.vision.api.system;
+
+import org.ilite.frc.vision.api.messages.RobotVisionMsg;
+
+/**
+ * Interface to connect to a single camera. This will provide users with the ability
+ * to register with the camera and receive updates. Implementations of the {@link VisionListener}
+ * will be notified when there is a new {@link RobotVisionMsg} available
+ *
+ */
+public interface IVisionSystem {
+
+	/**
+	 * Method to start the camera processing. This should be called before processing can begin. 
+	 * Subsequent calls to this method will do nothing
+	 */
+	public void start();
+
+    /**
+     * Method to subscribe for vision updates
+     * @param listener
+     *  Listener to register
+     */
+    public void subscribe(VisionListener listener);
+
+    /**
+     * Method to unsubscribe for vision updates
+     * @param listener
+     *  listener to stop registering
+     */
+    public void unsubscribe(VisionListener listener);
+
+
+}

src/main/java/org/ilite/frc/vision/api/system/ImageBlender.java

@@ -0,0 +1,140 @@
+package org.ilite.frc.vision.api.system;
+
+import java.awt.AlphaComposite;
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.imageio.ImageIO;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+import org.ilite.frc.vision.api.messages.RobotVisionMsg;
+import org.ilite.frc.vision.camera.opencv.ImagePanel;
+import org.ilite.frc.vision.camera.opencv.OverlaySlider;
+
+
+/**
+ * A proof of concept to overlay one image on top of each other. This will register
+ * with the live camera, using the {@link VisionSystemAPI} to get a reference. 
+ * When a new frame comes in, this image will blend the mOverlayImage on top of 
+ * the frame and then render it to the display. 
+ * 
+ * There {@link OverlaySlider} is used to adjust the alpha value. Valid alpha 
+ * values are from 0.0 to 1.0. Essentially the alpha values are percentages, with 
+ * 1.0 representing full opaque and 0.0 being completely invisible. 
+ * 
+ * This class will put the {@link OverlaySlider} on the top of the frame and 
+ * the image panel in the center
+ */
+public class ImageBlender extends JPanel implements VisionListener {
+
+    /**
+     * The panel that will render the mFinalImage onto this frame. 
+     */
+	private final ImagePanel mImagePanel = new ImagePanel();
+
+	/**
+	 * {@link List} containing all of the overlays
+	 */
+	private final List<BufferedImage>mOverlays = new ArrayList<BufferedImage>();
+	/**
+	 * The main content of  this frame
+	 */
+	/**
+	 * The final image that is to be rendered. This will be created once in the 
+	 * onVisonDataReceived, once this starts to receive frames from the camera
+	 */
+    private BufferedImage mFinalImage;
+    private BufferedImage mBackgroundImage;
+
+    private JLabel mPercentageLabel;
+    private final DecimalFormat mFormat = new DecimalFormat("000");
+
+    /**
+     * Creates and shows this frame
+     * @throws IOException
+     *  Thrown if there was an issue loading the overlay Image
+     */ 
+
+
+
+	public ImageBlender() throws IOException { 
+	    super(new BorderLayout());
+	    mOverlays.add(VisionSystemAPI.loadImageAsResource("Overlay.png"));
+
+        mImagePanel.getPanel().setPreferredSize(new Dimension(800, 600));
+
+        add(mImagePanel.getPanel(), BorderLayout.CENTER);
+        setVisible(true);   
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public void onVisionDataRecieved(RobotVisionMsg message) {
+	    BufferedImage frameImage = message.getRawImage();
+	    redraw(frameImage); 
+	}
+
+    private void redraw(BufferedImage frameImage) {
+        if(mFinalImage == null) {
+	        mFinalImage = new BufferedImage(frameImage.getWidth(), frameImage.getHeight(), BufferedImage.TYPE_INT_RGB); 
+	        setPreferredSize(new Dimension(mFinalImage.getWidth(), mFinalImage.getHeight()));
+
+	    } 
+	    int screenWidth = frameImage.getWidth(); 
+	    int screenHeight = frameImage.getHeight();
+
+	    Graphics2D graphics = mFinalImage.createGraphics();   
+	    graphics.fillRect(0, 0, mFinalImage.getWidth(), mFinalImage.getHeight());
+	    graphics.drawImage(frameImage, 0, 0,frameImage.getWidth(), frameImage.getHeight(), null);
+	    graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,.5f));  
+
+	    for(BufferedImage anOverlay : mOverlays) {
+	        graphics.drawImage(anOverlay, 0, 0,screenWidth,screenHeight, null);
+	    }
+	    graphics.dispose();
+
+	    mImagePanel.updateImage(mFinalImage);
+    }
+
+	/**
+	 * Starts the Image Blender and registers it with the {@link VisionSystemAPI}
+	 * @param args
+	 *     Not used
+	 * @throws IOException
+	 *     thrown if the overlay image could not be loaded
+	 */
+    public static void main(String[] args) throws IOException {   
+    	JFrame frame = new JFrame();  
+    	ImageBlender blender = new ImageBlender();  
+
+    	File background = new File("src/main/resources/images/Screenshot1.jpg");
+    	BufferedImage backgroundImage = ImageIO.read(background);
+    	blender.setbackgroundImage(backgroundImage);
+
+//        VisionSystemAPI.getVisionSystem(ECameraType.LOCAL_CAMERA).subscribe(blender);
+        frame.setContentPane(blender);
+
+
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
+        frame.setVisible(true);  
+        frame.pack();
+
+    }
+
+    private void setbackgroundImage(BufferedImage pBackgroundImage) {
+        mBackgroundImage = pBackgroundImage;
+        redraw(mBackgroundImage);
+
+    }
+}

src/main/java/org/ilite/frc/vision/api/system/VisionListener.java

@@ -0,0 +1,7 @@
+package org.ilite.frc.vision.api.system;
+
+import org.ilite.frc.vision.api.messages.RobotVisionMsg;
+
+public interface VisionListener {
+    public void onVisionDataRecieved(RobotVisionMsg message);
+}

src/main/java/org/ilite/frc/vision/api/system/VisionSystem.java

@@ -0,0 +1,84 @@
+package org.ilite.frc.vision.api.system;
+
+import java.awt.image.BufferedImage;
+import java.util.LinkedHashSet;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.ilite.frc.vision.api.messages.RobotVisionMsg;
+import org.ilite.frc.vision.camera.CameraConnectionFactory;
+import org.ilite.frc.vision.camera.ICameraConnection;
+import org.ilite.frc.vision.camera.ICameraFrameUpdateListener;
+import org.ilite.frc.vision.camera.opencv.OpenCVUtils;
+
+final class VisionSystem implements ICameraFrameUpdateListener, IVisionSystem {
+    private LinkedHashSet<VisionListener> listeners;
+    private ICameraConnection connection;
+    /**
+     * Flag indicating whether this vision system has been initializied. 
+     * This is used to ensure that multiple calls to start do nothing
+     */
+    private final AtomicBoolean mIsInit = new AtomicBoolean(false);
+    private static final ExecutorService sService = Executors.newCachedThreadPool(new ThreadFactory() {
+
+        @Override
+        public Thread newThread(Runnable pR) {
+            return new Thread(pR, "Vision System Connection Thread");
+        }
+    });
+
+    protected VisionSystem(String pIP) {
+
+        OpenCVUtils.init();
+        listeners = new LinkedHashSet<VisionListener>();
+
+        connection = CameraConnectionFactory.getCameraConnection(pIP);
+
+        connection.addCameraFrameListener(this);
+
+    }
+
+    @Override
+    public void frameAvail(BufferedImage pImage) {
+        RobotVisionMsg message = new RobotVisionMsg(pImage);
+
+        for(VisionListener listener : listeners) {
+            listener.onVisionDataRecieved(message);
+        }
+    }
+
+    @Override
+    public void start() {
+    	boolean isInit = mIsInit.getAndSet(true);
+
+    	if(!isInit) {
+        sService.submit(new Runnable() {
+
+            @Override
+            public void run() {
+                connection.start();     
+            }
+        });
+    	}
+
+    }
+
+    /* (non-Javadoc)
+     * @see org.ilite.vision.api.system.IVisionSystem#subscribe(org.ilite.vision.api.system.VisionListener)
+     */
+    @Override
+    public void subscribe(VisionListener listener) {
+        listeners.add(listener);
+    }
+
+    /* (non-Javadoc)
+     * @see org.ilite.vision.api.system.IVisionSystem#unsubscribe(org.ilite.vision.api.system.VisionListener)
+     */
+    @Override
+    public void unsubscribe(VisionListener listener) {
+        listeners.remove(listener);
+    }
+
+}