updated dashboard

Author: dusty-nv

Diff for: python/www/dash/app.py

@@ -37,8 +37,6 @@
 
 from layout import create_grid, create_navbar, create_stream_dialog, create_model_dialog
 
-#import os
-#print(f'loaded {__file__} module from {__name__} (pid {os.getpid()})')
 
 # create the dash app
 external_scripts = ['https://webrtc.github.io/adapter/adapter-latest.js']
@@ -54,6 +52,8 @@
 if len(config['dash']['users']) > 0:
     auth = dash_auth.BasicAuth(app, config['dash']['users'])
 
+
+# define the default layout
 app.layout = dash.html.Div([
     create_navbar(),
     create_grid(),
@@ -63,6 +63,7 @@
     dcc.Interval(id='refresh_timer', interval=config['dash']['refresh'])
 ])
 
+
 @app.callback(Output('server_resources', 'data'),
               Input('refresh_timer', 'n_intervals'),
               Input('server_resources', 'data'))

Diff for: python/www/dash/assets/dropdown.css

@@ -0,0 +1,40 @@
+
+/* input box */
+/*.Select-control {
+    background-color: black;
+}*/
+
+/* changes the text color of input box */
+/*.Select-value-label {
+    color: white !important;
+}*/
+
+/*.Select--single > .Select-control .Select-value, .Select-placeholder {
+    border: 1px solid grey;
+    border-radius: 4px;
+}*/
+
+/* dropdown menu options */
+.VirtualizedSelectOption {
+    background-color: black;
+    color: white;
+ }
+
+/* dropdown menu hover effect */
+.VirtualizedSelectFocusedOption {
+    background-color: black;
+    opacity: .7;
+}
+
+/* border on focus - default is blue
+ * shadow box around input box.  default is blue
+ */
+.is-focused:not(.is-open) > .Select-control {
+  border-color: var(--primary); 
+  box-shadow: none;
+}
+
+/* this colors the input box text and x  of multi dropdown*/
+/*.Select--multi .Select-value {
+  color: white;
+}*/

Diff for: python/www/dash/config.py

@@ -29,7 +29,7 @@
         'title' : 'WebRTC Dashboard',   # title of the dash app (used in browser title bar and navbar)
         'host' : '0.0.0.0',             # hostname/IP of the frontend webserver (ignored by gunicorn)
         'port' : 8050,                  # port used for the frontend webserver (ignored by gunicorn)
-        'refresh' : 1000,               # the interval at which the server state is refreshed
+        'refresh' : 2500,               # the interval at which the server state is refreshed
         'users' : {                     # to enable basic authentication logins, add username/password pairs here
             # 'username' : 'password',
         },

Diff for: python/www/dash/layout/stream_options.py

@@ -37,7 +37,8 @@ def create_stream_options(stream={}):
 
         html.Div([
             dbc.Label('Model', html_for='stream_options_model'),
-            dbc.Select(options=list_models(), id='stream_options_model'),
+            #dbc.Select(options=list_models(), multi=True, id='stream_options_model'),
+            dcc.Dropdown(options=list_models(), multi=True, id='stream_options_model'),
             dbc.FormText("The DNN model to use for processing the stream"),
         ], className='mb-3'),
 
@@ -109,7 +110,7 @@ def stream_submit(n_clicks, name, source, model):
         raise PreventUpdate
 
     print(f"adding stream {name} from source {source} with model {model}")
-    Server.instance.add_resource('streams', name, source, [model])
+    Server.instance.add_resource('streams', name, source, model)
     raise PreventUpdate
 
 '''    

Diff for: python/www/dash/server/model.py

@@ -21,21 +21,35 @@
 #
 
 from jetson_inference import imageNet, detectNet
-from jetson_utils import Log
+from jetson_utils import cudaFont, Log
 
 
 class Model:
     """
-    Represents a DNN model
+    Represents DNN models for classification, detection, segmentation, ect.
+    These can be either built-in models or user-provided / user-trained.
     """
     def __init__(self, server, name, type, model, labels='', input_layers='', output_layers=''):
+        """
+        Load the model, either from a built-in pre-trained model or from a user-provided model.
+        
+        Parameters:
+        
+            server (Server) -- the backend server instance
+            name (string) -- the name of the model
+            type (string) -- the type of the model (classification, detection, ect)
+            model (string) -- either a path to the model or name of the built-in model
+            labels (string) -- path to the model's labels.txt file (optional)
+            input_layers (string or dict) -- the model's input layer(s)
+            output_layers (string or dict) -- the model's output layers()
+        """
         self.name = name
         self.type = type
         self.server = server
 
         if type == 'classification':
             self.net = imageNet(model=model, labels=labels, input_blob=input_layers, output_blob=output_layers)
-
+            self.font = cudaFont()
         elif type == 'detection':
             if not output_layers:
                 output_layers = {'scores': '', 'bbox': ''}
@@ -45,9 +59,45 @@ def __init__(self, server, name, type, model, labels='', input_layers='', output
             self.net = detectNet(model=model, labels=labels, input_blob=input_layers, 
                                  output_cvg=output_layers['scores'], 
                                  output_bbox=output_layers['bbox'])
-           
+        else:
+            raise ValueError(f"invalid model type '{type}'")
+            
     def get_config(self):
+        """
+        Return a dict representation of the object.
+        """
         return {
             'name' : self.name,
             'type' : self.type,
-        }
+        }
+
+    def get_num_classes(self):
+        """
+        Get the number of classes that the model supports.
+        """
+        return self.net.GetNumClasses()
+        
+    def get_class_name(self, class_id):
+        """
+        Return the class name or description for the given class ID.
+        """
+        return self.net.GetClassDesc(class_id)
+  
+    def process(self, img):
+        """
+        Process an image with the model and return the results.
+        """
+        if self.type == 'classification':
+            return self.net.Classify(img)
+        elif self.type == 'detection':
+            return self.net.Detect(img, overlay='none')
+    
+    def visualize(self, img, results):
+        """
+        Visualize the results on an image.
+        """
+        if self.type == 'classification':
+            str = "{:05.2f}% {:s}".format(results[1] * 100, self.get_class_name(results[0]))
+            self.font.OverlayText(img, img.width, img.height, str, 5, 5, self.font.White, self.font.Gray40)
+        elif self.type == 'detection':
+            self.net.Overlay(img, results)

Diff for: python/www/dash/server/server.py

@@ -26,12 +26,13 @@
 import time
 import psutil
 import random
+import traceback
 import threading
 import multiprocessing
 import setproctitle
 
-from xmlrpc.server import SimpleXMLRPCServer
 from xmlrpc.client import ServerProxy
+from xmlrpc.server import SimpleXMLRPCServer
 
 from jetson_utils import Log
 
@@ -220,8 +221,11 @@ def process(self):
         """
         Perform one interation of the processing loop.
         """
-        for stream in self.resources['streams'].values():     # TODO don't spin if no streams
-            stream.process()
+        if len(self.resources['streams']) > 0:
+            for stream in self.resources['streams'].values():
+                stream.process()
+        else:
+            time.sleep(1.0)
 
     def add_resource(self, group, name, *args, **kwargs):
         """
@@ -246,7 +250,7 @@ def add_resource(self, group, name, *args, **kwargs):
                 return
         except Exception as error:
             Log.Error(f"[{self.name}] failed to create resource '{name}' in group '{group}'")
-            Log.Error(f"{error}")
+            traceback.print_exc()
             return
 
         self.resources[group][name] = resource

Diff for: python/www/dash/server/stream.py

@@ -22,6 +22,8 @@
 
 from jetson_utils import videoSource, videoOutput, Log
 
+import pprint
+import traceback
 
 class Stream:
     """
@@ -49,6 +51,9 @@ def __init__(self, server, name, source, models=[]):
         # lookup models
         self.models = []
 
+        if isinstance(models, str):
+            models = [models]
+
         for model in models:
             if model in server.resources['models']:
                 self.models.append(server.resources['models'][model])
@@ -57,11 +62,21 @@ def __init__(self, server, name, source, models=[]):
 
 
     def process(self):
+        """
+        Perform one capture/process/output iteration
+        """
         try:
             img = self.source.Capture()
-        except Exception as error:
+            results = [model.process(img) for model in self.models]
+            
+            print('model results:')
+            pprint.pprint(results)
+            
+            for model, result in zip(self.models, results):
+                model.visualize(img, result) 
+        except:
             # TODO check if stream is still open, if not reconnect?
-            Log.Error(f"{error}")
+            traceback.print_exc()
             return
 
         if self.frame_count % 25 == 0 or self.frame_count < 15:
@@ -71,8 +86,10 @@ def process(self):
         self.frame_count += 1
 
     def get_config(self):
-        # TODO add stats or runtime_stats option for easy frontend state-change comparison?
-        # the videoOptions could be dynamic as well... (i.e. framerate - actually that is not?)
+        """
+        TODO add stats or runtime_stats option for easy frontend state-change comparison?
+        the videoOptions could be dynamic as well... (i.e. framerate - actually that is not?)
+        """
         return {
             "name" : self.name,
             "source" : self.source.GetOptions(),