Fix IP updating.

Author: lopsided98

src/main/java/org/usfirst/frc/team2084/smartdashboard/extensions/vision/LocalVisionExtension.java

@@ -12,7 +12,7 @@ public class LocalVisionExtension extends VisionExtension {
     public static final String NAME = "Local Vision";
 
     private HighGoalProcessor processor;
-    
+
     private final Mat outImage = new Mat();
     private final ImageConvertor imageConvertor = new ImageConvertor();
 
@@ -29,11 +29,10 @@ public void init() {
     @Override
     public void imageUpdated(BufferedImage image) {
         Mat inputImage = imageConvertor.toMat(image);
-        inputImage.copyTo(outImage);
-        processor.process(inputImage, outImage);
-        
+        processor.process(inputImage);
+
         BufferedImage outImageJava = imageConvertor.toBufferedImage(outImage);
         outImageJava.copyData(image.getRaster());
     }
-    
+
 }

src/main/java/org/usfirst/frc/team2084/smartdashboard/extensions/vision/UDPStreamViewerExtension.java

@@ -10,8 +10,11 @@
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
+import java.net.NetworkInterface;
 import java.net.SocketException;
+import java.net.SocketTimeoutException;
 import java.net.UnknownHostException;
+import java.util.Enumeration;
 
 import javax.imageio.ImageIO;
 
@@ -39,6 +42,8 @@ public class UDPStreamViewerExtension extends StaticWidget {
     private DatagramSocket socket;
     private final byte[] buffer = new byte[100000];
 
+    private final int RECEIVE_TIMEOUT = 1000;
+
     public class BGThread extends Thread {
 
         boolean destroyed = false;
@@ -54,15 +59,16 @@ public void run() {
             while (!destroyed) {
                 try {
                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
-                    socket.receive(packet);
+                    try {
+                        socket.receive(packet);
+                    } catch (SocketTimeoutException t) {
+                        updateIP();
+                    }
 
                     fpsCounter++;
                     long currTime = System.currentTimeMillis();
                     long elapsedTime = currTime - lastFPSCheck;
                     if (elapsedTime > 500) {
-                        if(elapsedTime > 2000) {
-                            updateIP();
-                        }
                         lastFPSCheck = currTime;
                         lastFPS = fpsCounter * 2;
                         fpsCounter = 0;
@@ -108,16 +114,21 @@ public UDPStreamViewerExtension() {
 
     private void updateIP() {
         try {
-            VisionParameters.setStreamIP(InetAddress.getLocalHost().getHostAddress());
+            VisionParameters.setStreamIP(getLocalHostLANAddress().getHostAddress());
         } catch (UnknownHostException e) {
             System.out.println(e);
         }
     }
-    
+
     @Override
     public void init() {
         setPreferredSize(new Dimension(320, 240));
         propertyChanged(rotateProperty);
+        try {
+            socket.setSoTimeout(RECEIVE_TIMEOUT);
+        } catch (SocketException e) {
+            System.err.println("Could not set socket timeout: " + e);
+        }
         bgThread.start();
         updateIP();
         revalidate();
@@ -162,8 +173,10 @@ protected void paintComponent(Graphics g) {
             double panelHeight = getBounds().height;
             double panelCenterX = panelWidth / 2.0;
             double panelCenterY = panelHeight / 2.0;
-            double rotatedImageWidth = origImageWidth * Math.abs(Math.cos(rotateAngleRad)) + origImageHeight * Math.abs(Math.sin(rotateAngleRad));
-            double rotatedImageHeight = origImageWidth * Math.abs(Math.sin(rotateAngleRad)) + origImageHeight * Math.abs(Math.cos(rotateAngleRad));
+            double rotatedImageWidth = origImageWidth * Math.abs(Math.cos(rotateAngleRad))
+                    + origImageHeight * Math.abs(Math.sin(rotateAngleRad));
+            double rotatedImageHeight = origImageWidth * Math.abs(Math.sin(rotateAngleRad))
+                    + origImageHeight * Math.abs(Math.cos(rotateAngleRad));
 
             // compute scaling needed
             double scale = Math.min(panelWidth / rotatedImageWidth, panelHeight / rotatedImageHeight);
@@ -197,4 +210,91 @@ protected void paintComponent(Graphics g) {
 
     public void imageUpdated(BufferedImage image) {
     }
+
+    /**
+     * Returns an <code>InetAddress</code> object encapsulating what is most
+     * likely the machine's LAN IP address.
+     * <p/>
+     * This method is intended for use as a replacement of JDK method
+     * <code>InetAddress.getLocalHost</code>, because that method is ambiguous
+     * on Linux systems. Linux systems enumerate the loopback network interface
+     * the same way as regular LAN network interfaces, but the JDK
+     * <code>InetAddress.getLocalHost</code> method does not specify the
+     * algorithm used to select the address returned under such circumstances,
+     * and will often return the loopback address, which is not valid for
+     * network communication. Details
+     * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4665037">here
+     * </a>.
+     * <p/>
+     * This method will scan all IP addresses on all network interfaces on the
+     * host machine to determine the IP address most likely to be the machine's
+     * LAN address. If the machine has multiple IP addresses, this method will
+     * prefer a site-local IP address (e.g. 192.168.x.x or 10.10.x.x, usually
+     * IPv4) if the machine has one (and will return the first site-local
+     * address if the machine has more than one), but if the machine does not
+     * hold a site-local address, this method will return simply the first
+     * non-loopback address found (IPv4 or IPv6).
+     * <p/>
+     * If this method cannot find a non-loopback address using this selection
+     * algorithm, it will fall back to calling and returning the result of JDK
+     * method <code>InetAddress.getLocalHost</code>.
+     * <p/>
+     *
+     * @throws UnknownHostException If the LAN address of the machine cannot be
+     *         found.
+     */
+    private static InetAddress getLocalHostLANAddress() throws UnknownHostException {
+        try {
+            InetAddress candidateAddress = null;
+            // Iterate all NICs (network interface cards)...
+            for (Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces(); ifaces
+                    .hasMoreElements();) {
+                NetworkInterface iface = ifaces.nextElement();
+                // Iterate all IP addresses assigned to each card...
+                for (Enumeration<InetAddress> inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements();) {
+                    InetAddress inetAddr = inetAddrs.nextElement();
+                    if (!inetAddr.isLoopbackAddress()) {
+
+                        if (inetAddr.isSiteLocalAddress()) {
+                            // Found non-loopback site-local address. Return it
+                            // immediately...
+                            return inetAddr;
+                        } else if (candidateAddress == null) {
+                            // Found non-loopback address, but not necessarily
+                            // site-local.
+                            // Store it as a candidate to be returned if
+                            // site-local address is not subsequently found...
+                            candidateAddress = inetAddr;
+                            // Note that we don't repeatedly assign non-loopback
+                            // non-site-local addresses as candidates,
+                            // only the first. For subsequent iterations,
+                            // candidate will be non-null.
+                        }
+                    }
+                }
+            }
+            if (candidateAddress != null) {
+                // We did not find a site-local address, but we found some other
+                // non-loopback address.
+                // Server might have a non-site-local address assigned to its
+                // NIC (or it might be running
+                // IPv6 which deprecates the "site-local" concept).
+                // Return this non-loopback candidate address...
+                return candidateAddress;
+            }
+            // At this point, we did not find a non-loopback address.
+            // Fall back to returning whatever InetAddress.getLocalHost()
+            // returns...
+            InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
+            if (jdkSuppliedAddress == null) {
+                throw new UnknownHostException("The JDK InetAddress.getLocalHost() method unexpectedly returned null.");
+            }
+            return jdkSuppliedAddress;
+        } catch (Exception e) {
+            UnknownHostException unknownHostException =
+                    new UnknownHostException("Failed to determine LAN address: " + e);
+            unknownHostException.initCause(e);
+            throw unknownHostException;
+        }
+    }
 }