init samples

xinyzhou · xinyzhou · commit c12b32060f5b · 2019-09-25T15:23:32.000-07:00
diff --git a/samples/vision/inkrecognition_tkinter_sample.py b/samples/vision/inkrecognition_tkinter_sample.py
@@ -0,0 +1,183 @@
+import six
+if six.PY2:
+    from Tkinter import *
+    import tkMessageBox as messagebox
+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
+
+
+# Ink Recognizer Client Config
+URL = "https://api.cognitive.microsoft.com/inkrecognizer"
+CREDENTIAL = "FakeCredential"  # Put Azure credential instance here
+
+
+# Recognition Config
+# 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.
+# If "kind" in a stroke is specified, this will be overlaped in that stroke.
+APPLICATION_KIND = ApplicationKind.WRITING
+
+
+# UI Config
+CANVAS_WIDTH = 800
+CANVAS_HEIGHT = 500
+STROKE_COLOR = "#476042"  # python green
+STROKE_WIDTH = 3
+
+
+# Stroke Implementations
+# Shows simple implementation of InkPoint and InkStroke
+InkPoint = namedtuple("InkPoint", "x y")
+
+
+class InkStroke():
+    def __init__(self,
+                 ink_stroke_id,
+                 ink_points,
+                 stroke_kind=InkStrokeKind.UNKNOWN,
+                 stroke_language=""):
+        self.id = ink_stroke_id
+        self.points = ink_points
+        self.kind = stroke_kind
+        self.language = stroke_language
+
+
+# Sample wrapper for InkRecognizerClient that shows how to
+# (1) Convert stroke unit from pixel to mm
+# (2) Set language recognition locale
+# (3) Indexing a key word from recognition results
+# (4) Set application kind if user know expected type of ink content
+class RecognitionManager:
+    def __init__(self, pixel_per_mm):
+        self._pixel_per_mm = pixel_per_mm
+        self._client = InkRecognizerClient(URL, CREDENTIAL)
+        self.reset_ink()
+
+    def _reset_stroke(self):
+        self._curr_stroke_points = []
+
+    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)))
+
+    def stroke_end(self):
+        stroke = InkStroke(len(self._ink_stroke_list), self._curr_stroke_points)
+        self._ink_stroke_list.append(stroke)
+        self._reset_stroke()
+
+    def recognize(self):
+        self._root = None
+        try:
+            root = self._client.recognize_ink(
+                self._ink_stroke_list, 
+                # Pre-set recognition type
+                application_kind=APPLICATION_KIND, 
+                # Set language recognition locale
+                language=LANGUAGE_RECOGNITION_LOCALE)
+            result_text = []
+            for word in root.ink_words:
+                result_text.append(word.recognized_text)
+            for shape in root.ink_drawings:
+                result_text.append(shape.recognized_shape.value)
+            result_text = "\n".join(result_text)
+            messagebox.showinfo("Result", result_text)
+            self._root = root
+        except Exception as e:
+            messagebox.showinfo("Error", e)
+
+    def search(self, word):
+        # Indexing a key word from recognition results
+        if self._root is not None:
+            words = self._root.find_word(word)
+            messagebox.showinfo("Search Result", "Find %s words" % len(words))
+        else:
+            messagebox.showinfo("Search Result", "Find %s words" % 0)
+
+
+# Sample UI
+class InkRecognizerDemo:
+    def __init__(self):
+        self._master = Tk()
+        self._pack_widgets()
+        
+        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
+        self._search_variable = StringVar(value="")
+        search_entry = Entry(self._master, textvariable=self._search_variable)
+        search_button = Button(self._master, text="search a word", command=self._search)
+        search_entry.pack(pady=5)
+        search_button.pack()
+        # main canvas
+        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("<ButtonRelease-1>", self._stroke_end)
+        # recognize and clear buttons
+        recognize_button = Button(
+            self._master, text="Recognize", command=self._recognize)
+        recognize_button.pack(pady=5)
+        clear_button = Button(
+            self._master, text="Clear", command=self._clear_canvas)
+        clear_button.pack(pady=5)
+
+    def _draw(self, event):
+        # 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]
+            self._canvas.create_line(
+                x_last, y_last, x_curr, y_curr, fill=STROKE_COLOR, width=STROKE_WIDTH)
+        self._last_point = x_curr, y_curr
+        # add point to stroke store
+        self._recognition_manager.add_point(x_curr, y_curr)
+
+    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): 
+        mainloop()
+
+
+if __name__ == "__main__":
+    demo = InkRecognizerDemo()
+    demo.run()
diff --git a/samples/vision/inkrecognition_wxpython_sample.py b/samples/vision/inkrecognition_wxpython_sample.py
@@ -0,0 +1,210 @@
+import wx
+from azure.ai.inkrecognizer import ApplicationKind, InkPointUnit, InkStrokeKind
+from azure.ai.inkrecognizer import InkRecognizerClient
+from collections import namedtuple
+
+
+# Ink Recognizer Client Config
+URL = "https://api.cognitive.microsoft.com/inkrecognizer"
+CREDENTIAL = "FakeCredential"  # Put Azure credential instance here
+
+
+# Recognition Config
+# 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.
+# 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 
+app = wx.App(False)
+mm_on_canvas = float(wx.GetDisplaySizeMM()[1]) 
+pixel_on_canvas = float(wx.GetDisplaySize()[1])
+UNIT_MULTIPLE = mm_on_canvas / pixel_on_canvas 
+
+
+# UI config
+canvas_width = 800
+canvas_height = 600
+linewidth = 3
+
+
+# Stroke Implementations
+# Shows simple implementation of InkPoint and InkStroke
+InkPoint = namedtuple("InkPoint", "x y")
+
+
+class InkStroke():
+    def __init__(self,
+                 ink_stroke_id,
+                 ink_points,
+                 stroke_kind=InkStrokeKind.UNKNOWN,
+                 stroke_language=""):
+        self.id = ink_stroke_id
+        self.points = ink_points
+        self.kind = stroke_kind
+        self.language = stroke_language
+
+
+# Sample wrapper for InkRecognizerClient that shows how to
+# (1) Convert stroke unit from pixel to mm
+# (2) Set language recognition locale
+# (3) Indexing a key word from recognition results
+# (4) Set application kind if user know expected type of ink content
+class RecognitionManager:
+    def __init__(self):
+        self._client = InkRecognizerClient(
+            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
+            )
+        self._reset_ink()
+    
+    def _reset_ink(self):
+        self._stroke_list = []
+        self._reset_stroke()
+        self._root = None
+
+    def _reset_stroke(self):
+        self._curr_stroke_points = []
+
+    def add_point(self, x, y):
+        self._curr_stroke_points.append(
+            InkPoint(x, y))
+
+    def stroke_start(self):
+        return
+
+    def stroke_end(self):
+        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
+
+    def get_curr_points(self):
+        return self._curr_stroke_points
+
+    def recognize(self, call_back):
+        self._root = self._client.recognize_ink(self._stroke_list)
+        result_text = []
+        for word in self._root.ink_words:
+            result_text.append(word.recognized_text)
+        for shape in self._root.ink_drawings:
+            result_text.append(shape.recognized_shape.value)
+        result_text = "\n".join(result_text)
+        call_back(result_text)
+
+    def search(self, word, call_back):
+        if self._root is not None:
+            # Indexing a key word from recognition results
+            words = self._root.find_word(word)
+            call_back(len(words))
+        else:
+            call_back(0)
+
+
+# Sample canvas
+class Canvas(wx.Panel):
+    def __init__(self, parent):
+        super(Canvas, self).__init__(parent)
+        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
+        self.Bind(wx.EVT_SIZE, self.on_size)
+        self.Bind(wx.EVT_PAINT, self.on_paint)
+        self.Bind(wx.EVT_LEFT_DOWN, self.on_click)
+        self.Bind(wx.EVT_MOTION, self.on_drag)
+        self.Bind(wx.EVT_LEFT_UP, self.on_release)
+
+        self._recognition_manager = RecognitionManager()
+
+    def on_size(self, event):
+        event.Skip()
+        self.Refresh()
+
+    def on_paint(self, event):
+        self.dc = wx.PaintDC(self)
+        self.dc.SetPen(wx.Pen(wx.BLACK, linewidth))
+        self.dc.Clear()
+        for stroke in self._recognition_manager.get_stroke_list():
+            points = stroke.points
+            for i in range(len(points) - 1):
+                self.dc.DrawLine(points[i].x, points[i].y, points[i+1].x, points[i+1].y)
+        
+        points = self._recognition_manager.get_curr_points()
+        for i in range(len(points) - 1):
+            self.dc.DrawLine(points[i].x, points[i].y, points[i+1].x, points[i+1].y)
+    
+    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()
+
+    def recognize(self, event, call_back):
+        self._recognition_manager.recognize(call_back)
+
+    def clear(self, event):
+        self._recognition_manager._reset_ink()
+        self.Refresh()
+
+    def search(self, event, word, call_back):
+        self._recognition_manager.search(word, call_back)
+
+
+# Sample wxpython app 
+class InkRecognizerDemo(wx.Frame):
+    def __init__(self):
+        super(InkRecognizerDemo, self).__init__(None)
+        self.SetTitle('Ink Recognition Demo')
+        self.SetClientSize((canvas_width, canvas_height))
+        self.Center()
+        self.view = Canvas(self)
+        self.search_button = wx.Button(self.view, wx.ID_ANY, 'Search', (0, canvas_height - 90))
+        self.recognize_button = wx.Button(self.view, wx.ID_ANY, 'Recognize', (0, canvas_height - 60))
+        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.clear_button.Bind(wx.EVT_BUTTON, self.view.clear)
+        
+
+    def show_result(self, result):
+        dlg = wx.MessageDialog(self, result, "Recognition Result")
+        dlg.ShowModal()
+    
+    def show_search_result(self, num_words):
+        dlg = wx.MessageDialog(self, "Find %s words" % num_words, "Recognition Result")
+        dlg.ShowModal()
+
+
+def main():
+    frame = InkRecognizerDemo()
+    frame.Show()
+    app.MainLoop()
+
+
+if __name__ == '__main__':
+    main()
