changes + add two more benchmarks without annotations
authoryeom <yeom>
Wed, 31 Oct 2012 06:26:12 +0000 (06:26 +0000)
committeryeom <yeom>
Wed, 31 Oct 2012 06:26:12 +0000 (06:26 +0000)
34 files changed:
Robust/src/Analysis/SSJava/BuildLattice.java
Robust/src/Analysis/SSJava/FlowDownCheck.java
Robust/src/Analysis/SSJava/LocationInference.java
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Classifier.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ClassifierTree.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Counter.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/DeviationScanner.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Dimension.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/DummyCaptureDevice.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/EyeDetector.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/EyePosition.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/FaceAndEyePosition.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ICaptureDevice.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Image.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ImageReader.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/IntegralImageData.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LATTICE.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LEA.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LEAImplementation.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LOC.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Point.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Rectangle2D.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ScanArea.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/EyeTrackingInfer/makefile [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/MotorControl.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMControl.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMManager.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMNative.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMRtsj.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/RCBridge.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/RobotMain.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/StrategyMgr.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/TestSensorInput.java [new file with mode: 0644]
Robust/src/Benchmarks/SSJava/JavaNatorInfer/makefile [new file with mode: 0644]

index d1c631f..8c66b13 100644 (file)
@@ -66,8 +66,6 @@ public class BuildLattice {
       HierarchyGraph inputGraph, LocationSummary locSummary,
       Map<Set<Integer>, Set<Set<Integer>>> mapImSucc) {
 
-    HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc);
-
     SSJavaLattice<String> lattice =
         new SSJavaLattice<String>(SSJavaAnalysis.TOP, SSJavaAnalysis.BOTTOM);
 
@@ -140,6 +138,7 @@ public class BuildLattice {
 
     }
 
+    inputGraph.removeRedundantEdges();
     return lattice;
   }
 
index 6d22825..25f6a8e 100644 (file)
@@ -2172,6 +2172,7 @@ public class FlowDownCheck {
       // composite location
 
       int maxTupleSize = 0;
+      int minTupleSize = 0;
       CompositeLocation maxCompLoc = null;
 
       Location prevPriorityLoc = null;
@@ -2181,6 +2182,9 @@ public class FlowDownCheck {
           maxTupleSize = compLoc.getSize();
           maxCompLoc = compLoc;
         }
+        if (minTupleSize == 0 || compLoc.getSize() < minTupleSize) {
+          minTupleSize = compLoc.getSize();
+        }
         Location priorityLoc = compLoc.get(0);
         String priorityLocId = priorityLoc.getLocIdentifier();
         priorityLocIdentifierSet.add(priorityLocId);
@@ -2207,10 +2211,7 @@ public class FlowDownCheck {
       }
 
       SSJavaLattice<String> locOrder = getLatticeByDescriptor(priorityDescriptor);
-      System.out.println("priorityDescriptor=" + priorityDescriptor);
-      System.out.println("GLB INPUT=" + priorityLocIdentifierSet);
       String glbOfPriorityLoc = locOrder.getGLB(priorityLocIdentifierSet);
-      System.out.println("GLB OUTPUT="+glbOfPriorityLoc);
       glbCompLoc.addLocation(new Location(priorityDescriptor, glbOfPriorityLoc));
       Set<CompositeLocation> compSet = locId2CompLocSet.get(glbOfPriorityLoc);
 
@@ -2221,7 +2222,8 @@ public class FlowDownCheck {
 
         // in this case, do not take care about delta
         // CompositeLocation inputComp = inputSet.iterator().next();
-        for (int i = 1; i < maxTupleSize; i++) {
+        // for (int i = 1; i < maxTupleSize; i++) {
+        for (int i = 1; i < minTupleSize; i++) {
           glbCompLoc.addLocation(Location.createTopLocation(maxCompLoc.get(i).getDescriptor()));
         }
       } else {
index c344067..6575d4b 100644 (file)
@@ -560,7 +560,6 @@ public class LocationInference {
       //
       // update return flow nodes in the caller
       CompositeLocation returnLoc = getMethodSummary(mdCallee).getRETURNLoc();
-
       System.out.println("### min=" + min.printNode(0) + "  returnLoc=" + returnLoc);
       if (returnLoc != null && returnLoc.get(0).getLocDescriptor().equals(mdCallee.getThis())
           && returnLoc.getSize() > 1) {
@@ -573,6 +572,20 @@ public class LocationInference {
         }
         System.out.println("###NEW RETURN TUPLE FOR CALLER=" + newReturnTuple);
         callerFlowGraph.getFlowReturnNode(min).setNewTuple(newReturnTuple);
+      } else {
+        // if the return loc set was empty and later pcloc was connected to the return loc
+        // need to make sure that return loc reflects to this changes.
+        FlowReturnNode flowReturnNode = callerFlowGraph.getFlowReturnNode(min);
+        if (flowReturnNode != null && flowReturnNode.getReturnTupleSet().isEmpty()) {
+
+          if (needToUpdateReturnLocHolder(min.getMethod(), flowReturnNode)) {
+            NTuple<Descriptor> baseTuple = mapMethodInvokeNodeToBaseTuple.get(min);
+            NTuple<Descriptor> newReturnTuple = baseTuple.clone();
+            flowReturnNode.addTuple(newReturnTuple);
+          }
+
+        }
+
       }
 
     }
@@ -584,6 +597,23 @@ public class LocationInference {
 
   }
 
+  private boolean needToUpdateReturnLocHolder(MethodDescriptor mdCallee,
+      FlowReturnNode flowReturnNode) {
+    FlowGraph fg = getFlowGraph(mdCallee);
+    MethodSummary summary = getMethodSummary(mdCallee);
+    CompositeLocation returnCompLoc = summary.getRETURNLoc();
+    NTuple<Descriptor> returnDescTuple = translateToDescTuple(returnCompLoc.getTuple());
+    Set<FlowNode> incomingNodeToReturnNode =
+        fg.getIncomingFlowNodeSet(fg.getFlowNode(returnDescTuple));
+    for (Iterator iterator = incomingNodeToReturnNode.iterator(); iterator.hasNext();) {
+      FlowNode inNode = (FlowNode) iterator.next();
+      if (inNode.getDescTuple().get(0).equals(mdCallee.getThis())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   private void addMapMethodDescToMethodInvokeNodeSet(MethodInvokeNode min) {
     MethodDescriptor md = min.getMethod();
     if (!mapMethodDescToMethodInvokeNodeSet.containsKey(md)) {
@@ -3149,9 +3179,11 @@ public class LocationInference {
     // calculate a return location:
     // the return location type is lower than all parameters and the location of return values
     MethodSummary methodSummary = getMethodSummary(md);
-    if (methodSummary.getRETURNLoc() != null) {
-      return;
-    }
+    // if (methodSummary.getRETURNLoc() != null) {
+    // System.out.println("$HERE?");
+    // return;
+    // }
+
     FlowGraph fg = getFlowGraph(md);
     Map<Integer, CompositeLocation> mapParamToLoc = methodSummary.getMapParamIdxToInferLoc();
     Set<Integer> paramIdxSet = mapParamToLoc.keySet();
@@ -3199,6 +3231,13 @@ public class LocationInference {
 
       }
 
+      // makes sure that PCLOC is higher than RETURNLOC
+      CompositeLocation pcLoc = methodSummary.getPCLoc();
+      if (!pcLoc.get(0).isTop()) {
+        NTuple<Descriptor> pcLocDescTuple = translateToDescTuple(pcLoc.getTuple());
+        fg.addValueFlowEdge(pcLocDescTuple, returnDescTuple);
+      }
+
     }
 
   }
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Classifier.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Classifier.java
new file mode 100644 (file)
index 0000000..f73ef95
--- /dev/null
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * 
+ * @author Florian
+ */
+
+
+public class Classifier {
+
+  
+  private ScanArea[] scanAreas;
+
+  
+  private float[] possibilities_FaceYes;
+  
+  private float[] possibilities_FaceNo;
+  
+  private int possibilityFaceYes = 0;
+  
+  private int possibilityFaceNo = 0;
+
+  public Classifier(int numScanAreas) {
+    this.scanAreas = new ScanArea[numScanAreas];
+    this.possibilities_FaceYes = new float[numScanAreas];
+    this.possibilities_FaceNo = new float[numScanAreas];
+  }
+
+  public void setScanArea(int idx, ScanArea area) {
+    scanAreas[idx] = area;
+  }
+
+  public void setPossibilitiesFaceYes(@DELEGATE float[] arr) {
+    this.possibilities_FaceYes = arr;
+  }
+
+  public void setPossibilityFaceYes(int v) {
+    this.possibilityFaceYes = v;
+  }
+
+  public void setPossibilitiesFaceNo(@DELEGATE float[] arr) {
+    this.possibilities_FaceNo = arr;
+  }
+
+  public void setPossibilityFaceNo(int v) {
+    this.possibilityFaceNo = v;
+  }
+
+  /**
+   * Classifies an images region as face
+   * 
+   * @param image
+   * @param scaleFactor
+   *          please be aware of the fact that the scanareas are scaled for use
+   *          with 100x100 px images
+   * @param translationX
+   * @param translationY
+   * @return true if this region was classified as face, else false
+   */
+  
+  
+  public boolean classifyFace( IntegralImageData image,
+       float scaleFactor,  int translationX,
+       int translationY,  float borderline) {
+
+     long values[] = new long[scanAreas.length];
+
+     float avg = 0f;
+     int avgItems = 0;
+    for ( int i = 0; i < scanAreas.length; ++i) {
+      values[i] = 0l;
+
+      values[i] +=
+          image.getIntegralAt(translationX + scanAreas[i].getToX(scaleFactor), translationY
+              + scanAreas[i].getToY(scaleFactor));
+      values[i] +=
+          image.getIntegralAt(translationX + scanAreas[i].getFromX(scaleFactor), translationY
+              + scanAreas[i].getFromY(scaleFactor));
+
+      values[i] -=
+          image.getIntegralAt(translationX + scanAreas[i].getToX(scaleFactor), translationY
+              + scanAreas[i].getFromY(scaleFactor));
+      values[i] -=
+          image.getIntegralAt(translationX + scanAreas[i].getFromX(scaleFactor), translationY
+              + scanAreas[i].getToY(scaleFactor));
+
+      values[i] = (long) (values[i] / ((float) scanAreas[i].getSize(scaleFactor)));
+      avg = ((avgItems * avg) + values[i]) / (++avgItems);
+    }
+    // System.out.println("avg=" + avg);
+
+    // int amountYesNo = this.possibilityFaceNo + this.possibilityFaceYes;
+
+    // calculate the possibilites for face=yes and face=no with naive bayes
+    // P(Yes | M1 and ... and Mn) = P(Yes) * P(M1 | Yes) * ... * P(Mn | Yes) /xx
+    // P(No | M1 and ... and Mn) = P(No) * P(M1 | No) * ... * P(Mn | No) / xx
+    // as we just maximize the args we don't actually calculate the accurate
+    // possibility
+
+     float isFaceYes = 1.0f;// this.possibilityFaceYes /
+                                       // (float)amountYesNo;
+     float isFaceNo = 1.0f;// this.possibilityFaceNo /
+                                      // (float)amountYesNo;
+
+    for ( int i = 0; i < this.scanAreas.length; ++i) {
+       boolean bright = (values[i] >= avg);
+      isFaceYes *= (bright ? this.possibilities_FaceYes[i] : 1 - this.possibilities_FaceYes[i]);
+      isFaceNo *= (bright ? this.possibilities_FaceNo[i] : 1 - this.possibilities_FaceNo[i]);
+    }
+    // System.out.println("avg=" + avg + " yes=" + isFaceYes + " no=" +
+    // isFaceNo);
+
+    return (isFaceYes >= isFaceNo && (isFaceYes / (isFaceYes + isFaceNo)) > borderline);
+  }
+
+  public ScanArea[] getScanAreas() {
+    return this.scanAreas;
+  }
+
+  public int getLearnedFacesYes() {
+    return this.possibilityFaceYes;
+  }
+
+  public int getLearnedFacesNo() {
+    return this.possibilityFaceNo;
+  }
+
+  public float getPossibility(int scanAreaID, boolean faceYes, boolean bright) {
+    if (faceYes) {
+      return (bright ? this.possibilities_FaceYes[scanAreaID]
+          : 1 - this.possibilities_FaceYes[scanAreaID]);
+    } else {
+      return (bright ? this.possibilities_FaceNo[scanAreaID]
+          : 1 - this.possibilities_FaceNo[scanAreaID]);
+    }
+  }
+
+  public int compareTo(Classifier o) {
+    if (o.getScanAreas().length > this.getScanAreas().length) {
+      return -1;
+    } else if (o.getScanAreas().length < this.getScanAreas().length) {
+      return 1;
+    } else
+      return 0;
+  }
+
+  public String toString() {
+
+     String str = "";
+    for ( int i = 0; i < scanAreas.length; i++) {
+      str += scanAreas[i].toString() + "\n";
+    }
+
+    return str;
+
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ClassifierTree.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ClassifierTree.java
new file mode 100644 (file)
index 0000000..1454902
--- /dev/null
@@ -0,0 +1,193 @@
+import SSJava.PCLOC;
+
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * 
+ * @author Florian
+ */
+
+
+public class ClassifierTree {
+
+  
+  private Classifier classifiers[];
+
+  public ClassifierTree(int size) {
+    classifiers = new Classifier[size];
+  }
+
+  public void addClassifier( int idx,  Classifier c) {
+    classifiers[idx] = c;
+  }
+
+  /**
+   * Locates a face by searching radial starting at the last known position. If
+   * lastCoordinates are null we simply start in the center of the image.
+   * <p>
+   * TODO: This method could quite possible be tweaked so that face recognition
+   * would be much faster
+   * 
+   * @param image
+   *          the image to process
+   * @param lastCoordinates
+   *          the last known coordinates or null if unknown
+   * @return an rectangle representing the actual face position on success or
+   *         null if no face could be detected
+   */
+  
+  
+  public Rectangle2D locateFaceRadial( Image smallImage,
+       Rectangle2D lastCoordinates) {
+
+     IntegralImageData imageData = new IntegralImageData(smallImage);
+     float originalImageFactor = 1;
+
+    if (lastCoordinates == null) {
+      // if we don't have a last coordinate we just begin in the center
+       int smallImageMaxDimension =
+          Math.min(smallImage.getWidth(), smallImage.getHeight());
+      lastCoordinates =
+          new Rectangle2D((smallImage.getWidth() - smallImageMaxDimension) / 2.0,
+              (smallImage.getHeight() - smallImageMaxDimension) / 2.0, smallImageMaxDimension,
+              smallImageMaxDimension);
+      // System.out.println("lastCoordinates=" + lastCoordinates);
+    } else {
+      // first we have to scale the last coodinates back relative to the resized
+      // image
+      lastCoordinates =
+          new Rectangle2D((lastCoordinates.getX() * (1 / originalImageFactor)),
+              (lastCoordinates.getY() * (1 / originalImageFactor)),
+              (lastCoordinates.getWidth() * (1 / originalImageFactor)),
+              (lastCoordinates.getHeight() * (1 / originalImageFactor)));
+    }
+
+     float startFactor = (float) (lastCoordinates.getWidth() / 100.0f);
+
+    // first we calculate the maximum scale factor for our 200x200 image
+     float maxScaleFactor =
+        Math.min(imageData.getWidth() / 100f, imageData.getHeight() / 100f);
+    // maxScaleFactor = 1.0f;
+
+    // we simply won't recognize faces that are smaller than 40x40 px
+     float minScaleFactor = 0.5f;
+
+     float maxScaleDifference =
+        Math.max(Math.abs(maxScaleFactor - startFactor), Math.abs(minScaleFactor - startFactor));
+
+    // border for faceYes-possibility must be greater that that
+     float maxBorder = 0.999f;
+
+     int startPosX = (int) lastCoordinates.getX();
+     int startPosY = (int) lastCoordinates.getX();
+
+     int loopidx = 0;
+    TERMINATE: for ( float factorDiff = 0.0f; Math.abs(factorDiff) <= maxScaleDifference; factorDiff =
+        (factorDiff + sgn(factorDiff) * 0.1f) * -1 // we alternate between
+                                                   // negative and positiv
+                                                   // factors
+    ) {
+
+      if (++loopidx > 1000) {
+        return null;
+      }
+
+       float factor = startFactor + factorDiff;
+      if (factor > maxScaleFactor || factor < minScaleFactor)
+        continue;
+
+      // now we calculate the actualDimmension
+       int actualDimmension = (int) (100 * factor);
+       int maxX = imageData.getWidth() - actualDimmension;
+       int maxY = imageData.getHeight() - actualDimmension;
+
+       int maxDiffX = Math.max(Math.abs(startPosX - maxX), startPosX);
+       int maxDiffY = Math.max(Math.abs(startPosY - maxY), startPosY);
+
+       int xidx = 0;
+      TERMINATE: for ( float xDiff = 0.1f; Math.abs(xDiff) <= maxDiffX; xDiff =
+          (xDiff + sgn(xDiff) * 0.5f) * -1) {
+
+        if (++xidx > 1000) {
+          return null;
+        }
+
+         int xPos = Math.round((float) (startPosX + xDiff));
+
+        if (xPos < 0 || xPos > maxX)
+          continue;
+
+         int yidx = 0;
+        // yLines:
+        TERMINATE: for ( float yDiff = 0.1f; Math.abs(yDiff) <= maxDiffY; yDiff =
+            (yDiff + sgn(yDiff) * 0.5f) * -1) {
+
+          if (++yidx > 1000) {
+            return null;
+          }
+
+           int yPos = Math.round(startPosY + yDiff);
+          if (yPos < 0 || yPos > maxY)
+            continue;
+
+          // by now we should have a valid coordinate to process which we should
+          // do now
+           boolean backToYLines = false;
+          for ( int idx = 0; idx < classifiers.length; ++idx) {
+             float borderline =
+                0.8f + (idx / (classifiers.length - 1)) * (maxBorder - 0.8f);
+            if (!classifiers[idx].classifyFace(imageData, factor, xPos, yPos, borderline)) {
+              backToYLines = true;
+              break;
+              // continue yLines;
+            }
+          }
+
+          // if we reach here we have a face recognized because our image went
+          // through all
+          // classifiers
+
+          if (backToYLines) {
+            continue;
+          }
+           Rectangle2D faceRect =
+              new Rectangle2D(xPos * originalImageFactor, yPos * originalImageFactor,
+                  actualDimmension * originalImageFactor, actualDimmension * originalImageFactor);
+
+          return faceRect;
+
+        }
+
+      }
+
+    }
+
+    // System.out.println("Time: "+(System.currentTimeMillis()-timeStart)+"ms");
+    return null;
+
+  }
+
+  
+  
+  private static int sgn( float value) {
+    return (value < 0 ? -1 : (value > 0 ? +1 : 1));
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Counter.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Counter.java
new file mode 100644 (file)
index 0000000..a5a4ac3
--- /dev/null
@@ -0,0 +1,15 @@
+public class Counter {
+
+  static int idx = 0;
+
+  @TRUST
+  static boolean inc() {
+    idx++;
+  }
+
+  @TRUST
+  static int idx() {
+    return idx;
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/DeviationScanner.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/DeviationScanner.java
new file mode 100644 (file)
index 0000000..4cc353e
--- /dev/null
@@ -0,0 +1,171 @@
+/*\r
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)\r
+ * \r
+ * This file is part of LEA.\r
+ * \r
+ * LEA is free software: you can redistribute it and/or modify it under the\r
+ * terms of the GNU Lesser General Public License as published by the Free\r
+ * Software Foundation, either version 3 of the License, or (at your option) any\r
+ * later version.\r
+ * \r
+ * LEA is distributed in the hope that it will be useful, but WITHOUT ANY\r
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR\r
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more\r
+ * details.\r
+ * \r
+ * You should have received a copy of the GNU Lesser General Public License\r
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.\r
+ */\r
+\r
+/**\r
+ * No description given.\r
+ * \r
+ * @author Florian Frankenberger\r
+ */\r
+\r
+\r
+public class DeviationScanner {\r
+\r
+  \r
+  private EyePosition eyePositions[];\r
+\r
+  // LEFT_UP(+1, -1), UP(0, -1), RIGHT_UP(-1, -1), LEFT(+1, 0), NONE(0, 0),\r
+  // RIGHT(-1, 0), LEFT_DOWN(\r
+  // +1, +1), DOWN(0, +1), RIGHT_DOWN(-1, +1);\r
+\r
+  public static final int LEFT_UP = 0;\r
+  public static final int UP = 1;\r
+  public static final int RIGHT_UP = 2;\r
+  public static final int LEFT = 3;\r
+  public static final int NONE = 4;\r
+  public static final int RIGHT = 5;\r
+  public static final int LEFT_DOWN = 6;\r
+  public static final int DOWN = 7;\r
+  public static final int RIGHT_DOWN = 8;\r
+\r
+  public DeviationScanner() {\r
+    eyePositions = new EyePosition[3];\r
+  }\r
+\r
+  \r
+  public void addEyePosition( EyePosition eyePosition) {\r
+\r
+    // for ( int i = 1; i < 3; i++) {\r
+    // eyePositions[i - 1] = eyePositions[i];\r
+    // eyePositions[i] = null;\r
+    // }\r
+    // eyePositions[eyePositions.length - 1] = eyePosition;\r
+\r
+    SSJAVA.append(eyePositions, eyePosition);\r
+\r
+  }\r
+\r
+  // \r
+  \r
+  \r
+  public int scanForDeviation( Rectangle2D faceRect) {\r
+\r
+     int deviation = NONE;\r
+\r
+    for ( int i = 0; i < 3; i++) {\r
+      if (eyePositions[i] == null) {\r
+        return deviation;\r
+      }\r
+    }\r
+\r
+     double deviationX = 0;\r
+     double deviationY = 0;\r
+\r
+     int lastIdx = -1;\r
+    for ( int i = 0; i < 3; ++i) {\r
+      if (lastIdx != -1) {\r
+        deviationX += (eyePositions[i].getX() - eyePositions[lastIdx].getX());\r
+        deviationY += (eyePositions[i].getY() - eyePositions[lastIdx].getY());\r
+      }\r
+      lastIdx = i;\r
+    }\r
+\r
+     final double deviationPercentX = 0.04;\r
+     final double deviationPercentY = 0.04;\r
+\r
+    deviationX /= faceRect.getWidth();\r
+    deviationY /= faceRect.getWidth();\r
+\r
+     int deviationAbsoluteX = 0;\r
+     int deviationAbsoluteY = 0;\r
+    if (deviationX > deviationPercentX)\r
+      deviationAbsoluteX = 1;\r
+    if (deviationX < -deviationPercentX)\r
+      deviationAbsoluteX = -1;\r
+    if (deviationY > deviationPercentY)\r
+      deviationAbsoluteY = 1;\r
+    if (deviationY < -deviationPercentY)\r
+      deviationAbsoluteY = -1;\r
+\r
+    deviation = getDirectionFor(deviationAbsoluteX, deviationAbsoluteY);\r
+\r
+    if (deviation != NONE) {\r
+      eyePositions = new EyePosition[3];\r
+    }\r
+    // System.out.println(String.format("%.2f%% | %.2f%% => %d and %d >>> %s",\r
+    // deviationX*100, deviationY*100, deviationAbsoluteX, deviationAbsoluteY,\r
+    // deviation.toString()));\r
+\r
+    return deviation;\r
+  }\r
+\r
+  \r
+  public int getDirectionFor( int directionX,  int directionY) {\r
+\r
+    if (directionX == +1 && directionY == -1) {\r
+      return LEFT_UP;\r
+    } else if (directionX == 0 && directionY == -1) {\r
+      return UP;\r
+    } else if (directionX == -1 && directionY == -1) {\r
+      return RIGHT_UP;\r
+    } else if (directionX == +1 && directionY == 0) {\r
+      return LEFT;\r
+    } else if (directionX == 0 && directionY == 0) {\r
+      return NONE;\r
+    } else if (directionX == -1 && directionY == 0) {\r
+      return RIGHT;\r
+    } else if (directionX == +1 && directionY == +1) {\r
+      return LEFT_DOWN;\r
+    } else if (directionX == 0 && directionY == +1) {\r
+      return DOWN;\r
+    } else if (directionX == -1 && directionY == +1) {\r
+      return RIGHT_DOWN;\r
+    }\r
+\r
+    return -1;\r
+  }\r
+\r
+  public void clear() {\r
+    System.out.println("CLEAR");\r
+    eyePositions = new EyePosition[3];\r
+  }\r
+\r
+  public String toStringDeviation( int dev) {\r
+    if (dev == LEFT_UP) {\r
+      return "LEFT_UP";\r
+    } else if (dev == UP) {\r
+      return "UP";\r
+    } else if (dev == RIGHT_UP) {\r
+      return "RIGHT_UP";\r
+    } else if (dev == LEFT) {\r
+      return "LEFT";\r
+    } else if (dev == NONE) {\r
+      return "NONE";\r
+    } else if (dev == RIGHT) {\r
+      return "RIGHT";\r
+    } else if (dev == LEFT_DOWN) {\r
+      return "LEFT_DOWN";\r
+    } else if (dev == DOWN) {\r
+      return "DOWN";\r
+    } else if (dev == RIGHT_DOWN) {\r
+      return "RIGHT_DOWN";\r
+    }\r
+    return "ERROR";\r
+  }\r
+\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Dimension.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Dimension.java
new file mode 100644 (file)
index 0000000..c6013eb
--- /dev/null
@@ -0,0 +1,5 @@
+public class Dimension {
+  public int width;
+  public int height;
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/DummyCaptureDevice.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/DummyCaptureDevice.java
new file mode 100644 (file)
index 0000000..699a620
--- /dev/null
@@ -0,0 +1,52 @@
+/**\r
+ * \r
+ */\r
+\r
+import java.awt.Color;\r
+import java.awt.Graphics2D;\r
+import java.awt.image.BufferedImage;\r
+\r
+import de.darkblue.lea.ifaces.ICaptureDevice;\r
+\r
+/**\r
+ * No description given.\r
+ * \r
+ * @author Florian Frankenberger\r
+ */\r
+public class DummyCaptureDevice implements ICaptureDevice {\r
+\r
+       /**\r
+        * \r
+        */\r
+       public DummyCaptureDevice() {\r
+               // TODO Auto-generated constructor stub\r
+       }\r
+\r
+       /* (non-Javadoc)\r
+        * @see de.darkblue.lea.ifaces.ICaptureDevice#close()\r
+        */\r
+       @Override\r
+       public void close() {\r
+       }\r
+\r
+       /* (non-Javadoc)\r
+        * @see de.darkblue.lea.ifaces.ICaptureDevice#getFrameRate()\r
+        */\r
+       @Override\r
+       public int getFrameRate() {\r
+               return 15;\r
+       }\r
+\r
+       /* (non-Javadoc)\r
+        * @see de.darkblue.lea.ifaces.ICaptureDevice#getImage()\r
+        */\r
+       @Override\r
+       public BufferedImage getImage() {\r
+               BufferedImage image = new BufferedImage(640, 480, BufferedImage.TYPE_INT_RGB);\r
+               Graphics2D g2d = (Graphics2D)image.getGraphics();\r
+               g2d.setColor(new Color(255, 255, 255));\r
+               g2d.fillRect(0, 0, 639, 479);\r
+               return image;\r
+       }\r
+\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/EyeDetector.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/EyeDetector.java
new file mode 100644 (file)
index 0000000..11443ab
--- /dev/null
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * No description given.
+ * 
+ * @author Florian Frankenberger
+ */
+
+
+class EyeDetector {
+
+  
+  private int width;
+  
+  private int height;
+  
+  private int[] pixelBuffer;
+  
+  double percent;
+
+  public EyeDetector(Image image, Rectangle2D faceRect) {
+
+    percent = 0.15 * faceRect.getWidth();
+    Rectangle2D adjustedFaceRect =
+        new Rectangle2D(faceRect.getX() + percent, faceRect.getY() + percent, faceRect.getWidth()
+            - percent, faceRect.getHeight() - 2 * percent);
+
+    width = (int) adjustedFaceRect.getWidth() / 2;
+    height = (int) adjustedFaceRect.getHeight() / 2;
+    pixelBuffer = new int[width * height];
+
+    int startX = (int) adjustedFaceRect.getX();
+    int startY = (int) adjustedFaceRect.getY();
+
+    for (int y = 0; y < height; y++) {
+      for (int x = 0; x < width; x++) {
+        pixelBuffer[(y * width) + x] = (int) image.getPixel(x + startX, y + startY);
+      }
+    }
+
+  }
+
+  
+  public Point detectEye() {
+     Point eyePosition = null;
+     float brightness = 255f;
+    for ( int y = 0; y < height; ++y) {
+      for ( int x = 0; x < width; ++x) {
+         final int position = y * width + x;
+         final int[] color =
+            new int[] { (pixelBuffer[position] & 0xFF0000) >> 16,
+                (pixelBuffer[position] & 0x00FF00) >> 8, pixelBuffer[position] & 0x0000FF };
+        // System.out.println("("+x+","+y+")="+color[0]+" "+color[1]+" "+color[2]);
+         final float acBrightness = getBrightness(color);
+
+        if (acBrightness < brightness) {
+          eyePosition = new Point(x + (int) percent, y + (int) percent);
+          brightness = acBrightness;
+        }
+      }
+    }
+
+    return eyePosition;
+  }
+
+  
+  private static float getBrightness( int[] color) {
+     int min = Math.min(Math.min(color[0], color[1]), color[2]);
+     int max = Math.max(Math.max(color[0], color[1]), color[2]);
+
+    return 0.5f * (max + min);
+  }
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/EyePosition.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/EyePosition.java
new file mode 100644 (file)
index 0000000..500b008
--- /dev/null
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * No description given.
+ * 
+ * @author Florian Frankenberger
+ */
+
+
+public class EyePosition {
+  
+  private int x;
+  
+  private int y;
+  
+  private Rectangle2D faceRect;
+
+  public EyePosition(Point p, Rectangle2D faceRect) {
+    this(p.x, p.y, faceRect);
+  }
+
+  public EyePosition(int x, int y, Rectangle2D faceRect) {
+    this.x = x;
+    this.y = y;
+    this.faceRect = faceRect;
+  }
+
+  public int getX() {
+    return this.x;
+  }
+
+  public int getY() {
+    return this.y;
+  }
+
+  public String toString() {
+    return "(" + x + "," + y + ")";
+  }
+
+  // public Deviation getDeviation(EyePosition oldEyePosition) {
+  // if (oldEyePosition == null) return Deviation.NONE;
+  //
+  // //first we check if the faceRects are corresponding
+  // double widthChange = (this.faceRect.getWidth() -
+  // oldEyePosition.faceRect.getWidth()) / this.faceRect.getWidth();
+  // if (widthChange > 0.1) return Deviation.NONE;
+  //
+  // int maxDeviationX = (int)Math.round(this.faceRect.getWidth() / 4f);
+  // int maxDeviationY = (int)Math.round(this.faceRect.getWidth() / 8f);
+  // int minDeviation = (int)Math.round(this.faceRect.getWidth() / 16f);
+  //
+  // int deviationX = Math.abs(x - oldEyePosition.x);
+  // int directionX = sgn(x - oldEyePosition.x);
+  // if (deviationX < minDeviation || deviationX > maxDeviationX) directionX =
+  // 0;
+  //
+  // int deviationY = Math.abs(y - oldEyePosition.y);
+  // int directionY = sgn(y - oldEyePosition.y);
+  // if (deviationY < minDeviation || deviationY > maxDeviationY) directionY =
+  // 0;
+  //
+  // double deviationXPercent = deviationX / this.faceRect.getWidth();
+  // double deviationYPercent = deviationY / this.faceRect.getWidth();
+  //
+  // System.out.println(String.format("devX: %.2f | devY: %.2f",
+  // deviationXPercent*100f, deviationYPercent*100f));
+  // return Deviation.getDirectionFor(directionX, directionY);
+  // }
+
+  private static int sgn(int i) {
+    if (i > 0)
+      return 1;
+    if (i < 0)
+      return -1;
+    return 0;
+  }
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/FaceAndEyePosition.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/FaceAndEyePosition.java
new file mode 100644 (file)
index 0000000..cf24488
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * No description given.
+ * 
+ * @author Florian Frankenberger
+ */
+
+
+public class FaceAndEyePosition {
+
+  
+  private Rectangle2D facePosition;
+  
+  private EyePosition eyePosition;
+
+  public FaceAndEyePosition(Rectangle2D facePosition, EyePosition eyePosition) {
+    this.facePosition = facePosition;
+    this.eyePosition = eyePosition;
+  }
+
+  public Rectangle2D getFacePosition() {
+    return this.facePosition;
+  }
+
+  public EyePosition getEyePosition() {
+    return this.eyePosition;
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ICaptureDevice.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ICaptureDevice.java
new file mode 100644 (file)
index 0000000..f050a97
--- /dev/null
@@ -0,0 +1,52 @@
+/*\r
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)\r
+ * \r
+ * This file is part of LEA.\r
+ * \r
+ * LEA is free software: you can redistribute it and/or modify it under the\r
+ * terms of the GNU Lesser General Public License as published by the Free\r
+ * Software Foundation, either version 3 of the License, or (at your option) any\r
+ * later version.\r
+ * \r
+ * LEA is distributed in the hope that it will be useful, but WITHOUT ANY\r
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR\r
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more\r
+ * details.\r
+ * \r
+ * You should have received a copy of the GNU Lesser General Public License\r
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.\r
+ */\r
+\r
+\r
+import java.awt.image.BufferedImage;\r
+\r
+/**\r
+ * Describes a capture device. For now it is only tested\r
+ * with images in <code>640x480</code> at <code>RGB</code> or <code>YUV</code> color space.\r
+ * \r
+ * @author Florian Frankenberger\r
+ */\r
+public interface ICaptureDevice {\r
+\r
+       /**\r
+        * Returns the frame rate of the image source per second\r
+        * \r
+        * @return the frame rate (e.g. 15 = 15 frames per second)\r
+        */\r
+       public int getFrameRate();\r
+\r
+       /**\r
+        * Will be called a maximum of getFrameRate()-times in a second and returns\r
+        * the actual image of the capture device\r
+        *  \r
+        * @return the actual image of the capture device \r
+        */\r
+       public BufferedImage getImage();\r
+       \r
+       /**\r
+        * LEA calls this when it cleans up. You should put your own cleanup code in here.\r
+        */\r
+       public void close();\r
+       \r
+       \r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Image.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Image.java
new file mode 100644 (file)
index 0000000..d91a7e4
--- /dev/null
@@ -0,0 +1,50 @@
+
+
+public class Image {
+
+  
+  int width;
+  
+  int height;
+  
+  int pixel[][];
+
+  public Image(int width, int height) {
+    this.width = width;
+    this.height = height;
+    pixel = new int[width][height];
+  }
+
+  public void setPixel(int x, int y, int R, int G, int B) {
+    pixel[x][y] = (R << 16) | (G << 8) | B;
+  }
+
+  public int getRed(int x, int y) {
+    return (pixel[x][y] >> 16) & 0xff;
+  }
+
+  public int getGreen(int x, int y) {
+    return (pixel[x][y] >> 8) & 0xff;
+  }
+
+  public int getBlue(int x, int y) {
+    return pixel[x][y] & 0xff;
+  }
+
+  public void setPixel(int x, int y, int p) {
+    pixel[x][y] = p;
+  }
+
+  public long getPixel(int x, int y) {
+    return pixel[x][y];
+  }
+
+  public int getWidth() {
+    return width;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ImageReader.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ImageReader.java
new file mode 100644 (file)
index 0000000..36aa569
--- /dev/null
@@ -0,0 +1,193 @@
+public class ImageReader {
+
+  static int idx = 0;
+
+  public ImageReader() {
+  }
+
+  @TRUST
+  public static Image getImage() {
+    System.out.println(idx);
+    Image image = ImageReader.readImage("data/b" + idx + ".bmp");
+    idx++;
+    if (idx > 73) {
+      return null;
+    }
+    return image;
+  }
+
+  public static Image readImage(String file) {
+
+    FileInputStream fs = new FileInputStream(file);
+    int bflen = 14; // 14 byte BITMAPFILEHEADER
+    byte bf[] = new byte[bflen];
+    // fs.read(bf,0,bflen);
+    fs.read(bf);
+    int bilen = 40; // 40-byte BITMAPINFOHEADER
+    byte bi[] = new byte[bilen];
+    // fs.read(bi,0,bilen);
+    fs.read(bi);
+    // Interperet data.
+    int nsize =
+        (((int) bf[5] & 0xff) << 24) | (((int) bf[4] & 0xff) << 16) | (((int) bf[3] & 0xff) << 8)
+            | (int) bf[2] & 0xff;
+    // System.out.println("File type is :" + (char) bf[0] + (char) bf[1]);
+    // System.out.println("Size of file is :" + nsize);
+    int nbisize =
+        (((int) bi[3] & 0xff) << 24) | (((int) bi[2] & 0xff) << 16) | (((int) bi[1] & 0xff) << 8)
+            | (int) bi[0] & 0xff;
+    // System.out.println("Size of bitmapinfoheader is :" + nbisize);
+    int nwidth =
+        (((int) bi[7] & 0xff) << 24) | (((int) bi[6] & 0xff) << 16) | (((int) bi[5] & 0xff) << 8)
+            | (int) bi[4] & 0xff;
+    // System.out.println("Width is :" + nwidth);
+    int nheight =
+        (((int) bi[11] & 0xff) << 24) | (((int) bi[10] & 0xff) << 16) | (((int) bi[9] & 0xff) << 8)
+            | (int) bi[8] & 0xff;
+    // System.out.println("Height is :" + nheight);
+    int nplanes = (((int) bi[13] & 0xff) << 8) | (int) bi[12] & 0xff;
+    // System.out.println("Planes is :" + nplanes);
+    int nbitcount = (((int) bi[15] & 0xff) << 8) | (int) bi[14] & 0xff;
+    // System.out.println("BitCount is :" + nbitcount);
+    // Look for non-zero values to indicate compression
+    int ncompression =
+        (((int) bi[19]) << 24) | (((int) bi[18]) << 16) | (((int) bi[17]) << 8) | (int) bi[16];
+    // System.out.println("Compression is :" + ncompression);
+    int nsizeimage =
+        (((int) bi[23] & 0xff) << 24) | (((int) bi[22] & 0xff) << 16)
+            | (((int) bi[21] & 0xff) << 8) | (int) bi[20] & 0xff;
+    // System.out.println("SizeImage is :" + nsizeimage);
+
+    int nxpm =
+        (((int) bi[27] & 0xff) << 24) | (((int) bi[26] & 0xff) << 16)
+            | (((int) bi[25] & 0xff) << 8) | (int) bi[24] & 0xff;
+    // System.out.println("X-Pixels per meter is :" + nxpm);
+    int nypm =
+        (((int) bi[31] & 0xff) << 24) | (((int) bi[30] & 0xff) << 16)
+            | (((int) bi[29] & 0xff) << 8) | (int) bi[28] & 0xff;
+    // System.out.println("Y-Pixels per meter is :" + nypm);
+    int nclrused =
+        (((int) bi[35] & 0xff) << 24) | (((int) bi[34] & 0xff) << 16)
+            | (((int) bi[33] & 0xff) << 8) | (int) bi[32] & 0xff;
+    // System.out.println("Colors used are :" + nclrused);
+    int nclrimp =
+        (((int) bi[39] & 0xff) << 24) | (((int) bi[38] & 0xff) << 16)
+            | (((int) bi[37] & 0xff) << 8) | (int) bi[36] & 0xff;
+    // System.out.println("Colors important are :" + nclrimp);
+
+    Image image = new Image(nwidth, nheight);
+
+    if (nbitcount == 24) {
+      // No Palatte data for 24-bit format but scan lines are
+      // padded out to even 4-byte boundaries.
+      int npad = (nsizeimage / nheight) - nwidth * 3;
+      // ndata = new int[(nheight * nwidth) + 4];
+      byte brgb[] = new byte[(nwidth + npad) * 3 * nheight];
+      // fs.read (brgb, 0, (nwidth + npad) * 3 * nheight);
+      fs.read(brgb);
+      int nindex = 0;
+      int yPos = 0;
+      for (int j = 0; j < nheight; j++) {
+        for (int i = 0; i < nwidth; i++) {
+          // ndata[nwidth * (nheight - j - 1) + i] =
+          // (255 & 0xff) << 24 | (((int) brgb[nindex + 2] & 0xff) << 16)
+          // | (((int) brgb[nindex + 1] & 0xff) << 8) | (int) brgb[nindex] &
+          // 0xff;
+          int ta =
+              ((3 * ((int) (brgb[nindex + 2]) & 0xff) + 6 * ((int) brgb[nindex + 1] & 0xff) + ((int) brgb[nindex] & 0xff))) / 10;
+
+          // ndata[nwidth * (nheight - j - 1) + i + 4] = ta;
+          yPos = nheight - j - 1;
+          // System.out.println("yPos=" + yPos + " nheight=" + nheight + " j=" +
+          // j);
+          // System.out.println("Encoded Color at (" + i + "," + yPos + ")is:" +
+          // brgb + " (R,G,B)= ("
+          // + ((int) (brgb[nindex + 2]) & 0xff) + "," + ((int) brgb[nindex + 1]
+          // & 0xff) + ","
+          // + ((int) brgb[nindex] & 0xff) + ")" + "cufoff=" + ta);
+          image.setPixel(i, yPos, ((int) brgb[nindex + 2] & 0xff), ((int) brgb[nindex + 1] & 0xff),
+              ((int) brgb[nindex] & 0xff));
+          nindex += 3;
+        }
+        nindex += npad;
+      }
+      // image = createImage
+      // ( new MemoryImageSource (nwidth, nheight,
+      // ndata, 0, nwidth));
+
+    } else if (nbitcount == 8) {
+      // Have to determine the number of colors, the clrsused
+      // parameter is dominant if it is greater than zero. If
+      // zero, calculate colors based on bitsperpixel.
+      int nNumColors = 0;
+      if (nclrused > 0) {
+        nNumColors = nclrused;
+      } else {
+        nNumColors = (1 & 0xff) << nbitcount;
+      }
+      System.out.println("The number of Colors is" + nNumColors);
+      // Some bitmaps do not have the sizeimage field calculated
+      // Ferret out these cases and fix 'em.
+      if (nsizeimage == 0) {
+        nsizeimage = ((((nwidth * nbitcount) + 31) & 31) >> 3);
+        nsizeimage *= nheight;
+        System.out.println("nsizeimage (backup) is" + nsizeimage);
+      }
+      // Read the palatte colors.
+      int npalette[] = new int[nNumColors];
+      byte bpalette[] = new byte[nNumColors * 4];
+      // fs.read (bpalette, 0, nNumColors*4);
+      fs.read(bpalette);
+      int nindex8 = 0;
+      for (int n = 0; n < nNumColors; n++) {
+        npalette[n] =
+            (255 & 0xff) << 24 | (((int) bpalette[nindex8 + 2] & 0xff) << 16)
+                | (((int) bpalette[nindex8 + 1] & 0xff) << 8) | (int) bpalette[nindex8] & 0xff;
+        // System.out.println ("Palette Color "+n
+        // +" is:"+npalette[n]+" (res,R,G,B)= (" +((int)(bpalette[nindex8+3]) &
+        // 0xff)+"," +((int)(bpalette[nindex8+2]) & 0xff)+","
+        // +((int)bpalette[nindex8+1]&0xff)+","
+        // +((int)bpalette[nindex8]&0xff)+")");
+
+        nindex8 += 4;
+      }
+      // Read the image data (actually indices into the palette)
+      // Scan lines are still padded out to even 4-byte
+      // boundaries.
+      int npad8 = (nsizeimage / nheight) - nwidth;
+      // System.out.println("nPad is:" + npad8);
+      // int ndata8[] = new int[nwidth * nheight];
+      // ndata = new int[(nwidth * nheight) + 4];
+      byte bdata[] = new byte[(nwidth + npad8) * nheight];
+      // fs.read (bdata, 0, (nwidth+npad8)*nheight);
+      fs.read(bdata);
+      nindex8 = 0;
+      for (int j8 = 0; j8 < nheight; j8++) {
+        for (int i8 = 0; i8 < nwidth; i8++) {
+          // ndata[nwidth * (nheight - j8 - 1) + i8 + 4] = npalette[((int)
+          // bdata[nindex8] & 0xff)];
+          image.setPixel(i8, j8, npalette[((int) bdata[nindex8] & 0xff)]);
+          // System.out.println("Encoded Color at (" + i8 + "," + j8 + ")is: "
+          // + ndata[nwidth * (nheight - j8 - 1) + i8 + 4]);
+          nindex8++;
+        }
+        nindex8 += npad8;
+      }
+      // image = createImage ( new MemoryImageSource (nwidth, nheight,
+      // ndata8, 0, nwidth));
+    } else {
+      System.out.println("Not a 24-bit or 8-bit Windows Bitmap, aborting...");
+      // image = (Image)null;
+    }
+    fs.close();
+
+    // ndata[0] = nheight;
+    // ndata[1] = nwidth;
+    // ndata[2] = nheight * nwidth;
+    // ndata[3] = 2;
+
+    return image;
+    // return ndata;
+
+  }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/IntegralImageData.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/IntegralImageData.java
new file mode 100644 (file)
index 0000000..d517a37
--- /dev/null
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * No description given.
+ * 
+ * @author Florian Frankenberger
+ */
+
+
+public class IntegralImageData {
+
+  
+  private long[][] integral;
+  
+  private int width;
+  
+  private int hegith;
+
+  // private Dimension dimension;
+
+  public IntegralImageData(Image bufferedImage) {
+    this.integral = new long[bufferedImage.getWidth()][bufferedImage.getHeight()];
+    this.width = bufferedImage.getWidth();
+    this.hegith = bufferedImage.getHeight();
+
+    long[][] s = new long[bufferedImage.getWidth()][bufferedImage.getHeight()];
+    for (int y = 0; y < bufferedImage.getHeight(); ++y) {
+      for (int x = 0; x < bufferedImage.getWidth(); ++x) {
+        s[x][y] = (y - 1 < 0 ? 0 : s[x][y - 1]) + (bufferedImage.getBlue(x, y) & 0xff);
+        this.integral[x][y] = (x - 1 < 0 ? 0 : this.integral[x - 1][y]) + s[x][y];
+        // System.out.println("integral ("+x+","+y+")="+integral[x][y]);
+      }
+    }
+
+  }
+
+  public long getIntegralAt( int x,  int y) {
+    return this.integral[x][y];
+  }
+
+  public int getWidth() {
+    return width;
+  }
+
+  public int getHeight() {
+    return hegith;
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LATTICE.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LATTICE.java
new file mode 100644 (file)
index 0000000..3cb4b1d
--- /dev/null
@@ -0,0 +1,3 @@
+public @interface LATTICE {
+  String value();
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LEA.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LEA.java
new file mode 100644 (file)
index 0000000..48a1577
--- /dev/null
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * This is the main class of LEA.
+ * <p>
+ * It uses a face detection algorithm to find an a face within the provided
+ * image(s). Then it searches for the eye in a region where it most likely
+ * located and traces its position relative to the face and to the last known
+ * position. The movements are estimated by comparing more than one movement. If
+ * a movement is distinctly pointing to a direction it is recognized and all
+ * listeners get notified.
+ * <p>
+ * The notification is designed as observer pattern. You simply call
+ * <code>addEyeMovementListener(IEyeMovementListener)</code> to add an
+ * implementation of <code>IEyeMovementListener</code> to LEA. When a face is
+ * recognized/lost or whenever an eye movement is detected LEA will call the
+ * appropriate methods of the listener
+ * <p>
+ * LEA also needs an image source implementing the <code>ICaptureDevice</code>.
+ * One image source proxy to the <code>Java Media Framework</code> is included (
+ * <code>JMFCaptureDevice</code>).
+ * <p>
+ * Example (for using LEA with <code>Java Media Framework</code>):
+ * <p>
+ * <code>
+ * LEA lea = new LEA(new JMFCaptureDevice(), true);
+ * </code>
+ * <p>
+ * This will start LEA with the first available JMF datasource with an extra
+ * status window showing if face/eye has been detected successfully. Please note
+ * that face detection needs about 2 seconds to find a face. After detection the
+ * following face detection is much faster.
+ * 
+ * @author Florian Frankenberger
+ */
+
+
+public class LEA {
+
+  
+  private LEAImplementation implementation;
+  
+  private FaceAndEyePosition lastPositions = new FaceAndEyePosition(null, null);
+  
+  private DeviationScanner deviationScanner = new DeviationScanner();
+
+  public LEA() {
+    // this.imageProcessor = new
+    // ImageProcessor(this.captureDevice.getFrameRate());
+    implementation = new LEAImplementation();
+  }
+
+  /**
+   * Clears the internal movement buffer. If you just capture some of the eye
+   * movements you should call this every time you start recording the
+   * movements. Otherwise you may get notified for movements that took place
+   * BEFORE you started recording.
+   */
+  public void clear() {
+    // this.imageProcessor.clearDeviationScanner();
+  }
+
+  /**
+   * @METHOD To test LEA with the first capture device from the
+   *         <code>Java Media Framework</code> just start from here.
+   * 
+   * @param args
+   * @throws Exception
+   */
+  public static void main(String[] args) throws Exception {
+    LEA lea = new LEA();
+    lea.doRun();
+  }
+
+  
+  public void doRun() {
+
+     int i = 0;
+
+    SSJAVA: while (true) {
+       Image image =  ImageReader.getImage();
+      if (image == null) {
+        break;
+      }
+      processImage(image);
+    }
+
+    System.out.println("Done.");
+
+  }
+  
+
+  private void processImage( Image image) {
+     FaceAndEyePosition positions = implementation.getEyePosition(image);
+    // if (positions.getEyePosition() != null) {
+    deviationScanner.addEyePosition(positions.getEyePosition());
+     int deviation =
+        deviationScanner.scanForDeviation(positions.getFacePosition());// positions.getEyePosition().getDeviation(lastPositions.getEyePosition());
+    if (deviation != DeviationScanner.NONE) {
+      System.out.println("deviation=" + deviationScanner.toStringDeviation(deviation));
+      // notifyEyeMovementListenerEyeMoved(deviation);
+    }
+    // }
+    lastPositions = positions;
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LEAImplementation.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LEAImplementation.java
new file mode 100644 (file)
index 0000000..998cd69
--- /dev/null
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * No description given.
+ * 
+ * @author Florian Frankenberger
+ */
+
+
+public class LEAImplementation {
+
+  
+  private ClassifierTree classifierTree;
+
+  
+  private Rectangle2D lastRectangle;
+
+  public LEAImplementation() {
+    this.loadFaceData();
+  }
+
+  
+  
+  public FaceAndEyePosition getEyePosition( Image image) {
+    if (image == null)
+      return null;
+     Rectangle2D faceRect =
+        classifierTree.locateFaceRadial(image, lastRectangle);
+    if (faceRect.getWidth() > image.getWidth() || faceRect.getHeight() > image.getHeight()) {
+      return null;
+    }
+     EyePosition eyePosition = null;
+    if (faceRect != null) {
+      lastRectangle = faceRect;
+      faceRect = null;
+       Point point = readEyes(image, lastRectangle);
+      if (point != null) {
+        eyePosition = new EyePosition(point, lastRectangle);
+      }
+    } else {
+      lastRectangle = null;
+    }
+    System.out.println("eyePosition=" + eyePosition);
+
+    return new FaceAndEyePosition(lastRectangle, eyePosition);
+  }
+
+  
+  
+  private Point readEyes( Image image,  Rectangle2D rect) {
+     EyeDetector ed = new EyeDetector(image, rect);
+    return ed.detectEye();
+  }
+
+  public boolean needsCalibration() {
+    return false;
+  }
+
+  /**
+   * This method loads the faceData from a file called facedata.dat which should
+   * be within the jar-file
+   */
+  private void loadFaceData() {
+
+    FileInputStream inputFile = new FileInputStream("facedata.dat");
+
+    int numClassifier = Integer.parseInt(inputFile.readLine());
+    classifierTree = new ClassifierTree(numClassifier);
+    for (int c = 0; c < numClassifier; c++) {
+
+      int numArea = Integer.parseInt(inputFile.readLine());
+      Classifier classifier = new Classifier(numArea);
+      // parsing areas
+      for (int idx = 0; idx < numArea; idx++) {
+        // 54,54,91,62,296.0
+        Point fromPoint = new Point();
+        Point toPoint = new Point();
+        fromPoint.x = Integer.parseInt(inputFile.readLine());
+        fromPoint.y = Integer.parseInt(inputFile.readLine());
+        toPoint.x = Integer.parseInt(inputFile.readLine());
+        toPoint.y = Integer.parseInt(inputFile.readLine());
+        float size = Float.parseFloat(inputFile.readLine());
+        ScanArea area = new ScanArea(fromPoint, toPoint, size);
+        classifier.setScanArea(idx, area);
+      }
+
+      // parsing possibilities face yes
+      float array[] = new float[numArea];
+      for (int idx = 0; idx < numArea; idx++) {
+        array[idx] = Float.parseFloat(inputFile.readLine());
+      }
+      classifier.setPossibilitiesFaceYes(array);
+
+      // parsing possibilities face no
+      array = new float[numArea];
+      for (int idx = 0; idx < numArea; idx++) {
+        array[idx] = Float.parseFloat(inputFile.readLine());
+      }
+      classifier.setPossibilitiesFaceNo(array);
+
+      classifier.setPossibilityFaceYes(Integer.parseInt(inputFile.readLine()));
+      classifier.setPossibilityFaceNo(Integer.parseInt(inputFile.readLine()));
+
+      classifierTree.addClassifier(c, classifier);
+    }
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LOC.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/LOC.java
new file mode 100644 (file)
index 0000000..0165516
--- /dev/null
@@ -0,0 +1,7 @@
+public @interface LOC {
+  String value();
+}
+
+public @interface RETURNLOC {
+  String value();
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Point.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Point.java
new file mode 100644 (file)
index 0000000..beb0545
--- /dev/null
@@ -0,0 +1,20 @@
+
+
+public class Point {
+
+   public int x;
+   public int y;
+
+  public Point(int x, int y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  public Point() {
+  }
+  
+  public String toString(){
+    return "("+x+","+y+")";
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Rectangle2D.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/Rectangle2D.java
new file mode 100644 (file)
index 0000000..e765e70
--- /dev/null
@@ -0,0 +1,36 @@
+
+
+public class Rectangle2D {
+
+   double x;
+   double y;
+   double width;
+   double height;
+
+  public Rectangle2D(double x, double y, double w, double h) {
+    this.x = x;
+    this.y = y;
+    this.width = w;
+    this.height = h;
+  }
+
+  public double getX() {
+    return x;
+  }
+
+  public double getY() {
+    return y;
+  }
+
+  public double getWidth() {
+    return width;
+  }
+
+  public double getHeight() {
+    return height;
+  }
+
+  public String toString() {
+    return "(" + x + "," + y + "," + width + "," + height + ")";
+  }
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ScanArea.java b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/ScanArea.java
new file mode 100644 (file)
index 0000000..abb581b
--- /dev/null
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2009 (c) Florian Frankenberger (darkblue.de)
+ * 
+ * This file is part of LEA.
+ * 
+ * LEA is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * LEA 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 Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with LEA. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * 
+ * @author Florian
+ */
+
+
+public class ScanArea {
+
+  
+  private Point fromPoint;
+  
+  private Point toPoint;
+  
+  private float size;
+
+  /**
+   * Imagine you want to classify an image with 100px x 100px what would be the
+   * scanarea in this kind of image. That size gets automatically scalled to fit
+   * bigger images
+   * 
+   * @param fromPoint
+   * @param toPoint
+   */
+  public ScanArea(Point fromPoint, Point toPoint) {
+    this.fromPoint = fromPoint;
+    this.toPoint = toPoint;
+
+    this.size = (this.toPoint.x - this.fromPoint.x) * (this.toPoint.y - this.fromPoint.y);
+  }
+
+  public ScanArea(Point fromPoint, Point toPoint, float size) {
+    this.fromPoint = fromPoint;
+    this.toPoint = toPoint;
+    this.size = size;
+  }
+
+  public ScanArea(int fromX, int fromY, int width, int height) {
+    this(new Point(fromX, fromY), new Point(fromX + width, fromY + height));
+  }
+
+  public int getFromX( float scaleFactor) {
+    return (int) (this.fromPoint.x * scaleFactor);
+  }
+
+  public int getFromY( float scaleFactor) {
+    return (int) (this.fromPoint.y * scaleFactor);
+  }
+
+  public int getToX( float scaleFactor) {
+    return (int) (this.toPoint.x * scaleFactor);
+  }
+
+  public int getToY( float scaleFactor) {
+    return (int) (this.toPoint.y * scaleFactor);
+  }
+
+  public int getSize( float scaleFactor) {
+    return (int) (this.size * Math.pow(scaleFactor, 2));
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    ScanArea other = (ScanArea) o;
+
+    return pointsWithin(other.fromPoint.x, other.toPoint.x, this.fromPoint.x, this.toPoint.x)
+        && pointsWithin(other.fromPoint.y, other.toPoint.y, this.fromPoint.y, this.toPoint.y);
+  }
+
+  private static boolean pointsWithin(int pointA1, int pointA2, int pointB1, int pointB2) {
+    boolean within = false;
+    within = within || (pointB1 >= pointA1 && pointB1 <= pointA2);
+    within = within || (pointB2 >= pointA1 && pointB2 <= pointA2);
+    within = within || (pointA1 >= pointB1 && pointA1 <= pointB2);
+    within = within || (pointA2 >= pointB1 && pointA2 <= pointB2);
+
+    return within;
+  }
+
+  // private boolean checkPoints(ScanArea a, ScanArea b) {
+  // Point[] pointsToCheck = new Point[] {
+  // a.fromPoint, a.toPoint,
+  // new Point (a.fromPoint.x, a.toPoint.y),
+  // new Point (a.toPoint.x, a.fromPoint.y)
+  // };
+  // for (Point point: pointsToCheck) {
+  // if (point.x >= b.fromPoint.x && point.x <= b.toPoint.x &&
+  // point.y >= b.fromPoint.y && point.y <= b.toPoint.y) return true;
+  // }
+  //
+  // return false;
+  // }
+
+  public String toString() {
+     String str = "";
+    str += "fromPoint=(" + fromPoint.x + "," + fromPoint.y + ")";
+    str += "toPoint=(" + toPoint.x + "," + toPoint.y + ")";
+    str += "size=" + size;
+    return str;
+  }
+}
diff --git a/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/makefile b/Robust/src/Benchmarks/SSJava/EyeTrackingInfer/makefile
new file mode 100644 (file)
index 0000000..f42b8fb
--- /dev/null
@@ -0,0 +1,52 @@
+BUILDSCRIPT=../../../buildscript
+
+PROGRAM=LEA
+SOURCE_FILES=LEA.java
+
+ifndef INV_ERROR_PROB
+INV_ERROR_PROB=1000
+endif
+
+ifndef RANDOMSEED
+RANDOMSEED=12345
+endif
+
+SSJAVA= -ssjava -ssjavainfer -ssjavadebug
+BSFLAGS= -32bit -mainclass $(PROGRAM)  -heapsize-mb 1350  -nooptimize -debug -garbagestats #-printlinenum #-joptimize
+NORMAL= -ssjava-inject-error 0 0
+INJECT_ERROR= -ssjava-inject-error $(INV_ERROR_PROB) $(RANDOMSEED)
+
+
+default: $(PROGRAM)s.bin
+
+normal: $(PROGRAM)n.bin
+
+error: $(PROGRAM)e.bin
+
+
+$(PROGRAM)s.bin: $(SOURCE_FILES) makefile
+       $(BUILDSCRIPT) $(SSJAVA) $(BSFLAGS) -o $(PROGRAM)s -builddir ssj $(SOURCE_FILES) 
+
+$(PROGRAM)n.bin: $(SOURCE_FILES) makefile
+       $(BUILDSCRIPT) $(NORMAL) $(BSFLAGS) -o $(PROGRAM)n -builddir norm $(SOURCE_FILES) 
+
+$(PROGRAM)e.bin: $(SOURCE_FILES) makefile
+       $(BUILDSCRIPT) $(SSJAVA) $(INJECT_ERROR) $(BSFLAGS) -o $(PROGRAM)e -builddir injerr $(SOURCE_FILES) 
+
+cleanerror:
+       rm -f $(PROGRAM)e.bin
+       rm -rf injerr
+
+clean:
+       rm -f  $(PROGRAM)s.bin $(PROGRAM)n.bin $(PROGRAM)e.bin
+       rm -fr ssj norm injerr
+       rm -f nve-diff.tmp nve-diff-ranges.tmp
+       rm -f  *~
+       rm -f  *.dot
+       rm -f  *.png
+       rm -f  *.pdf
+       rm -f  aliases.txt
+       rm -f  results*txt
+       rm -f  output.txt
+       rm -f *log
+
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/MotorControl.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/MotorControl.java
new file mode 100644 (file)
index 0000000..ea7f2f0
--- /dev/null
@@ -0,0 +1,318 @@
+/*\r
+ * PWMRtsj.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+/**\r
+ * This class is a wrapper for a PWMControl introduced by porting to SSJava. It\r
+ * maintains two key fields motorLeftUpTime and motorRightUpTime and expects\r
+ * that the control thread who is running from the other side gets the current\r
+ * settings.\r
+ */\r
+\r
+\r
+\r
+public class MotorControl {\r
+  \r
+  boolean DEBUG = true;\r
+  \r
+  int motorLeftUpTime = 150;\r
+  \r
+  int motorRightUpTime = 150;\r
+  \r
+  int speedFactor;\r
+  \r
+  int agilityFactor;\r
+\r
+  public MotorControl(int speedFactor, int agilityFactor) {\r
+    this.speedFactor = speedFactor;\r
+    this.agilityFactor = agilityFactor;\r
+  }\r
+\r
+  // A poor's man ajustimg for the 0 speed which found\r
+  // to be 450000 nano seconds.\r
+  \r
+  private int normalizeTime( int timePosition) {\r
+    if ((timePosition <= 50) && (timePosition >= 44)) {\r
+      return 45;\r
+    }\r
+    return timePosition;\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpin - Set speed for the spin case motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinLeft( int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+     int timePos = normalizeTime(timePosition);\r
+\r
+     int motorUpTime = (int) (timePos * agilityFactor * speedFactor);\r
+    // System.out.println("Left Motor UpTime1: " +\r
+    // Integer.toString(motorUpTime));\r
+    // Since the right motor is hanging in reverse position\r
+    // the direction should be opposit\r
+    // Bug in wait. Can't take 0 nanoseconds\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    // if (DEBUG) {\r
+    // System.out.println("setSpeedSpinLeft: output-> = " +\r
+    // Integer.toString(motorUpTime));\r
+    // }\r
+    // synchronized (this) {\r
+    /* Factor in the speed and agility factors */\r
+    motorLeftUpTime = motorUpTime;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setSpeedSpinLeft: output-> " + motorLeftUpTime);\r
+    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpinRight - Set speed for the spin case right motor.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinRight( int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* An input of 50 should result in 0 speed. */\r
+    /* 100 should result in full speed forward */\r
+    /* while 0 should result in full speed backwords */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+     int timePos = normalizeTime(timePosition);\r
+     int motorUpTime = (int) ((timePos) * agilityFactor * speedFactor);\r
+    // Bug in wait. Cant take 0 nanoseconds\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    // if (DEBUG) {\r
+    // System.out.println("setSpeedSpinRight: output-> = " +\r
+    // Integer.toString(motorUpTime));\r
+    // }\r
+    // synchronized (this) {\r
+    /* Factor in the speed and agility factors */\r
+    motorRightUpTime = motorUpTime;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setSpeedSpinRight: output-> " + motorRightUpTime);\r
+    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 1\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnLeft( int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+     int timePosLocal = normalizeTime(timePosition);\r
+     int motorUpTime =\r
+        (timePosLocal * 100 + ((100 - timePosLocal) * (100 - agilityFactor))) * speedFactor;\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+    // if (DEBUG) {\r
+    // System.out.println("setSpeedTurnLeft: output-> = " +\r
+    // Integer.toString(motorUpTime));\r
+    // }\r
+    // synchronized (this) {\r
+    /* Factor in the speed and agility factors */\r
+    motorLeftUpTime = motorUpTime;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setSpeedTurnLeft: output-> " + motorLeftUpTime);\r
+    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 2\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnRight( int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+     int timePos = normalizeTime(timePosition);\r
+     int motorUpTime =\r
+        ((timePos * 100) + ((100 - timePos) * (100 - agilityFactor))) * speedFactor;\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    // synchronized (this) {\r
+    /* Factor in the speed and agility factors */\r
+    motorRightUpTime = motorUpTime;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setSpeedTurnRight: output-> " + motorRightUpTime);\r
+    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedLeft - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedLeft( int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+     int timePos = normalizeTime(timePosition);\r
+     int motorUpTime = (int) (timePos * 100) * speedFactor;\r
+    /*\r
+     * System.out.println("motorUpTime = " + Integer.toStri\r
+     * ng(motorUpTime) + " timePos = " + Integer.toString((int)timePos) +\r
+     * " timePosition = " + Integer.toString((int)timePosition) +\r
+     * " speedFactor = " + Integer.toString(speedFactor));\r
+     */\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    // synchronized (this) {\r
+    /* Factor in speedFactor */\r
+    motorLeftUpTime = motorUpTime;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out\r
+          .println("MotorContol: setSpeedLeft: output-> " + Integer.toString(motorLeftUpTime));\r
+    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedRight - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedRight( int timePosition) {\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+     int timePos = normalizeTime(timePosition);\r
+     int motorUpTime = (int) (timePos * 100) * speedFactor;\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+    // synchronized (this) {\r
+    /* Factor in speedFactor */\r
+    motorRightUpTime = motorUpTime;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setSpeedRight: output-> " + motorRightUpTime);\r
+    }\r
+  }\r
+\r
+  public void setUrgentReverse() {\r
+    // synchronized (this) {\r
+    motorLeftUpTime = 1;\r
+    motorRightUpTime = 1;\r
+    // }\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setUrgentReverse: motorLeftUpTime-> " + motorLeftUpTime);\r
+      System.out.println("MotorControl: setUrgentReverse: motorRightUpTime-> " + motorRightUpTime);\r
+    }\r
+  }\r
+\r
+  public void setUrgentStraight() {\r
+    // synchronized (this) {\r
+    motorLeftUpTime = 99;\r
+    motorRightUpTime = 99;\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: setUrgentStraight: motorLeftUpTime-> " + motorLeftUpTime);\r
+      System.out.println("MotorControl: setUrgentStraight: motorRightUpTime-> " + motorRightUpTime);\r
+    }\r
+    // }\r
+  }\r
+\r
+  public void justSync() {\r
+    // synchronized (this) {\r
+    motorLeftUpTime = motorLeftUpTime;\r
+    motorRightUpTime = motorRightUpTime;\r
+    if (DEBUG) {\r
+      System.out.println("MotorControl: justSync: motorLeftUpTime-> " + motorLeftUpTime);\r
+      System.out.println("MotorControl: justSync: motorRightUpTime-> " + motorRightUpTime);\r
+    }\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * Control debug messageing. true - Activate debug messages false - deactivate\r
+   * debug messages\r
+   */\r
+  public void setDebug(boolean debug) {\r
+    DEBUG = debug;\r
+  }\r
+\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMControl.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMControl.java
new file mode 100644 (file)
index 0000000..05a1c56
--- /dev/null
@@ -0,0 +1,192 @@
+/*\r
+ * PWMControl.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+/**\r
+ * This class is the super class of all motor control classes. The class\r
+ * represent a generic interface to such class. In our case the motor controller\r
+ * require for 0 speed 1.5 ms out of 10-20ms cycle and a change between 1 to 2\r
+ * seconds for max reverse and forward speed. These values: 1, 1.5, 2 and 20 ms\r
+ * are thus this class specific\r
+ * \r
+ * @author Michael Gesundheit\r
+ * @version 1.0\r
+ */\r
+\r
+public abstract class PWMControl {\r
+\r
+  PWMManager pwmManager;\r
+  boolean DEBUG = false;\r
+  // boolean DEBUG = true;\r
+  static final byte PULSE_HIGH = 1;\r
+  static final byte PULSE_LOW = 0;\r
+  int highMask;\r
+  int m1HighMask;\r
+  int m2HighMask;\r
+  int lowMask;\r
+  int myOwnBit;\r
+  int myBitPos;\r
+  int m1BitPos;\r
+  int m2BitPos;\r
+  int speedFactor;\r
+  int agilityFactor;\r
+  boolean updateTime;\r
+  int pulseWidth;\r
+  Object obj;\r
+\r
+  int motorLeftUpTime = 150;\r
+  int motorRightUpTime = 150;\r
+  boolean manualMode = false;\r
+\r
+  PWMControl(PWMManager pwmMan, int motor1bit, int motor2bit) {\r
+    pwmManager = pwmMan; // This is papa\r
+    m1BitPos = 0x1 << motor1bit;\r
+    m2BitPos = 0x1 << motor2bit;\r
+    m1HighMask = 0x1 << motor1bit;\r
+    m2HighMask = 0x1 << motor2bit;\r
+    lowMask = 0x0;\r
+    obj = new Object();\r
+  }\r
+\r
+  public void setManualMode() {\r
+    if (DEBUG)\r
+      System.out.println("PWMContolr: setManualMode... ");\r
+//    synchronized (obj) {\r
+      if (manualMode == false) {\r
+        manualMode = true;\r
+      }\r
+//    }\r
+  }\r
+\r
+  public void setAutomatedMode() {\r
+    if (DEBUG)\r
+      System.out.println("PWMControl: setAutomatedMode... ");\r
+//    synchronized (obj) {\r
+      if (manualMode == true) {\r
+        System.out.println("PWMControl: wake me up... ");\r
+        manualMode = false;\r
+        // obj.notify();\r
+        System.out.println("PWMControl: wake me up...... tried!!!");\r
+      }\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * OutPut value to motor control line\r
+   */\r
+  public void outToPortMLeft(byte value) {\r
+    /*\r
+     * System.out.println("PWMControl " + Integer.toString(myOwnBit) +\r
+     * //" bit position = 0x" + Integer.toHexString(myOwnBit) +\r
+     * " output value = 0x" + Integer.toHexString(value));\r
+     */\r
+    if (value == PULSE_HIGH) {\r
+      pwmManager.writeToPort(m1BitPos, m1HighMask);\r
+    } else {\r
+      pwmManager.writeToPort(m1BitPos, lowMask);\r
+    }\r
+  }\r
+\r
+  public void outToPortMRight(byte value) {\r
+    /*\r
+     * System.out.println("PWMControl " + Integer.toString(myOwnBit) +\r
+     * //" bit position = 0x" + Integer.toHexString(myOwnBit) +\r
+     * " output value = 0x" + Integer.toHexString(value));\r
+     */\r
+    if (value == PULSE_HIGH) {\r
+      pwmManager.writeToPort(m2BitPos, m2HighMask);\r
+    } else {\r
+      pwmManager.writeToPort(m2BitPos, lowMask);\r
+    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpin - Set speed for the spin case motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinLeft(int timePosition) {\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpinRight - Set speed for the spin case right motor.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinRight(int timePosition) {\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 1\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnLeft(int timePosition) {\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 2\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnRight(int timePosition) {\r
+  }\r
+\r
+  /**\r
+   * setSpeedLeft - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedLeft(int timePosition) {\r
+  }\r
+\r
+  /**\r
+   * setSpeedRight - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedRight(int timePosition) {\r
+  }\r
+\r
+  public void setSpeedAgilityFactors(int speed, int agility) {\r
+//    synchronized (this) {\r
+      speedFactor = speed;\r
+      agilityFactor = agility;\r
+//    }\r
+  }\r
+\r
+  public void setUrgentReverse() {\r
+  }\r
+\r
+  public void setUrgentStraight() {\r
+  }\r
+\r
+  /**\r
+   * Control debug messageing. true - Activate debug messages false - deactivate\r
+   * debug messages\r
+   */\r
+  public void setDebug(boolean debug) {\r
+    DEBUG = debug;\r
+  }\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMManager.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMManager.java
new file mode 100644 (file)
index 0000000..09f4aeb
--- /dev/null
@@ -0,0 +1,214 @@
+/*\r
+ * PWMManager.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+/**\r
+ * PWMManager - Interface between robot strategy code and the various motors\r
+ * PWMControl classes. Agility is a number between 0 to 100 and represent the\r
+ * precentage of max speed to be applied to the turn side wheel. On left turn\r
+ * the left wheel will receive less speed as % of "speed" value represented by\r
+ * agility.\r
+ * \r
+ * @author Michael Gesundheit\r
+ * @version 1.0\r
+ */\r
+\r
+\r
+\r
+public class PWMManager {\r
+\r
+  // private int GPIO_A_OER = 0x09002000;\r
+  // private int GPIO_A_OUT = GPIO_A_OER + 4;\r
+  // private int GPIO_E_OER = 0x09002400;\r
+  // private int GPIO_E_OUT = 0x09002404;\r
+  // private byte MOTOR_PORTID_6 = 6; // Bit 2 (...3,2,1,0)\r
+  // private byte MOTOR_PORTID_7 = 7; // Bit 3 (...3,2,1,0)\r
+  \r
+  private int currentRegMask;\r
+  \r
+  private boolean DEBUG = false;\r
+  // private PWMControl pwmControl;\r
+  \r
+  private RCBridge rcb;\r
+  \r
+  private int speedFactor;\r
+  \r
+  private int agilityFactor;\r
+  \r
+  private int zeroSpeed = 45;\r
+\r
+  /**\r
+   * Constractor\r
+   */\r
+  public PWMManager(String pwmSelection) {\r
+    /*\r
+     * Instantiate PWM Makers one for each motor. motorPortId is 1 to 8 and is\r
+     * corresponding to 8 bits in a byte.\r
+     */\r
+    // if (pwmSelection.equals("rtsj"))\r
+    // pwmControl = new PWMRtsj(this, MOTOR_PORTID_6, MOTOR_PORTID_7);\r
+    // else {\r
+    // System.out.println("Selection PWMNative is activated");\r
+    // pwmControl = new PWMNative(this, MOTOR_PORTID_6, MOTOR_PORTID_7);\r
+    // System.out.println("Selection PWMNative is activated.... Return");\r
+    // }\r
+\r
+    // rcb = new RCBridge(this);\r
+    rcb = new RCBridge();\r
+\r
+    /* Enable input bits 0,1 Enable output for the rest */\r
+    // rawJEM.set(GPIO_E_OER, 0x00C0);\r
+  }\r
+\r
+  public void setManualMode() {\r
+    if (DEBUG)\r
+      System.out.println("PWMManager: setManualMode....");\r
+    // pwmControl.setManualMode();\r
+    rcb.setManualMode();\r
+  }\r
+\r
+  public void setAutomatedMode() {\r
+    if (DEBUG)\r
+      System.out.println("PWMManager: setAutomatedMode....");\r
+    // pwmControl.setAutomatedMode();\r
+    rcb.setAutomatedMode();\r
+  }\r
+\r
+  // public PWMControl getPWMControl() {\r
+  // if (DEBUG)\r
+  // System.out.println("PWMManager: getPWMControl....");\r
+  // return pwmControl;\r
+  // }\r
+\r
+  public synchronized void writeToPort(int myBit, int myValue) {\r
+    currentRegMask &= ~myBit; // e.g. 0x11110111\r
+    currentRegMask |= myValue;\r
+    /*\r
+     * // if (DEBUG){ // System.out.println("PWMM: writeToPort: myBit = 0x" +\r
+     * Integer.toHexString(myBit) + // " ~myBit = 0x" +\r
+     * Integer.toHexString(~myBit) + " myValue = 0x" + //\r
+     * Integer.toHexString(myValue) + " currentRegMask = 0x" + //\r
+     * Integer.toHexString(currentRegMask)); //}\r
+     */\r
+    // rawJEM.set(GPIO_E_OUT, currentRegMask);\r
+  }\r
+\r
+  /*\r
+   * public void stop(){ if(DEBUG) System.out.println("PWMManager: stop....");\r
+   * pwmControl.setSpeedLeft(zeroSpeed); pwmControl.setSpeedRight(zeroSpeed); }\r
+   * \r
+   * public void search(){ if(DEBUG)\r
+   * System.out.println("PWMManager: search...."); pwmControl.setSpeedLeft(70);\r
+   * pwmControl.setSpeedRight(50); }\r
+   * \r
+   * public void straight(){ if(DEBUG)\r
+   * System.out.println("PWMManager: strait...."); pwmControl.setSpeedLeft(100);\r
+   * pwmControl.setSpeedRight(100); }\r
+   * \r
+   * public void spinRight(){ if(DEBUG)\r
+   * System.out.println("PWMManager: spinRight....");\r
+   * pwmControl.setSpeedSpinLeft(100); pwmControl.setSpeedSpinRight(0); }\r
+   * \r
+   * public void spinLeft(){ if(DEBUG)\r
+   * System.out.println("PWMManager: spinLeft....");\r
+   * pwmControl.setSpeedSpinLeft(0); pwmControl.setSpeedSpinRight(100); }\r
+   * \r
+   * public void spin180(){ int mod = (rand.nextInt() % 2);\r
+   * \r
+   * if(DEBUG) System.out.println("PWMManager: spin180...."); if(mod == 1){\r
+   * pwmControl.setSpeedSpinLeft(0); pwmControl.setSpeedSpinRight(100); }else{\r
+   * pwmControl.setSpeedSpinLeft(100); pwmControl.setSpeedSpinRight(0); } }\r
+   * \r
+   * public void right(){ if(DEBUG) System.out.println("PWMManager: right....");\r
+   * pwmControl.setSpeedTurnLeft(100); pwmControl.setSpeedRight(zeroSpeed); }\r
+   * \r
+   * public void left(){ if(DEBUG) System.out.println("PWMManager: left....");\r
+   * pwmControl.setSpeedLeft(zeroSpeed); pwmControl.setSpeedTurnRight(100); }\r
+   * \r
+   * public void bearRight(){ if(DEBUG)\r
+   * System.out.println("PWMManager: bearRight....");\r
+   * pwmControl.setSpeedTurnLeft(100); pwmControl.setSpeedTurnRight(60); }\r
+   * \r
+   * public void bearLeft(){ if(DEBUG)\r
+   * System.out.println("PWMManager: bearLeft....");\r
+   * pwmControl.setSpeedTurnLeft(60); pwmControl.setSpeedTurnRight(100); }\r
+   * \r
+   * public void back(){ if(DEBUG) System.out.println("PWMManager: back....");\r
+   * pwmControl.setSpeedLeft(0); pwmControl.setSpeedRight(0); }\r
+   * \r
+   * public void backBearLeft(){ if(DEBUG)\r
+   * System.out.println("PWMManager: backBearLeft....");\r
+   * pwmControl.setSpeedLeft(30); pwmControl.setSpeedRight(0); }\r
+   * \r
+   * public void backBearRight(){ if(DEBUG)\r
+   * System.out.println("PWMManager: backBearRight....");\r
+   * pwmControl.setSpeedLeft(0); pwmControl.setSpeedRight(30); }\r
+   */\r
+  public void resume() {\r
+    if (DEBUG)\r
+      System.out.println("PWMManager: Reasume...........");\r
+  }\r
+\r
+  /**\r
+   * setSpeedFactor - set speed factor value\r
+   * \r
+   * @param speed\r
+   *          factor\r
+   */\r
+  public synchronized void setSpeedFactor(int speedFactor) {\r
+    if (DEBUG)\r
+      System.out.println("PWMManager: setSpeedFactor....");\r
+    this.speedFactor = speedFactor;\r
+    // pwmControl.setSpeedAgilityFactors(speedFactor, agilityFactor);\r
+  }\r
+\r
+  /**\r
+   * setAgilityFactor\r
+   * \r
+   * @param agility\r
+   *          factor\r
+   */\r
+  public synchronized void setAgilityFactor(int agilityFactor) {\r
+    if (DEBUG)\r
+      System.out.println("PWMManager: setAgilityFactor....");\r
+    this.agilityFactor = agilityFactor;\r
+    // pwmControl.setSpeedAgilityFactors(speedFactor, agilityFactor);\r
+  }\r
+\r
+  /**\r
+   * setSpeedAgilityFactors - set both speed and agility\r
+   * \r
+   * @param speed\r
+   * @param agility\r
+   */\r
+  public synchronized void setSpeedAgilityFactors( int speed,  int agility) {\r
+    if (DEBUG)\r
+      System.out.println("PWMManager: setSpeedAgilityFactors....");\r
+    speedFactor = speed;\r
+    agilityFactor = agility;\r
+    // pwmControl.setSpeedAgilityFactors(speedFactor, agilityFactor);\r
+  }\r
+\r
+  /**\r
+   * Control debug messaging. true - Activate debug messages false - deactivate\r
+   * debug messages\r
+   */\r
+  public void setDebug(boolean debug) {\r
+    DEBUG = debug;\r
+  }\r
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMNative.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMNative.java
new file mode 100644 (file)
index 0000000..4bc2be5
--- /dev/null
@@ -0,0 +1,377 @@
+/*\r
+ * PWMNative.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+//public class PWMNative extends PWMControl implements Runnable, InterruptEventListener  {\r
+public class PWMNative extends PWMControl {\r
+\r
+  private int PULSE_INTERVAL = 2000;\r
+  private int NATIVE_OFFSET = 100;\r
+  private Object obj;\r
+  private Object tc0Obj;\r
+  private Object tc1Obj;\r
+  private int pulseUpTime;\r
+\r
+  // private TimerCounter tc0;\r
+  // private TimerCounter tc1;\r
+  // private TimerCounter[] tcSet = new TimerCounter[2];\r
+\r
+  PWMNative(PWMManager pwmMan, int motor1bit, int motor2bit) {\r
+    super(pwmMan, motor1bit, motor2bit);\r
+\r
+    System.out.println("PWMNative constructor.....Start");\r
+    obj = new Object();\r
+    tc0Obj = new Object();\r
+    tc1Obj = new Object();\r
+\r
+    // TimerCounter.setPrescalerClockSource(TimerCounter.INTERNAL_PERIPHERAL_CLOCK);\r
+    // TimerCounter.setPrescalerReloadRegisterValue(375);\r
+    // TimerCounter.setPrescalerEnabled(true);\r
+\r
+    // tc0 = tcSet[0] = new TimerCounter(0);\r
+    // tc0.setMode_IO_Line_A(TimerCounter.TIMER_0_OUTPUT);\r
+    // // bring TIMER_0_OUTPUT_DIVIDE_BY_2 out via IO_Line_B\r
+    // tc0.setMode_IO_Line_B(TimerCounter.TIMER_0_OUTPUT_DIVIDE_BY_2);\r
+    // // In JemBuilder, go to Pin Setup 2 and allocate Port E bit 6 to\r
+    // // be Timer IO_Line_B.\r
+    //\r
+    // // Connect signal lead of servo (usually the white one) to IOE6 on\r
+    // // JStamp\r
+    // tc0.set_IO_Line_A_Polarity(TimerCounter.POLARITY_ACTIVE_STATE_HIGH);\r
+    // tc0.set_IO_Line_B_Polarity(TimerCounter.POLARITY_ACTIVE_STATE_HIGH);\r
+    // tc0.setExternalTimerEnableMode(TimerCounter.TIMER_ENABLED_ONLY_VIA_MTEN_AND_TRIGGER);\r
+    // tc0.setReloadRegisterValue(100);\r
+    // tc0.setExternalStartTriggerMode(TimerCounter.NO_EXTERNAL_START_TRIGGER);\r
+    // tc0.setMasterTimerEnabled(true);\r
+    // tc0.setGlobalInterruptEnabled(true);\r
+    // tc0.setTimeOutInterruptEnabled(true);\r
+    // tc0.setTimerTriggerRegister(false);\r
+    // System.out.println("PWMNative: Constructor completed 1....");\r
+    /*\r
+     * tc1 = tcSet[1] = new TimerCounter ( 1 ); tc1.setMode_IO_Line_A(\r
+     * TimerCounter.TIMER_1_OUTPUT ); //bring TIMER_0_OUTPUT_DIVIDE_BY_2 out via\r
+     * IO_Line_B tc1.setMode_IO_Line_B( TimerCounter.TIMER_1_OUTPUT_DIVIDE_BY_2\r
+     * ); //In JemBuilder, go to Pin Setup 2 and allocate Port E bit 6 to //be\r
+     * Timer IO_Line_B.\r
+     * tc1.set_IO_Line_A_Polarity(TimerCounter.POLARITY_ACTIVE_STATE_HIGH);\r
+     * tc1.set_IO_Line_B_Polarity(TimerCounter.POLARITY_ACTIVE_STATE_HIGH);\r
+     * tc1.setExternalTimerEnableMode\r
+     * (TimerCounter.TIMER_ENABLED_ONLY_VIA_MTEN_AND_TRIGGER );\r
+     * tc1.setReloadRegisterValue( 100 );\r
+     * tc1.setExternalStartTriggerMode(TimerCounter.NO_EXTERNAL_START_TRIGGER );\r
+     * tc1.setMasterTimerEnabled( true ); tc1.setGlobalInterruptEnabled( true);\r
+     * tc1.setTimeOutInterruptEnabled( true); tc1.setTimerTriggerRegister( false\r
+     * );\r
+     */\r
+    /*\r
+     * // Add interrupt event listener for GPTC\r
+     * InterruptController.addInterruptListener( this,\r
+     * InterruptController.GPTC_INTERRUPT );\r
+     * \r
+     * // Turn on interrupts InterruptController.enableInterrupt(\r
+     * InterruptController.GPTC_INTERRUPT );\r
+     * \r
+     * // start all prescaler based timers TimerCounter.setPrescalerEnabled(\r
+     * true );\r
+     */\r
+    // t2 = new Thread(this);\r
+    // t2.start();\r
+    // t2.setPriority(20);\r
+    System.out.println("PWMNative: Constructor return.....");\r
+  }\r
+\r
+  public void setUpTime(int upTime) {\r
+    // synchronized (obj) {\r
+    pulseUpTime = upTime;\r
+    // }\r
+  }\r
+\r
+  /*\r
+   * public void interruptEvent() { TimerCounter tc; int tcIntrState;\r
+   * \r
+   * System.out.println("PWMNative: InterruptEvent"); do { for ( int tcNum=0;\r
+   * tcNum<2; tcNum++ ) { tc = tcSet[ tcNum ];\r
+   * if(tc.readAndClear_TimeOutInterruptStatus()){ switch(tcNum){ case 0:\r
+   * System.out.println("PWMNative: Interrupt case 0"); synchronized(tc0Obj){\r
+   * System.out.println("PWMNative: Interrupt notify 0"); tc0Obj.notify(); }\r
+   * break; case 1: System.out.println("PWMNative: Interrupt case 1");\r
+   * synchronized(tc1Obj){ System.out.println("PWMNative: Interrupt notify 1");\r
+   * tc1Obj.notify(); } break; default:; } } } } while (\r
+   * TimerCounter.isGPTCInterruptPending() ); }\r
+   */\r
+  public void run() {\r
+    //\r
+    // System.out.println("PWMNative: run method........");\r
+    // int upTime0 = 150; // 1.5 milli seconds = 0 speed\r
+    // int upTime1 = 150; // 1.5 milli seconds = 0 speed\r
+    //\r
+    // while (true) {\r
+    // synchronized (obj) {\r
+    // /*\r
+    // * System.out.println("PWMNative: Updating Up Times......Left = " +\r
+    // * Integer.toString(motorLeftUpTime) + " Right = " +\r
+    // * Integer.toString(motorRightUpTime));\r
+    // */\r
+    // upTime0 = motorLeftUpTime;\r
+    // upTime1 = motorRightUpTime;\r
+    // }\r
+    //\r
+    // // Timer number 1\r
+    // tc0.setReloadRegisterValue(upTime0);\r
+    // outToPortMLeft(PULSE_HIGH);\r
+    // tc0.setTimerTriggerRegister(true);\r
+    // do {\r
+    // } while (tc0.didTimeOutInterruptOccur());\r
+    // outToPortMLeft(PULSE_LOW);\r
+    // tc0.setTimerTriggerRegister(false);\r
+    // tc0.resetTimeOutInterruptStatus();\r
+    //\r
+    // // System.out.println("PWMNative: Big loop long suspend1");\r
+    // try {\r
+    // tc0Obj.wait(18, 500000);\r
+    // } catch (Exception e) {\r
+    // }\r
+    // // System.out.println("PWMNative: Big loop long suspend2");\r
+    //\r
+    // tc0.setReloadRegisterValue(upTime1);\r
+    // outToPortMRight(PULSE_HIGH);\r
+    // tc0.setTimerTriggerRegister(true);\r
+    // do {\r
+    // } while (tc0.didTimeOutInterruptOccur());\r
+    // outToPortMRight(PULSE_LOW);\r
+    // tc0.setTimerTriggerRegister(false);\r
+    // tc0.resetTimeOutInterruptStatus();\r
+    //\r
+    // try {\r
+    // tc0Obj.wait(18, 500000);\r
+    // } catch (Exception e) {\r
+    // }\r
+\r
+    /*\r
+     * // Timer number 2 tc1.setReloadRegisterValue( upTime1 );\r
+     * tc1.setTimerTriggerRegister( true ); synchronized(tc1Obj){ try{\r
+     * System.out.println("PWMNative: Sleep 3"); tc1Obj.wait();\r
+     * System.out.println("PWMNative: Wake Up 3"); }catch(Exception e){ } }\r
+     * tc1.setTimerTriggerRegister( false ); tc1.resetTimeOutInterruptStatus();\r
+     * tc1.setReloadRegisterValue( PULSE_INTERVAL - upTime1 ); //this sets pulse\r
+     * interval tc1.setTimerTriggerRegister( true ); synchronized(tc1Obj){ try{\r
+     * System.out.println("PWMNative: Sleep 3"); tc1Obj.wait();\r
+     * System.out.println("PWMNative: Wake Up 3"); }catch(Exception e){ } }\r
+     * tc1.setTimerTriggerRegister( false ); tc1.resetTimeOutInterruptStatus();\r
+     */\r
+    // }\r
+  }\r
+\r
+  public void setManualMode() {\r
+    if (DEBUG)\r
+      System.out.println("PWMControl: setManualMode... ");\r
+    // synchronized (obj) {\r
+    if (manualMode == false) {\r
+      manualMode = true;\r
+    }\r
+    // }\r
+  }\r
+\r
+  public void setAutomatedMode() {\r
+    if (DEBUG)\r
+      System.out.println("PWMControl: setAutomatedMode... ");\r
+    /*\r
+     * synchronized(obj){ if(manualMode == true){\r
+     * System.out.println("PWMControl: wake me up... "); obj.notifyAll();\r
+     * manualMode = false; } }\r
+     */\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpin - Set speed for the spin case motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinLeft(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = timePosition + NATIVE_OFFSET;\r
+    int motorUpTime = (int) (timePos * agilityFactor * speedFactor) / 10000;\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinLeft: output-> = " + Integer.toString(motorUpTime));\r
+    }\r
+    // synchronized (obj) {\r
+    /* Factor in the speed and agility factors */\r
+    motorLeftUpTime = motorUpTime;\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpinRight - Set speed for the spin case right motor.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinRight(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* An input of 50 should result in 0 speed. */\r
+    /* 100 should result in full speed forward */\r
+    /* while 0 should result in full speed backwords */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = timePosition + NATIVE_OFFSET;\r
+    int motorUpTime = (int) ((timePos) * agilityFactor * speedFactor) / 10000;\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinRight: output-> = " + Integer.toString(motorUpTime));\r
+    }\r
+    // synchronized (obj) {\r
+    /* Factor in the speed and agility factors */\r
+    motorRightUpTime = motorUpTime;\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 1\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnLeft(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePosLocal = timePosition + NATIVE_OFFSET;\r
+    int motorUpTime =\r
+        ((timePosLocal * 100 + ((100 - timePosLocal) * (100 - agilityFactor))) * speedFactor) / 10000;\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnLeft: output-> = " + Integer.toString(motorUpTime));\r
+    }\r
+    // synchronized (obj) {\r
+    /* Factor in the speed and agility factors */\r
+    motorLeftUpTime = motorUpTime;\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 2\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnRight(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = timePosition + NATIVE_OFFSET;\r
+    int motorUpTime =\r
+        (((timePos * 100) + ((100 - timePos) * (100 - agilityFactor))) * speedFactor) / 10000;\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnRight: output-> " + Integer.toString(motorUpTime));\r
+    }\r
+    // synchronized (obj) {\r
+    /* Factor in the speed and agility factors */\r
+    motorRightUpTime = motorUpTime;\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * setSpeedLeft - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedLeft(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = timePosition + NATIVE_OFFSET;\r
+    int motorUpTime = (int) ((timePos * 100) * speedFactor) / 10000;\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedLeft: output-> " + Integer.toString(motorUpTime));\r
+    }\r
+    // synchronized (obj) {\r
+    /* Factor in speedFactor */\r
+    motorLeftUpTime = motorUpTime;\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * setSpeedRight - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedRight(int timePosition) {\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    int timePos = timePosition + NATIVE_OFFSET;\r
+    int motorUpTime = (int) (((timePos * 100) * speedFactor) / 10000);\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedRight: output-> " + Integer.toString(motorUpTime));\r
+    }\r
+    // synchronized (obj) {\r
+    /* Factor in speedFactor */\r
+    motorRightUpTime = motorUpTime;\r
+    // }\r
+  }\r
+\r
+  public void setSpeedAgilityFactors(int speed, int agility) {\r
+    // synchronized (obj) {\r
+    speedFactor = speed;\r
+    agilityFactor = agility;\r
+    // }\r
+  }\r
+\r
+  public void setUrgentReverse() {\r
+    // synchronized (obj) {\r
+    motorLeftUpTime = 1;\r
+    motorRightUpTime = 1;\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * Control debug messageing. true - Activate debug messages false - deactivate\r
+   * debug messages\r
+   */\r
+  public void setDebug(boolean debug) {\r
+    DEBUG = debug;\r
+  }\r
+\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMRtsj.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/PWMRtsj.java
new file mode 100644 (file)
index 0000000..1bb4190
--- /dev/null
@@ -0,0 +1,322 @@
+/*\r
+ * PWMRtsj.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+/**\r
+ * This class is motor controller specific. In our case the motor controller\r
+ * require for 0 speed 1.5 ms out of 10-20ms cycle and a change between 1 to 2\r
+ * seconds for max reverse and forward speed. These values: 1, 1.5, 2 and 20 ms\r
+ * are thus this class specific\r
+ * \r
+ * @author Michael Gesundheit\r
+ * @version 1.0\r
+ */\r
+\r
+public class PWMRtsj extends PWMControl {\r
+\r
+  // RelativeTime zeroSpeedDuration;\r
+  // RelativeTime timeUpDuration;\r
+  // RelativeTime timeDownDuration;\r
+  // RelativeTime cycleTime;\r
+  boolean updateTime;\r
+  int sleepUpDurationNano = 500000;\r
+  long sleepUpDurationMilli = 1;\r
+  int sleepDownDurationNano = 500000;\r
+  long sleepDownDurationMilli = 18;\r
+  int pulseWidth;\r
+  // Object obj;\r
+\r
+  private static final int GPIO_A_OER = 0x09002000;\r
+  private static final int GPIO_A_OUT = GPIO_A_OER + 4;\r
+  private static final int GPIO_A_IN = GPIO_A_OER + 8;\r
+\r
+  /**\r
+   * Constructor - Start a standard Java thread. The thread is suspended and\r
+   * will wake up evey 18 ms. It will issue a 1-2ms pulse and suspends itself\r
+   * again to 18ms. This is to have a total of 20ms or less yet it's the maxim\r
+   * possible cycle so as to load the cpu as little as possible.\r
+   */\r
+  public PWMRtsj(PWMManager pwmMan, int motor1bit, int motor2bit) {\r
+\r
+    super(pwmMan, motor1bit, motor2bit); // This is papa\r
+\r
+    motorLeftUpTime = 450000; // Nano seconds\r
+    motorRightUpTime = 450000; // Nano seconds\r
+\r
+    if (DEBUG) {\r
+      System.out.println("PWMRtsj: About to start RoboThread...");\r
+    }\r
+\r
+    // t2 = new RoboThread();\r
+    // t2.start();\r
+    // t2.setPriority(10);\r
+  }\r
+\r
+  // A poor's man ajustimg for the 0 speed which found\r
+  // to be 450000 nano seconds.\r
+  private int normalizeTime(int timePosition) {\r
+    if ((timePosition <= 50) && (timePosition >= 44)) {\r
+      return 45;\r
+    }\r
+    return timePosition;\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpin - Set speed for the spin case motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinLeft(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = normalizeTime(timePosition);\r
+\r
+    int motorUpTime = (int) (timePos * agilityFactor * speedFactor);\r
+    // System.out.println("Left Motor UpTime1: " +\r
+    // Integer.toString(motorUpTime));\r
+    // Since the right motor is hanging in reverse position\r
+    // the direction should be opposit\r
+    // Bug in wait. Can't take 0 nanoseconds\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinLeft: output-> = " + Integer.toString(motorUpTime));\r
+    }\r
+//    synchronized (this) {\r
+      /* Factor in the speed and agility factors */\r
+      motorLeftUpTime = motorUpTime;\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedSpinRight - Set speed for the spin case right motor.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedSpinRight(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* An input of 50 should result in 0 speed. */\r
+    /* 100 should result in full speed forward */\r
+    /* while 0 should result in full speed backwords */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = normalizeTime(timePosition);\r
+\r
+    int motorUpTime = (int) ((timePos) * agilityFactor * speedFactor);\r
+    // Bug in wait. Cant take 0 nanoseconds\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedSpinRight: output-> = " + Integer.toString(motorUpTime));\r
+    }\r
+//    synchronized (this) {\r
+      /* Factor in the speed and agility factors */\r
+      motorRightUpTime = motorUpTime;\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 1\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnLeft(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePosLocal = normalizeTime(timePosition);\r
+    int motorUpTime =\r
+        (timePosLocal * 100 + ((100 - timePosLocal) * (100 - agilityFactor))) * speedFactor;\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnLeft: output-> = " + Integer.toString(motorUpTime));\r
+    }\r
+//    synchronized (this) {\r
+      /* Factor in the speed and agility factors */\r
+      motorLeftUpTime = motorUpTime;\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedTurnM1 - set speed considering agility factor for motor 2\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedTurnRight(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = normalizeTime(timePosition);\r
+    int motorUpTime = ((timePos * 100) + ((100 - timePos) * (100 - agilityFactor))) * speedFactor;\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedTurnRight: output-> " + Integer.toString(motorUpTime));\r
+    }\r
+//    synchronized (this) {\r
+      /* Factor in the speed and agility factors */\r
+      motorRightUpTime = motorUpTime;\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedLeft - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedLeft(int timePosition) {\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    /* 100-input to get reverse polarity for this motor */\r
+    /* since it's mounted in reverse direction to the other motor */\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedLeft: input-> " + Integer.toString(timePosition));\r
+    }\r
+    int timePos = normalizeTime(timePosition);\r
+    int motorUpTime = (int) (timePos * 100) * speedFactor;\r
+    /*\r
+     * System.out.println("motorUpTime = " + Integer.toString(motorUpTime) +\r
+     * " timePos = " + Integer.toString((int)timePos) + " timePosition = " +\r
+     * Integer.toString((int)timePosition) + " speedFactor = " +\r
+     * Integer.toString(speedFactor));\r
+     */\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedLeft: output-> " + Integer.toString(motorUpTime));\r
+    }\r
+//    synchronized (this) {\r
+      /* Factor in speedFactor */\r
+      motorLeftUpTime = motorUpTime;\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * setSpeedRight - speed control for motor 1.\r
+   * \r
+   * @param uptime\r
+   *          pulse width (time position)\r
+   */\r
+  public void setSpeedRight(int timePosition) {\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedRight: input-> " + Integer.toString(timePosition));\r
+    }\r
+    /* Speed comes in as a number between 0 - 100 */\r
+    /* It represents values between 1 to 2 ms */\r
+    int timePos = normalizeTime(timePosition);\r
+    int motorUpTime = (int) (timePos * 100) * speedFactor;\r
+    if (motorUpTime == 0) {\r
+      motorUpTime = 1;\r
+      // System.out.println("returning....");\r
+      // return; // ndr\r
+    } else if (motorUpTime == 1000000) {\r
+      motorUpTime--;\r
+    }\r
+    if (DEBUG) {\r
+      System.out.println("setSpeedRight: output-> " + Integer.toString(motorUpTime));\r
+    }\r
+//    synchronized (this) {\r
+      /* Factor in speedFactor */\r
+      motorRightUpTime = motorUpTime;\r
+//    }\r
+  }\r
+\r
+  public void setSpeedAgilityFactors(int speed, int agility) {\r
+//    synchronized (this) {\r
+      speedFactor = speed;\r
+      agilityFactor = agility;\r
+//    }\r
+  }\r
+\r
+  public void setUrgentReverse() {\r
+//    synchronized (this) {\r
+      motorLeftUpTime = 1;\r
+      motorRightUpTime = 1;\r
+//    }\r
+  }\r
+\r
+  public void setUrgentStraight() {\r
+//    synchronized (this) {\r
+      motorLeftUpTime = 99;\r
+      motorRightUpTime = 99;\r
+//    }\r
+  }\r
+\r
+  public void justSync() {\r
+//    synchronized (this) {\r
+      motorLeftUpTime = motorLeftUpTime;\r
+      motorRightUpTime = motorRightUpTime;\r
+//    }\r
+  }\r
+\r
+  /**\r
+   * Control debug messageing. true - Activate debug messages false - deactivate\r
+   * debug messages\r
+   */\r
+  public void setDebug(boolean debug) {\r
+    DEBUG = debug;\r
+  }\r
+\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/RCBridge.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/RCBridge.java
new file mode 100644 (file)
index 0000000..28dfcfc
--- /dev/null
@@ -0,0 +1,41 @@
+/*
+ * PWMControl.java
+ *
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * This software is the confidential and proprietary information of Sun
+ * Microsystems, Inc. ("Confidential Information").  You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with Sun.
+ *
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
+ */
+
+/**
+ * Manage the software link between two IO port lines.
+ * <p>
+ * Copyright: Copyright (c) 2002
+ * </p>
+ * 
+ * @author Michael Gesundheit
+ * @version 1.0
+ */
+
+public class RCBridge {
+
+  public void setManualMode() {
+    // rcLleft.activate();
+    // rcLright.activate();
+  }
+
+  public void setAutomatedMode() {
+    // rcLleft.deActivate();
+    // rcLright.deActivate();
+  }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/RobotMain.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/RobotMain.java
new file mode 100644 (file)
index 0000000..a3d582a
--- /dev/null
@@ -0,0 +1,310 @@
+/*\r
+ * RobotMain.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+/**\r
+ * Robot's Main class - instantiates all required classes and resources.\r
+ * \r
+ * @author Michael Gesundheit\r
+ * @version 1.0\r
+ */\r
+\r
+\r
+public class RobotMain {\r
+\r
+  \r
+  private static boolean DEBUG1 = true;\r
+  \r
+  private static boolean DEBUG = true;\r
+\r
+  private static final int OFF_MODE = 1;\r
+  private static final int ON_MODE = 2;\r
+  private static final int MANUAL_MODE = 1;\r
+  private static final int AUTONOMUS_MODE = 2;\r
+  private static final int ON_OFF = 128;// 0x80\r
+  private static final int MANUAL_AUTONOMUS = 32; // 0x20\r
+  public static final int LINE_SENSORS = 64; // 0x40\r
+  private static final int SONAR_SENSORS = 96; // 0x60\r
+  public static final int ALL_COMMANDS = 0xe0;\r
+\r
+  public static final byte LF_FRONT = 0x1;\r
+  public static final byte RT_FRONT = 0x2;\r
+  public static final byte RT_SIDE = 0x4;\r
+  public static final byte BK_SIDE = 0x8;\r
+  public static final byte LF_SIDE = 0x10;\r
+  public static final byte ALL_SONARS = 0x1f;\r
+  public static final byte LF_RT_FRONT = 0x3; // LF_FRONT | RT_FRONT;\r
+  public static final byte LS_LEFT = 0x1;\r
+  public static final byte LS_RIGHT = 0x2;\r
+  public static final byte LS_REAR = 0x4;\r
+  public static final byte LS_LEFT_RIGHT = 0x3;\r
+  public static final byte LS_LEFT_REAR = 0x5;\r
+  public static final byte LS_RIGHT_REAR = 0x6;\r
+  public static final byte LS_ALL = 0x7;\r
+  private static final int ALL_DATA = 0x1f;\r
+\r
+  \r
+  private static PWMManager pwmm;\r
+  \r
+  private static StrategyMgr strategyMgr;\r
+\r
+  \r
+  private static int onOffMode = ON_MODE;\r
+  \r
+  private static int manualAutonomusMode = AUTONOMUS_MODE;\r
+  \r
+  private static byte lineSensorsMask;\r
+  \r
+  private static byte sonarSensors;\r
+  \r
+  private static byte currentCommand;\r
+  \r
+  private static byte privSonars;\r
+  \r
+  private static byte privLineSensors;\r
+  \r
+  private static byte currentSonars;\r
+  \r
+  public static String pwmSelection;\r
+\r
+  /**\r
+   * Constructor for the class for the robot main thread.\r
+   */\r
+  RobotMain() {\r
+  }\r
+\r
+  /**\r
+   * Processes sonar sensor input. This method is called each time new sonar\r
+   * sensor data arrives, and each time that a mode switch occurs between ON/OFF\r
+   * and Manual Override.\r
+   */\r
+  static void processSonars() {\r
+    strategyMgr.processSonars(sonarSensors);\r
+  }\r
+\r
+  /**\r
+   * Processes line sensor input. This method is called each time new line\r
+   * sensor data arrives, and each time that a mode switch occurs between ON/OFF\r
+   * and Manual Override.\r
+   */\r
+  static void processLineSensors() {\r
+    strategyMgr.processLineSensors(lineSensorsMask);\r
+    resume();\r
+  }\r
+\r
+  /**\r
+   * Resumes motors as per the last sonar command.\r
+   */\r
+  public static void resume() {\r
+    processSonars();\r
+  }\r
+\r
+  /**\r
+   * Extracts sonar sensor data from the adjunct sensor controller and from line\r
+   * sensor data from the JStamp line sensor pins.\r
+   */\r
+  \r
+  private static void processIOCommand() {\r
+\r
+    // int data = 0;\r
+    // int opCode = 0;\r
+    // synchronized (obj1) {\r
+     int data = (int) (currentCommand & ALL_DATA);\r
+     int opCode = (int) (currentCommand & 0xe0); // ALL_COMMANDS);\r
+    // }\r
+\r
+    if (DEBUG) {\r
+      System.out.println("processIOCommand: Default: opCode = " + Integer.toString((int) opCode)\r
+          + " data = " + Integer.toString((int) data));\r
+    }\r
+    switch ((int) opCode) {\r
+    case ON_OFF:\r
+      if (DEBUG) {\r
+        System.out.println("processIO: ON_OFF....");\r
+      }\r
+      if ((data & 0x1) == 0x1) {\r
+        System.out.println("processIO: ON MODE........");\r
+        onOffMode = ON_MODE;\r
+        processLineSensors();\r
+        processSonars();\r
+      } else {\r
+        System.out.println("processIO: OFF MODE.......");\r
+        onOffMode = OFF_MODE;\r
+        strategyMgr.stop();\r
+      }\r
+      break;\r
+    case MANUAL_AUTONOMUS:\r
+      if (DEBUG) {\r
+        System.out.println("processIO: Setting manual_autonomus mode");\r
+      }\r
+      if ((data & 0x1) == 0x1) {\r
+        manualAutonomusMode = MANUAL_MODE;\r
+        pwmm.setManualMode();\r
+      } else {\r
+        manualAutonomusMode = AUTONOMUS_MODE;\r
+        pwmm.setAutomatedMode();\r
+        processLineSensors();\r
+        processSonars();\r
+      }\r
+      break;\r
+    case LINE_SENSORS:\r
+      if (DEBUG) {\r
+        // System.out.println("processIO: Line Sensors.................."\r
+        // + Integer.toBinaryString((int) (data & LS_ALL)));\r
+      }\r
+      lineSensorsMask = (byte) (data & LS_ALL);\r
+\r
+      /*\r
+       * Line sensors with '0' data means the robot moved off the edge line, and\r
+       * there is nothing to do.\r
+       */\r
+      if (((data & LS_ALL) == 0) || ((data & LS_ALL) == privLineSensors)) {\r
+        privLineSensors = (byte) (data & LS_ALL);\r
+        return;\r
+      }\r
+      if ((onOffMode == ON_MODE) && (manualAutonomusMode == AUTONOMUS_MODE)) {\r
+        if (DEBUG)\r
+          System.out.println("processIO: Line Sensors..Process...!!!");\r
+        processLineSensors();\r
+      }\r
+      break;\r
+    case SONAR_SENSORS:\r
+      if (DEBUG) {\r
+        // System.out.println("processIO: SONAR_SENORS: bits = ......"\r
+        // + Integer.toBinaryString((int) (currentCommand & ALL_SONARS)));\r
+      }\r
+      currentSonars = (byte) (data & ALL_SONARS);\r
+      /*\r
+       * No need to synchronized on this variable assignment since all referring\r
+       * code is on the same logical thread\r
+       */\r
+      sonarSensors = (byte) currentSonars;\r
+      if ((onOffMode == ON_MODE) && (manualAutonomusMode == AUTONOMUS_MODE)) {\r
+        processSonars();\r
+      }\r
+      break;\r
+    default:\r
+      strategyMgr.stop();\r
+      System.out.println("processIOCommand: Default: opCode = " + Integer.toString((int) opCode)\r
+          + " data = " + Integer.toString((int) data));\r
+    }\r
+  }\r
+\r
+  /**\r
+   * Sets the simulation mode on in the IOManager.\r
+   */\r
+  // static public void setSimulation() {\r
+  // sm.setSimulation();\r
+  // }\r
+\r
+  /**\r
+   * Resets the simulation mode in the IOManager.\r
+   */\r
+  // static public void resetSimulation() {\r
+  // sm.resetSimulation();\r
+  // }\r
+\r
+  /**\r
+   * Saves the current IOManager command byte locally.\r
+   */\r
+  static public void setIOManagerCommand(byte[] cmd) {\r
+    // synchronized (obj1) {\r
+    currentCommand = cmd[0];\r
+    // }\r
+    // synchronized (obj) {\r
+    try {\r
+      // obj.notify();\r
+    } catch (IllegalMonitorStateException ie) {\r
+      System.out.println("IllegalMonitorStateException caught trying to notify");\r
+    }\r
+    // }\r
+  }\r
+\r
+  /**\r
+   * Sets debug messaging state: true - Activate debug messages false -\r
+   * deactivate debug messages\r
+   */\r
+  static public void setDebug(boolean debug) {\r
+    DEBUG = debug;\r
+  }\r
+\r
+  /**\r
+   * Runs the robot's main thread.\r
+   */\r
+  \r
+  public static void main( String args[]) {\r
+\r
+    TestSensorInput.init();\r
+     boolean active = true;\r
+    /**\r
+     * RealTime management of the robot behaviour based on sensors and commands\r
+     * input.\r
+     */\r
+\r
+    /**\r
+     * Set the low level PWM interface type, e.g. "rtsj" or "native" (ajile\r
+     * library-based).\r
+     */\r
+    pwmSelection = "rtsj";\r
+\r
+    System.out.println("PWM Selction is: " + pwmSelection);\r
+\r
+    pwmm = new PWMManager(pwmSelection);\r
+\r
+    // Pass in the PWMManager for callbacks.\r
+    // sm = new IOManager(pwmm);\r
+    // ram = new RemoteApplicationManager(pwmm);\r
+     MotorControl mc = new MotorControl(100, 100);\r
+    strategyMgr = new StrategyMgr(mc);\r
+\r
+    /*\r
+     * Sets initial values for the speed and agility parameters. Speed and\r
+     * agility are arbitrary scale factors for the overall speed and speed of\r
+     * turns, respectively. These work with PWM via the native ajile libraries,\r
+     * but do not work well with the RTSJ implementation due to limits on the\r
+     * granularity of timing for the PWM pulse (quantization).\r
+     */\r
+    pwmm.setSpeedAgilityFactors(100, 100);\r
+\r
+    /*\r
+     * Robot's initial state is "ON" by default. Set this parameter to "OFF" if\r
+     * the robot is to be started over the TCP/IP link.\r
+     */\r
+    // issueCommand("OFF");\r
+\r
+    SSJAVA: while (active) {\r
+\r
+      // if (DEBUG) {\r
+      // System.out.println("Main: Waiting for remote commands");\r
+      // }\r
+      // try {\r
+      // obj.wait();\r
+      // } catch (IllegalMonitorStateException ie) {\r
+      // System.out.println("IllegalMonitorStateException caught in main loop");\r
+      // }\r
+      currentCommand = TestSensorInput.getCommand();\r
+      if (currentCommand == -1) {\r
+        break;\r
+      }\r
+      System.out.println("currentCommand=" + currentCommand);\r
+      processIOCommand();\r
+    }\r
+    System.exit(0);\r
+  }\r
+\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/StrategyMgr.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/StrategyMgr.java
new file mode 100644 (file)
index 0000000..c46b5fd
--- /dev/null
@@ -0,0 +1,270 @@
+/*\r
+ * StragegyMgr.java\r
+ *\r
+ * Copyright (c) 1993-2002 Sun Microsystems, Inc. All Rights Reserved.\r
+ *\r
+ * This software is the confidential and proprietary information of Sun\r
+ * Microsystems, Inc. ("Confidential Information").  You shall not\r
+ * disclose such Confidential Information and shall use it only in\r
+ * accordance with the terms of the license agreement you entered into\r
+ * with Sun.\r
+ *\r
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF\r
+ * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR\r
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR\r
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.\r
+ */\r
+\r
+/**\r
+ * StrategyMgr - an isolation class ment for programmers to modify and create\r
+ * thier own code for robot strategy.\r
+ * \r
+ * @author Michael Gesundheit\r
+ * @version 1.0\r
+ */\r
+\r
+\r
+public class StrategyMgr {\r
+\r
+  \r
+  private MotorControl mc;\r
+  private static final int zeroSpeed = 45;\r
+  \r
+  private Random rand;\r
+  \r
+  private boolean DEBUGL = true;\r
+  // private boolean DEBUGL = false;\r
+\r
+  // private boolean DEBUG = true;\r
+  \r
+  private boolean DEBUG = true;\r
+\r
+  /**\r
+   * Constructor - Invoke communication to remote application thread\r
+   */\r
+  public StrategyMgr(@DELEGATE MotorControl motorControl) {\r
+    mc = motorControl;\r
+    rand = new Random();\r
+  }\r
+\r
+  void processSonars( byte sonarSensors) {\r
+\r
+    // 5 sensors. 1,2 are fromnt left and right.\r
+    // Sensor 3 is right side, 4 back and 5 is left side.\r
+    if ((sonarSensors & 0x1f) == 0) {\r
+      // No sensor data may mean dead area between sensors.\r
+      // Continue with the last gesture until any sensor\r
+      // provide data.\r
+      if (DEBUG) {\r
+        System.out.println("sonar: NO SONARS!!!!!!!!");\r
+      }\r
+    } else if ((sonarSensors & (RobotMain.LF_RT_FRONT)) == (RobotMain.LF_RT_FRONT)) {\r
+      if (DEBUG) {\r
+        System.out.println("sonar: straight");\r
+      }\r
+      straight();\r
+    } else if ((sonarSensors & RobotMain.LF_FRONT) == RobotMain.LF_FRONT) {\r
+      if (DEBUG) {\r
+        System.out.println("sonar: bearLeft");\r
+      }\r
+      bearLeft();\r
+    } else if ((sonarSensors & RobotMain.RT_FRONT) == RobotMain.RT_FRONT) {\r
+      if (DEBUG) {\r
+        System.out.println("sonar: bearRight");\r
+      }\r
+      bearRight();\r
+    } else if ((sonarSensors & RobotMain.RT_SIDE) == RobotMain.RT_SIDE) {\r
+      if (DEBUG) {\r
+        System.out.println("sonar: right");\r
+      }\r
+      spinRight();\r
+    } else if ((sonarSensors & RobotMain.LF_SIDE) == RobotMain.LF_SIDE) {\r
+      if (DEBUG) {\r
+        System.out.println("sonar: left");\r
+      }\r
+      spinLeft();\r
+    } else if ((sonarSensors & RobotMain.BK_SIDE) == RobotMain.BK_SIDE) {\r
+      if (DEBUG) {\r
+        System.out.println("sonar: spin180");\r
+      }\r
+      spin180();\r
+    }\r
+  }\r
+\r
+  void processLineSensors( byte lineSensorsMask) {\r
+\r
+     int count = 0;\r
+\r
+    while ((lineSensorsMask & RobotMain.LS_ALL) != 0) {\r
+\r
+      if (count > 100) {\r
+        // if the robot fail to get out of weird condition wihtin 100 steps,\r
+        // terminate while loop for stabilizing behavior.\r
+        stop();\r
+        break;\r
+      }\r
+      count++;\r
+\r
+      if ((lineSensorsMask & RobotMain.LS_ALL) == RobotMain.LS_ALL) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - ALL");\r
+        stop();\r
+      } else if ((lineSensorsMask & RobotMain.LS_LEFT_RIGHT) == RobotMain.LS_LEFT_RIGHT) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - Left & Right");\r
+        back();\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+        spin180();\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+      } else if ((lineSensorsMask & RobotMain.LS_LEFT_REAR) == RobotMain.LS_LEFT_REAR) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - Left & Rear");\r
+        bearRight();\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+      } else if ((lineSensorsMask & RobotMain.LS_RIGHT_REAR) == RobotMain.LS_RIGHT_REAR) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - Right & Rear");\r
+        bearLeft();\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+      } else if ((lineSensorsMask & RobotMain.LS_LEFT) == RobotMain.LS_LEFT) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - Left");\r
+        backBearRight();\r
+\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+      } else if ((lineSensorsMask & RobotMain.LS_RIGHT) == RobotMain.LS_RIGHT) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - Right");\r
+        backBearLeft();\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+      } else if ((lineSensorsMask & RobotMain.LS_REAR) == RobotMain.LS_REAR) {\r
+        if (DEBUGL)\r
+          System.out.println("Line Sensors - Rear");\r
+        straight();\r
+        try {\r
+          // Thread.sleep(1000);\r
+        } catch (InterruptedException ie) {\r
+        }\r
+      }\r
+      lineSensorsMask = TestSensorInput.getCommand();\r
+    }// while loop\r
+  }\r
+\r
+  public void stop() {\r
+    if (DEBUG)\r
+      System.out.println("StrageyMgr: stop....");\r
+    mc.setSpeedLeft(zeroSpeed);\r
+    mc.setSpeedRight(zeroSpeed);\r
+  }\r
+\r
+  public void search() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: search....");\r
+    mc.setSpeedLeft(70);\r
+    mc.setSpeedRight(50);\r
+  }\r
+\r
+  public void straight() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: strait....");\r
+    mc.setSpeedLeft(100);\r
+    mc.setSpeedRight(100);\r
+  }\r
+\r
+  public void spinRight() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: spinRight....");\r
+    mc.setSpeedSpinLeft(100);\r
+    mc.setSpeedSpinRight(0);\r
+  }\r
+\r
+  public void spinLeft() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: spinLeft....");\r
+    mc.setSpeedSpinLeft(0);\r
+    mc.setSpeedSpinRight(100);\r
+  }\r
+\r
+  public void spin180() {\r
+     int mod = (rand.nextInt() % 2);\r
+\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: spin180....");\r
+    if (mod == 1) {\r
+      mc.setSpeedSpinLeft(0);\r
+      mc.setSpeedSpinRight(100);\r
+    } else {\r
+      mc.setSpeedSpinLeft(100);\r
+      mc.setSpeedSpinRight(0);\r
+    }\r
+  }\r
+\r
+  public void right() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: right....");\r
+    mc.setSpeedTurnLeft(100);\r
+    mc.setSpeedRight(zeroSpeed);\r
+  }\r
+\r
+  public void left() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: left....");\r
+    mc.setSpeedLeft(zeroSpeed);\r
+    mc.setSpeedTurnRight(100);\r
+  }\r
+\r
+  public void bearRight() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: bearRight....");\r
+    mc.setSpeedTurnLeft(100);\r
+    mc.setSpeedTurnRight(60);\r
+  }\r
+\r
+  public void bearLeft() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: bearLeft....");\r
+    mc.setSpeedTurnLeft(60);\r
+    mc.setSpeedTurnRight(100);\r
+  }\r
+\r
+  public void back() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: back....");\r
+    mc.setSpeedLeft(0);\r
+    mc.setSpeedRight(0);\r
+  }\r
+\r
+  public void backBearLeft() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: backBearLeft....");\r
+    mc.setSpeedLeft(30);\r
+    mc.setSpeedRight(0);\r
+  }\r
+\r
+  public void backBearRight() {\r
+    if (DEBUG)\r
+      System.out.println("StrategyMgr: backBearRight....");\r
+    mc.setSpeedLeft(0);\r
+    mc.setSpeedRight(30);\r
+  }\r
+}\r
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/TestSensorInput.java b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/TestSensorInput.java
new file mode 100644 (file)
index 0000000..a6b3d37
--- /dev/null
@@ -0,0 +1,26 @@
+public class TestSensorInput {
+
+  private static FileInputStream inputFile;
+  private static int idx=0;
+
+  @TRUST
+  public static void init() {
+    inputFile = new FileInputStream("input.dat");
+  }
+
+  @TRUST
+  public static byte getCommand() {
+    String in = inputFile.readLine();
+    if (in == null) {
+       return (byte) -1;
+    }
+    // DEBUG_OUTPUT();
+    return (byte) Integer.parseInt(in);
+  }
+  
+  public static DEBUG_OUTPUT(){
+    idx++;
+    System.out.println(idx);
+  }
+
+}
diff --git a/Robust/src/Benchmarks/SSJava/JavaNatorInfer/makefile b/Robust/src/Benchmarks/SSJava/JavaNatorInfer/makefile
new file mode 100644 (file)
index 0000000..99d8177
--- /dev/null
@@ -0,0 +1,52 @@
+BUILDSCRIPT=../../../buildscript
+
+PROGRAM=RobotMain
+SOURCE_FILES=RobotMain.java
+
+ifndef INV_ERROR_PROB
+INV_ERROR_PROB=1000
+endif
+
+ifndef RANDOMSEED
+RANDOMSEED=12345
+endif
+
+SSJAVA= -ssjava -ssjavainfer -ssjavadebug
+BSFLAGS= -32bit -mainclass $(PROGRAM)  -heapsize-mb 1350  -nooptimize -debug -garbagestats #-printlinenum #-joptimize
+NORMAL= -ssjava-inject-error 0 0
+INJECT_ERROR= -ssjava-inject-error $(INV_ERROR_PROB) $(RANDOMSEED)
+
+
+default: $(PROGRAM)s.bin
+
+normal: $(PROGRAM)n.bin
+
+error: $(PROGRAM)e.bin
+
+
+$(PROGRAM)s.bin: $(SOURCE_FILES) makefile
+       $(BUILDSCRIPT) $(SSJAVA) $(BSFLAGS) -o $(PROGRAM)s -builddir ssj $(SOURCE_FILES) 
+
+$(PROGRAM)n.bin: $(SOURCE_FILES) makefile
+       $(BUILDSCRIPT) $(NORMAL) $(BSFLAGS) -o $(PROGRAM)n -builddir norm $(SOURCE_FILES) 
+
+$(PROGRAM)e.bin: $(SOURCE_FILES) makefile
+       $(BUILDSCRIPT) $(SSJAVA) $(INJECT_ERROR) $(BSFLAGS) -o $(PROGRAM)e -builddir injerr $(SOURCE_FILES) 
+
+cleanerror:
+       rm -f $(PROGRAM)e.bin
+       rm -rf injerr
+
+clean:
+       rm -f  $(PROGRAM)s.bin $(PROGRAM)n.bin $(PROGRAM)e.bin
+       rm -fr ssj norm injerr
+       rm -f nve-diff.tmp nve-diff-ranges.tmp
+       rm -f  *~
+       rm -f  *.dot
+       rm -f  *.png
+       rm -f  *.pdf
+       rm -f  aliases.txt
+       rm -f  results*txt
+       rm -f  output.txt
+       rm -f *log
+