polish format

Author: xinyzhou

samples/vision/inkrecognition_tkinter_sample.py

@@ -5,9 +5,9 @@
 else:
     from tkinter import *
     from tkinter import messagebox
-from azure.ai.inkrecognizer import ApplicationKind, InkPointUnit, InkStrokeKind
-from azure.ai.inkrecognizer import InkRecognizerClient, InkRecognitionUnitKind
 from collections import namedtuple
+from azure.ai.inkrecognizer import ApplicationKind, InkStrokeKind
+from azure.ai.inkrecognizer import InkRecognizerClient
 
 
 # Ink Recognizer Client Config
@@ -16,12 +16,14 @@
 
 
 # Recognition Config
-# This tell Ink Recognizer Service that the sample is in en-US. 
+# This tell Ink Recognizer Service that the sample is in en-US.
 # Default value is "en-US".
 # If "language" in a stroke is specified, this will be overlaped in that stroke.
 LANGUAGE_RECOGNITION_LOCALE = "en-US"
-# This tell Ink Recognizer Service that domain of the application is writing, i.e. all strokes are writing. 
-# Default value is ApplicationKind.MIXED, which means let Ink Recognizer Service detect kind of strokes.
+# This tell Ink Recognizer Service that domain of the application is writing,
+# i.e. all strokes are writing.
+# Default value is ApplicationKind.MIXED, which means let Ink Recognizer
+# Service detect kind of strokes.
 # If "kind" in a stroke is specified, this will be overlaped in that stroke.
 APPLICATION_KIND = ApplicationKind.WRITING
 
@@ -66,16 +68,18 @@ def _reset_stroke(self):
 
     def _pixel_to_mm(self, pixel):
         return pixel * 1.0 / self._pixel_per_mm
-    
+
     def reset_ink(self):
         self._ink_stroke_list = []
         self._root = None
         self._reset_stroke()
 
     def add_point(self, x, y):
-        # Convert from pixel to mm before sending to InkPoint
-        # You can also specify keyword argument "unit_multiple" in InkRecognizerClient constructor or in recognizer_ink() request
-        self._curr_stroke_points.append(InkPoint(self._pixel_to_mm(x), self._pixel_to_mm(y)))
+        # Convert from pixel to mm before sending to InkPoint.
+        # You can also specify keyword argument "unit_multiple" in
+        # InkRecognizerClient constructor or in recognizer_ink() request.
+        self._curr_stroke_points.append(
+            InkPoint(self._pixel_to_mm(x), self._pixel_to_mm(y)))
 
     def stroke_end(self):
         stroke = InkStroke(len(self._ink_stroke_list), self._curr_stroke_points)
@@ -86,11 +90,15 @@ def recognize(self):
         self._root = None
         try:
             root = self._client.recognize_ink(
-                self._ink_stroke_list, 
+                self._ink_stroke_list,
                 # Pre-set recognition type
-                application_kind=APPLICATION_KIND, 
+                application_kind=APPLICATION_KIND,
                 # Set language recognition locale
-                language=LANGUAGE_RECOGNITION_LOCALE)
+                language=LANGUAGE_RECOGNITION_LOCALE
+            )
+            # Aruments in request is for this request only
+            # You can also specify these arguments in InkRecognizerClient constructor, 
+            # which will be default arguments for each call.
             result_text = []
             for word in root.ink_words:
                 result_text.append(word.recognized_text)
@@ -116,11 +124,12 @@ class InkRecognizerDemo:
     def __init__(self):
         self._master = Tk()
         self._pack_widgets()
-        
-        self._recognition_manager = RecognitionManager(pixel_per_mm=self._master.winfo_fpixels("1m"))
+
+        self._recognition_manager = RecognitionManager(
+            pixel_per_mm=self._master.winfo_fpixels("1m"))
         # point for drawing stroke
         self._last_point = None
-        
+
     def _pack_widgets(self):
         self._master.title("Ink Recognizer Demo")
         # search words
@@ -130,12 +139,13 @@ def _pack_widgets(self):
         search_entry.pack(pady=5)
         search_button.pack()
         # main canvas
-        self._canvas = Canvas(self._master, 
-                width=CANVAS_WIDTH, 
-                height=CANVAS_HEIGHT)
+        self._canvas = Canvas(
+            self._master,
+            width=CANVAS_WIDTH,
+            height=CANVAS_HEIGHT)
         self._canvas.pack(expand=YES, fill = BOTH)
-        self._canvas.bind( "<B1-Motion>", self._draw)
-        self._canvas.bind( "<Button-1>", self._stroke_start)
+        self._canvas.bind("<B1-Motion>", self._draw)
+        self._canvas.bind("<Button-1>", self._stroke_start)
         self._canvas.bind("<ButtonRelease-1>", self._stroke_end)
         # recognize and clear buttons
         recognize_button = Button(
@@ -146,7 +156,7 @@ def _pack_widgets(self):
         clear_button.pack(pady=5)
 
     def _draw(self, event):
-        # paint on canvas 
+        # paint on canvas
         x_curr, y_curr = event.x, event.y
         if self._last_point is not None:
             x_last, y_last = self._last_point[0], self._last_point[1]
@@ -159,25 +169,25 @@ def _draw(self, event):
     def _stroke_start(self, event):
         # nothing need to do
         pass
-    
+
     def _stroke_end(self, event):
         self._recognition_manager.stroke_end()
         self._last_point = None
 
     def _clear_canvas(self):
         self._canvas.delete("all")
         self._recognition_manager.reset_ink()
-    
+
     def _recognize(self):
         self._recognition_manager.recognize()
 
     def _search(self):
         self._recognition_manager.search(self._search_variable.get())
 
-    def run(self): 
+    def run(self):
         mainloop()
 
 
 if __name__ == "__main__":
     demo = InkRecognizerDemo()
-    demo.run()
+    demo.run()

samples/vision/inkrecognition_wxpython_sample.py

@@ -10,23 +10,27 @@
 
 
 # Recognition Config
-# This tell Ink Recognizer Service that the sample is in en-US. 
+# This tell Ink Recognizer Service that the sample is in en-US.
 # Default value is "en-US".
 # If "language" in a stroke is specified, this will be overlaped in that stroke.
 LANGUAGE_RECOGNITION_LOCALE = "en-US"
-# This tell Ink Recognizer Service that domain of the application is writing, i.e. all strokes are writing. 
-# Default value is ApplicationKind.MIXED, which means let Ink Recognizer Service detect kind of strokes.
+# This tell Ink Recognizer Service that domain of the application is writing,
+# i.e. all strokes are writing.
+# Default value is ApplicationKind.MIXED, which means let Ink Recognizer
+# Service detect kind of strokes.
 # If "kind" in a stroke is specified, this will be overlaped in that stroke.
 APPLICATION_KIND = ApplicationKind.WRITING
 
 
-# This ratio map the number of pixel for x and y axis coordinates on canvas into number of mm
-# In InK Recognizer Server, every coordinate in InkPoint will multiply this number 
-# You may also want to mutliply /divide this value before sending request and after receiving response 
+# This ratio map the number of pixel for x and y axis coordinates on canvas
+# into number of mm.
+# In InK Recognizer Server, every coordinate in InkPoint will multiply this number. 
+# You may also want to mutliply /divide this value before sending request and
+# after receiving response.
 app = wx.App(False)
-mm_on_canvas = float(wx.GetDisplaySizeMM()[1]) 
+mm_on_canvas = float(wx.GetDisplaySizeMM()[1])
 pixel_on_canvas = float(wx.GetDisplaySize()[1])
-UNIT_MULTIPLE = mm_on_canvas / pixel_on_canvas 
+UNIT_MULTIPLE = mm_on_canvas / pixel_on_canvas
 
 
 # UI config
@@ -60,18 +64,21 @@ def __init__(self,
 class RecognitionManager:
     def __init__(self):
         self._client = InkRecognizerClient(
-            URL, CREDENTIAL, 
-            ink_point_unit=InkPointUnit.MM, 
+            URL,
+            CREDENTIAL,
+            ink_point_unit=InkPointUnit.MM,
             # Convert stroke unit from pixel to mm by specify unit_multiple
             # You can also multiply the number when creating InkPoints
             unit_multiple=UNIT_MULTIPLE,
             # Set language recognition locale
             language=LANGUAGE_RECOGNITION_LOCALE,
             # Pre-set recognition type
             application_kind=APPLICATION_KIND
-            )
+        )
+        # Aruments in constructor becomes default arguments for each request
+        # You can also specify these arguments in recognize_ink() requests.
         self._reset_ink()
-    
+
     def _reset_ink(self):
         self._stroke_list = []
         self._reset_stroke()
@@ -88,11 +95,12 @@ def stroke_start(self):
         return
 
     def stroke_end(self):
-        stroke = InkStroke(len(self._stroke_list), 
-                           self._curr_stroke_points)
+        stroke = InkStroke(
+            len(self._stroke_list),
+            self._curr_stroke_points)
         self._stroke_list.append(stroke)
         self._reset_stroke()
-    
+
     def get_stroke_list(self):
         return self._stroke_list
 
@@ -150,12 +158,12 @@ def on_paint(self, event):
 
     def on_click(self, event):
         self._recognition_manager.stroke_start()
-    
+
     def on_drag(self, event):
         if event.Dragging():
             self._recognition_manager.add_point(event.X, event.y)
             self.Refresh()
-    
+
     def on_release(self, event):
         self._recognition_manager.stroke_end()
         self.Refresh()
@@ -171,7 +179,7 @@ def search(self, event, word, call_back):
         self._recognition_manager.search(word, call_back)
 
 
-# Sample wxpython app 
+# Sample wxpython app
 class InkRecognizerDemo(wx.Frame):
     def __init__(self):
         super(InkRecognizerDemo, self).__init__(None)
@@ -184,18 +192,24 @@ def __init__(self):
         self.clear_button = wx.Button(self.view, wx.ID_ANY, 'Clear', (0, canvas_height - 30))
 
         self.search_text = wx.TextCtrl(self.view, wx.ID_ANY, "", (0, canvas_height - 120))
-        func_search = lambda event: self.view.search(event, self.search_text.GetLineText(0), call_back=self.show_search_result)
-        self.search_button.Bind(wx.EVT_BUTTON, func_search)
-        func_recognize = lambda event: self.view.recognize(event, call_back=self.show_result)
-        self.recognize_button.Bind(wx.EVT_BUTTON, func_recognize)
+        self.search_button.Bind(wx.EVT_BUTTON, self._search_function)
+        self.recognize_button.Bind(wx.EVT_BUTTON, self._recognize_function)
         self.clear_button.Bind(wx.EVT_BUTTON, self.view.clear)
-        
 
-    def show_result(self, result):
+    def _search_function(self, event):
+        return self.view.search(
+            event, 
+            self.search_text.GetLineText(0), 
+            call_back=self._show_search_result)
+
+    def _recognize_function(self, event):
+        return self.view.recognize(event, call_back=self._show_result)
+
+    def _show_result(self, result):
         dlg = wx.MessageDialog(self, result, "Recognition Result")
         dlg.ShowModal()
-    
-    def show_search_result(self, num_words):
+
+    def _show_search_result(self, num_words):
         dlg = wx.MessageDialog(self, "Find %s words" % num_words, "Recognition Result")
         dlg.ShowModal()