Updated Java Sample TensorFlow Object Detection Op Mode (markdown)

Java-Sample-TensorFlow-Object-Detection-Op-Mode.md

@@ -13,6 +13,81 @@ Your new op mode should appear in the editing pane of the OnBot Java screen.
 <p align="center">[[/images/Blocks-Sample-TensorFlow-Object-Detection-Op-Mode/onbotMyExample.png]]<br/>Your newly created op mode should be available for editing through OnBot Java.<p> 
 
 ### Initializing the System
+Let's take a look at the initial statements in the op mode.  Before you start, you must first make sure you have a valid Vuforia developer license key to initialize the Vuforia software.  You can obtain a key for free from [https://developer.vuforia.com/license-manager](https://developer.vuforia.com/license-manager).  Once you obtain your key, replace the VUFORIA_KEY static String with the actual license key so the Vuforia software will be able to initialize properly.
+
+```
+    private static final String VUFORIA_KEY =
+            " -- YOUR NEW VUFORIA KEY GOES HERE  --- ";
+```
+Also, by default the op mode is disabled.  Comment out the "@Disabled" annotation to enable your newly created op mode.
+
+```
+@TeleOp(name = "Concept: TensorFlow Object Detection", group = "Concept")
+//@Disabled
+public class MyTensorFlowExample extends LinearOpMode {
+```
+
+Since TensorFlow will receive image data from Vuforia, the op mode attempts to create and initialize a VuforiaLocalizer object by calling the function called "initVuforia()":
+
+```
+        // The TFObjectDetector uses the camera frames from the VuforiaLocalizer, so we create that
+        // first.
+        initVuforia();
+```
+
+You can initialize both the Vuforia and the TensorFlow libraries in the same op mode.  This is useful, for example, if you would like to use the TensorFlow library to determine the ring stack and then use the Vuforia library to help  the robot autonomously navigate on the game field to navigate to the appropriate target zone from its starting position.
+
+In this example op mode, however, the initVuforia() function does not load any trackable image targets.
+
+```
+    /**
+     * Initialize the Vuforia localization engine.
+     */
+    private void initVuforia() {
+        /*
+         * Configure Vuforia by creating a Parameter object, and passing it to the Vuforia engine.
+         */
+        VuforiaLocalizer.Parameters parameters = new VuforiaLocalizer.Parameters();
+
+        parameters.vuforiaLicenseKey = VUFORIA_KEY;
+        parameters.cameraDirection = CameraDirection.BACK;
+
+        //  Instantiate the Vuforia engine
+        vuforia = ClassFactory.getInstance().createVuforia(parameters);
+
+        // Loading trackables is not necessary for the TensorFlow Object Detection engine.
+    }
+```
+
+After the Vuforia localizer is initialized, the op mode calls a method initTfod().  This method initializes the TensorFlow Object Detection engine.
+```
+    /**
+     * Initialize the TensorFlow Object Detection engine.
+     */
+    private void initTfod() {
+        int tfodMonitorViewId = hardwareMap.appContext.getResources().getIdentifier(
+            "tfodMonitorViewId", "id", hardwareMap.appContext.getPackageName());
+        TFObjectDetector.Parameters tfodParameters = new TFObjectDetector.Parameters(tfodMonitorViewId);
+        tfodParameters.minResultConfidence = 0.8f;
+        tfod = ClassFactory.getInstance().createTFObjectDetector(tfodParameters, vuforia);
+        tfod.loadModelFromAsset(TFOD_MODEL_ASSET, LABEL_FIRST_ELEMENT, LABEL_SECOND_ELEMENT);
+    }
+```
+Note that by default, when you create a new TensorFlow object detector, an object tracker is used, in addition to the TensorFlow interpreter, to keep track of the locations of detected objects. The object tracker interpolates object recognitions so that results are smoother than they would be if the system were to solely rely on the TensorFlow interpreter.
+
+If you want to turn off the object tracker, then you can set the useObjectTracker variable of the tfodParameters object to false before you create the TensorFlow object detector.
+
+```
+        // set useObjectTracker to false to disable object tracker.
+        tfodParameters.useObjectTracker = false;
+```
+
+Also note that the by default, the minimum detection confidence level is set to 80%. This means that the TensorFlow library needs to have a confidence level of 80% or higher in order to consider an object as being detected in its field of view. You can adjust this parameter to a higher value if you would like the system to be more selective in identifying an object.
+
+```
+        tfodParameters.minResultConfidence = 0.8f;
+```
+
 Let's take a look at the initial blocks in the op mode.  The first block in the op mode (excluding the comment blocks) initializes the Vuforia library on the Android Robot Controller.  This is needed because the TensorFlow Lite library will receive image data from the Vuforia library. Also, in the screenshot below, the Vuforia system will use an externally connected webcam named "Webcam 1" (which should match the camera name in your robot's configuration file).
 
 <p align="center">[[/images/Blocks-Sample-TensorFlow-Object-Detection-Op-Mode/blocksInit.png]]<br/>Initialize the Vuforia and TensorFlow libraries.<p>