dolla-one-recognizer-py 0.1.2__tar.gz

dolla_one_recognizer_py-0.1.2/LICENSE

@@ -0,0 +1,66 @@
+The $1 Unistroke Recognizer (Python 3 port)
+
+    Jacob O. Wobbrock, Ph.D.
+    The Information School
+    University of Washington
+    wobbrock@uw.edu
+
+    Andrew D. Wilson, Ph.D.
+    Microsoft Research
+    awilson@microsoft.com
+
+    Yang Li, Ph.D.
+    Department of Computer Science and Engineering
+    University of Washington
+    yangli@cs.washington.edu
+
+The academic publication for the $1 recognizer, and what should be
+used to cite it, is:
+
+    Wobbrock, J.O., Wilson, A.D. and Li, Y. (2007). Gestures without
+    libraries, toolkits or training: A $1 recognizer for user interface
+    prototypes. Proceedings of the ACM Symposium on User Interface
+    Software and Technology (UIST '07). Newport, Rhode Island (October
+    7-10, 2007). New York: ACM Press, pp. 159-168.
+    https://dl.acm.org/citation.cfm?id=1294238
+
+The Protractor enhancement was separately published by Yang Li and programmed
+here by Jacob O. Wobbrock:
+
+    Li, Y. (2010). Protractor: A fast and accurate gesture
+    recognizer. Proceedings of the ACM Conference on Human
+    Factors in Computing Systems (CHI '10). Atlanta, Georgia
+    (April 10-15, 2010). New York: ACM Press, pp. 2169-2172.
+    https://dl.acm.org/citation.cfm?id=1753654
+
+This software is distributed under the "New BSD License" agreement:
+
+Copyright (C) 2007-2012, Jacob O. Wobbrock, Andrew D. Wilson and Yang Li.
+All rights reserved.
+
+Python 3 port Copyright (C) 2026, yuzujelly2222.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   * Neither the names of the University of Washington nor Microsoft,
+     nor the names of its contributors may be used to endorse or promote
+     products derived from this software without specific prior written
+     permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Jacob O. Wobbrock OR Andrew D. Wilson
+OR Yang Li OR yuzujelly2222 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

dolla_one_recognizer_py-0.1.2/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: dolla_one_recognizer_py
+Version: 0.1.2
+Summary: A Python 3 implementation of the $1 Unistroke Recognizer
+Home-page: https://github.com/yuzujelly2222/dolla_one_recognizer_python
+Author: yuzujelly2222
+License: BSD-3-Clause
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[English](README.md) | [日本語](README.ja.md)
+
+# dolla_one_recognizer
+
+A Python 3 implementation of the **$1 Unistroke Recognizer**.
+
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/)
+
+> 詳しい日本語の解説は [README.ja.md](README.ja.md) にあります。
+
+## What is this
+
+The **$1 Unistroke Recognizer** is a lightweight single-stroke gesture recognition
+algorithm by Wobbrock, Wilson, and Li (UIST '07). It needs no machine-learning
+training: register just one template per shape and it works. It resamples the input
+stroke to a fixed number of points, normalizes rotation, scale, and position, then
+picks the nearest registered template.
+
+Input is a plain list of points `[[x, y], ...]`, so the coordinates can come from a
+mouse, touch input, or a tracker such as OpenCV optical flow / color / fingertip
+tracking — just append each frame's `(x, y)` and pass the list in.
+
+This repository contains the recognizer itself, packaged as `dolla_one_recognizer_py/`,
+plus two small Tkinter demo apps: `export_gesture_app.py` (draw and save gesture
+templates) and `recognize_app.py` (match a drawn stroke against saved templates).
+
+![Demo of recognize_app.py matching hand-drawn gestures against registered templates](assets/demo.gif)
+
+## Install
+
+```bash
+git clone https://github.com/yuzujelly2222/dolla_one_recognizer_python.git
+cd dolla_one_recognizer
+pip install -r requirements.txt
+```
+
+Dependencies are `numpy` (geometry) and `pillow` (PNG I/O for the demo apps).
+
+## Usage
+
+```python
+from dolla_one_recognizer_py import dolla_one_recognizer
+
+# Register templates — one example stroke per shape is enough
+line_template = [[x, x] for x in range(0, 101, 5)]
+check_template = [[0, 30], [30, 0], [90, 60]]
+
+recognizer = dolla_one_recognizer(
+    size=250,
+    templates=[line_template, check_template],
+    templates_name=["line", "checkmark"],
+    n=64,
+)
+
+# Raw points to recognize (e.g. collected from a mouse drag)
+query = [[x, x * 0.9 + 2] for x in range(0, 101, 4)]
+
+best_points, best_name, score = recognizer.recognize(query)
+print(best_name, score)  # -> line 0.96...
+```
+
+Try the GUI demos:
+
+```bash
+python export_gesture_app.py   # draw and save to gestures/ as CSV + PNG
+python recognize_app.py        # auto-load gestures/ and test recognition
+```
+
+## How it works
+
+$1 applies four steps to the input points and returns the nearest template:
+
+1. **Resample** (`_resample`) to `n` (default 64) evenly spaced points, absorbing
+   differences in drawing speed.
+2. **Rotate** (`_rotate_to_zero`) so the angle from the centroid to the first point is zero.
+3. **Scale & translate** (`_scale_to_square` -> `_translate_to_origin`) into a
+   `size x size` square (default 250) centered at the origin.
+4. **Match** (`recognize`) against each template, searching +/-45 degrees for the
+   rotation that minimizes the average point-to-point distance (Golden Section Search),
+   and return the closest. The distance is converted to a 0-1 score.
+
+The Protractor enhancement (a closed-form optimal angle instead of the search) is not
+included in this implementation. See [README.ja.md](README.ja.md) for a fuller walkthrough.
+
+## API
+
+Only the members below are part of the public API; the geometry helpers are prefixed
+with `_` and are internal.
+
+| Member | Description |
+|---|---|
+| `__init__(size, templates, templates_name, n)` | Initialize with a list of template strokes and their names |
+| `add_template(points, name)` | Add one more template |
+| `recognize(points)` | Normalize a raw stroke, match all templates, return `(best_points, best_name, score)` |
+
+## License & citation
+
+Distributed under the **New BSD License** — see [LICENSE](LICENSE).
+
+This is an independent implementation based on the pseudocode from the paper below.
+The original authors and copyright holders exist separately from this port.
+
+> Wobbrock, J.O., Wilson, A.D. and Li, Y. (2007). Gestures without libraries, toolkits
+> or training: A $1 recognizer for user interface prototypes. *Proceedings of the ACM
+> Symposium on User Interface Software and Technology (UIST '07)*, pp. 159-168.
+
+Official site (algorithm, pseudocode, reference implementation):
+<https://depts.washington.edu/acelab/proj/dollar/index.html>

dolla_one_recognizer_py-0.1.2/README.md

@@ -0,0 +1,109 @@
+[English](README.md) | [日本語](README.ja.md)
+
+# dolla_one_recognizer
+
+A Python 3 implementation of the **$1 Unistroke Recognizer**.
+
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/)
+
+> 詳しい日本語の解説は [README.ja.md](README.ja.md) にあります。
+
+## What is this
+
+The **$1 Unistroke Recognizer** is a lightweight single-stroke gesture recognition
+algorithm by Wobbrock, Wilson, and Li (UIST '07). It needs no machine-learning
+training: register just one template per shape and it works. It resamples the input
+stroke to a fixed number of points, normalizes rotation, scale, and position, then
+picks the nearest registered template.
+
+Input is a plain list of points `[[x, y], ...]`, so the coordinates can come from a
+mouse, touch input, or a tracker such as OpenCV optical flow / color / fingertip
+tracking — just append each frame's `(x, y)` and pass the list in.
+
+This repository contains the recognizer itself, packaged as `dolla_one_recognizer_py/`,
+plus two small Tkinter demo apps: `export_gesture_app.py` (draw and save gesture
+templates) and `recognize_app.py` (match a drawn stroke against saved templates).
+
+![Demo of recognize_app.py matching hand-drawn gestures against registered templates](assets/demo.gif)
+
+## Install
+
+```bash
+git clone https://github.com/yuzujelly2222/dolla_one_recognizer_python.git
+cd dolla_one_recognizer
+pip install -r requirements.txt
+```
+
+Dependencies are `numpy` (geometry) and `pillow` (PNG I/O for the demo apps).
+
+## Usage
+
+```python
+from dolla_one_recognizer_py import dolla_one_recognizer
+
+# Register templates — one example stroke per shape is enough
+line_template = [[x, x] for x in range(0, 101, 5)]
+check_template = [[0, 30], [30, 0], [90, 60]]
+
+recognizer = dolla_one_recognizer(
+    size=250,
+    templates=[line_template, check_template],
+    templates_name=["line", "checkmark"],
+    n=64,
+)
+
+# Raw points to recognize (e.g. collected from a mouse drag)
+query = [[x, x * 0.9 + 2] for x in range(0, 101, 4)]
+
+best_points, best_name, score = recognizer.recognize(query)
+print(best_name, score)  # -> line 0.96...
+```
+
+Try the GUI demos:
+
+```bash
+python export_gesture_app.py   # draw and save to gestures/ as CSV + PNG
+python recognize_app.py        # auto-load gestures/ and test recognition
+```
+
+## How it works
+
+$1 applies four steps to the input points and returns the nearest template:
+
+1. **Resample** (`_resample`) to `n` (default 64) evenly spaced points, absorbing
+   differences in drawing speed.
+2. **Rotate** (`_rotate_to_zero`) so the angle from the centroid to the first point is zero.
+3. **Scale & translate** (`_scale_to_square` -> `_translate_to_origin`) into a
+   `size x size` square (default 250) centered at the origin.
+4. **Match** (`recognize`) against each template, searching +/-45 degrees for the
+   rotation that minimizes the average point-to-point distance (Golden Section Search),
+   and return the closest. The distance is converted to a 0-1 score.
+
+The Protractor enhancement (a closed-form optimal angle instead of the search) is not
+included in this implementation. See [README.ja.md](README.ja.md) for a fuller walkthrough.
+
+## API
+
+Only the members below are part of the public API; the geometry helpers are prefixed
+with `_` and are internal.
+
+| Member | Description |
+|---|---|
+| `__init__(size, templates, templates_name, n)` | Initialize with a list of template strokes and their names |
+| `add_template(points, name)` | Add one more template |
+| `recognize(points)` | Normalize a raw stroke, match all templates, return `(best_points, best_name, score)` |
+
+## License & citation
+
+Distributed under the **New BSD License** — see [LICENSE](LICENSE).
+
+This is an independent implementation based on the pseudocode from the paper below.
+The original authors and copyright holders exist separately from this port.
+
+> Wobbrock, J.O., Wilson, A.D. and Li, Y. (2007). Gestures without libraries, toolkits
+> or training: A $1 recognizer for user interface prototypes. *Proceedings of the ACM
+> Symposium on User Interface Software and Technology (UIST '07)*, pp. 159-168.
+
+Official site (algorithm, pseudocode, reference implementation):
+<https://depts.washington.edu/acelab/proj/dollar/index.html>

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py/__init__.py

@@ -0,0 +1,2 @@
+from .recognizer import dolla_one_recognizer
+__version__ = '0.1.2'

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py/recognizer.py

@@ -0,0 +1,236 @@
+
+# The $1 Unistroke Recognizer (Python 3 version)
+#
+#     Jacob O. Wobbrock, Ph.D.
+#     The Information School
+#     University of Washington
+#     wobbrock@uw.edu
+#
+#     Andrew D. Wilson, Ph.D.
+#     Microsoft Research
+#     awilson@microsoft.com
+#
+#     Yang Li, Ph.D.
+#     Department of Computer Science and Engineering
+#     University of Washington
+#     yangli@cs.washington.edu
+#
+# The academic publication for the $1 recognizer, and what should be
+# used to cite it, is:
+#
+#     Wobbrock, J.O., Wilson, A.D. and Li, Y. (2007). Gestures without
+#     libraries, toolkits or training: A $1 recognizer for user interface
+#     prototypes. Proceedings of the ACM Symposium on User Interface
+#     Software and Technology (UIST '07). Newport, Rhode Island (October
+#     7-10, 2007). New York: ACM Press, pp. 159-168.
+#     https://dl.acm.org/citation.cfm?id=1294238
+#
+# The Protractor enhancement was separately published by Yang Li and programmed
+# here by Jacob O. Wobbrock:
+#
+#     Li, Y. (2010). Protractor: A fast and accurate gesture
+#     recognizer. Proceedings of the ACM Conference on Human
+#     Factors in Computing Systems (CHI '10). Atlanta, Georgia
+#     (April 10-15, 2010). New York: ACM Press, pp. 2169-2172.
+#     https://dl.acm.org/citation.cfm?id=1753654
+#
+# This software is distributed under the "New BSD License" agreement:
+#
+# Copyright (C) 2007-2012, Jacob O. Wobbrock, Andrew D. Wilson and Yang Li.
+# All rights reserved.
+#
+# Python 3 port Copyright (C) 2026, yuzujelly2222.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#    * Neither the names of the University of Washington nor Microsoft,
+#      nor the names of its contributors may be used to endorse or promote
+#      products derived from this software without specific prior written
+#      permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Jacob O. Wobbrock OR Andrew D. Wilson
+# OR Yang Li OR yuzujelly2222 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from typing import Sequence
+
+import numpy as np
+
+Point = Sequence[float]
+Points = Sequence[Point]
+
+
+class templates_template:
+    points: np.ndarray = np.empty((0, 2))
+    name: str = ""
+
+
+class _deg:
+    sin = staticmethod(lambda x: np.sin(np.deg2rad(x)))
+    cos = staticmethod(lambda x: np.cos(np.deg2rad(x)))
+    tan = staticmethod(lambda x: np.tan(np.deg2rad(x)))
+    arcsin = staticmethod(lambda x: np.rad2deg(np.arcsin(x)))
+    arccos = staticmethod(lambda x: np.rad2deg(np.arccos(x)))
+    arctan = staticmethod(lambda x: np.rad2deg(np.arctan(x)))
+    arctan2 = staticmethod(lambda y, x: np.rad2deg(np.arctan2(y, x)))
+
+
+class dolla_one_recognizer:
+    def __init__(self, size: float, templates: Sequence[Points], templates_name: Sequence[str], n: int) -> None:
+        self.size = size
+        self.n = n
+        self.templates: list[templates_template] = []
+        for points, name in zip(templates, templates_name):
+            template = templates_template()
+            template.points = self._normalize(points)
+            template.name = name
+            self.templates.append(template)
+
+    def add_template(self, points: Points, name: str) -> None:
+        template = templates_template()
+        template.points = self._normalize(points)
+        template.name = name
+        self.templates.append(template)
+
+    def _get_distance(self, p1: Point, p2: Point) -> float:
+        return ((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)**0.5
+
+    def _get_length(self, points: Points) -> float:
+        return sum(self._get_distance(points[i-1], points[i]) for i in range(1, len(points)))
+
+    def _get_centroid(self, points: Points) -> list[float]:
+        xs = [p[0] for p in points]
+        ys = [p[1] for p in points]
+        return [sum(xs)/len(points), sum(ys)/len(points)]
+
+    def _get_bounding_box(self, points: Points) -> tuple[float, float]:
+        xs = [p[0] for p in points]
+        ys = [p[1] for p in points]
+        x_max = max(xs)
+        x_min = min(xs)
+        y_max = max(ys)
+        y_min = min(ys)
+        width = abs(x_max - x_min)
+        height = abs(y_max - y_min)
+        return width, height
+
+    def _all_point_rotate(self, points: Points, theta: float) -> np.ndarray:
+        c = self._get_centroid(points)
+        new_points = list()
+        for point in points:
+            qx = (point[0]-c[0])*_deg.cos(theta) - (point[1]-c[1])*_deg.sin(theta) + c[0]
+            qy = (point[0]-c[0])*_deg.sin(theta) + (point[1]-c[1])*_deg.cos(theta) + c[1]
+            new_points.append([qx,qy])
+        return np.array(new_points)
+
+    def _resample(self, points: Points) -> np.ndarray:
+        points = [list(p) for p in points]
+        ideal = self._get_length(points) / (self.n - 1)
+        new_points = [points[0][:]]
+        all_distance = 0.0
+        i = 1
+        while i < len(points):
+            distance = self._get_distance(points[i-1], points[i])
+            if all_distance + distance >= ideal:
+                t = (ideal - all_distance) / distance
+                qx = points[i-1][0] + t * (points[i][0] - points[i-1][0])
+                qy = points[i-1][1] + t * (points[i][1] - points[i-1][1])
+                q = [qx, qy]
+                new_points.append(q)
+                points.insert(i, q)
+                all_distance = 0.0
+            else:
+                all_distance += distance
+            i += 1
+        if len(new_points) == self.n - 1:
+            new_points.append(points[-1][:])
+        return np.array(new_points)
+
+    def _rotate_to_zero(self, points: Points) -> np.ndarray:
+        c = self._get_centroid(points)
+        theta = _deg.arctan2(c[1]-points[0][1],c[0]-points[0][0])
+        return self._all_point_rotate(points,-theta)
+
+    def _scale_to_square(self, points: Points) -> np.ndarray:
+        bounding_box = self._get_bounding_box(points)
+        new_points = list()
+        for point in  points:
+            qx = point[0] * (self.size/bounding_box[0])
+            qy = point[1] * (self.size/bounding_box[1])
+            new_points.append([qx,qy])
+        return np.array(new_points)
+
+    def _translate_to_origin(self, points: Points) -> np.ndarray:
+        c = self._get_centroid(points)
+        new_points = list()
+        for point in points:
+            qx = point[0] - c[0]
+            qy = point[1] - c[1]
+            new_points.append([qx,qy])
+        return np.array(new_points)
+
+    def _normalize(self, points: Points) -> np.ndarray:
+        points = self._resample(points)
+        points = self._rotate_to_zero(points)
+        points = self._scale_to_square(points)
+        points = self._translate_to_origin(points)
+        return points
+
+    def recognize(self, points: Points) -> tuple[np.ndarray, str, float]:
+        points = self._normalize(points)
+        best_point = float('inf')
+        for template in self.templates:
+            temp_point = self._distance_at_best_angle(points, template.points, -45,45,2)
+            if temp_point < best_point:
+                best_point = temp_point
+                best_template = template.points
+                best_template_name = template.name
+        score = 1 - best_point / (0.5*((self.size**2+self.size**2)**0.5))
+        return best_template, best_template_name, score
+
+    def _distance_at_best_angle(self, points: Points, template: Points, theta_a: float, theta_b: float, theta_d: float) -> float:
+        GOLDEN_RATIO = 0.5*(-1+(5)**0.5)
+        x_1 = GOLDEN_RATIO*theta_a + (1-GOLDEN_RATIO)*theta_b
+        f_1 = self._distance_at_angle(points, template, x_1)
+        x_2 = GOLDEN_RATIO*theta_b + (1-GOLDEN_RATIO)*theta_a
+        f_2 = self._distance_at_angle(points, template, x_2)
+        while abs(theta_b-theta_a) > theta_d:
+            if f_1 < f_2:
+                theta_b = x_2
+                x_2 = x_1
+                f_2 = f_1
+                x_1 = GOLDEN_RATIO*theta_a +(1-GOLDEN_RATIO)*theta_b
+                f_1 = self._distance_at_angle(points, template,x_1)
+            else:
+                theta_a = x_1
+                x_1 = x_2
+                f_1 = f_2
+                x_2 = GOLDEN_RATIO*theta_b + (1-GOLDEN_RATIO)*theta_a
+                f_2 = self._distance_at_angle(points, template, x_2)
+
+        return min(f_1,f_2)
+
+    def _distance_at_angle(self, points: Points, template: Points, theta: float) -> float:
+        new_points = self._all_point_rotate(points,theta)
+        return self._path_distance(new_points,template)
+
+    def _path_distance(self, a: Points, b: Points) -> float:
+        d = 0
+        for i in range(len(a)):
+            d = d + self._get_distance(a[i],b[i])
+        return d / len(a)
+
+    def main(self, points: Points) -> tuple[np.ndarray, str, float]:
+        return self.recognize(points)

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: dolla_one_recognizer_py
+Version: 0.1.2
+Summary: A Python 3 implementation of the $1 Unistroke Recognizer
+Home-page: https://github.com/yuzujelly2222/dolla_one_recognizer_python
+Author: yuzujelly2222
+License: BSD-3-Clause
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[English](README.md) | [日本語](README.ja.md)
+
+# dolla_one_recognizer
+
+A Python 3 implementation of the **$1 Unistroke Recognizer**.
+
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/)
+
+> 詳しい日本語の解説は [README.ja.md](README.ja.md) にあります。
+
+## What is this
+
+The **$1 Unistroke Recognizer** is a lightweight single-stroke gesture recognition
+algorithm by Wobbrock, Wilson, and Li (UIST '07). It needs no machine-learning
+training: register just one template per shape and it works. It resamples the input
+stroke to a fixed number of points, normalizes rotation, scale, and position, then
+picks the nearest registered template.
+
+Input is a plain list of points `[[x, y], ...]`, so the coordinates can come from a
+mouse, touch input, or a tracker such as OpenCV optical flow / color / fingertip
+tracking — just append each frame's `(x, y)` and pass the list in.
+
+This repository contains the recognizer itself, packaged as `dolla_one_recognizer_py/`,
+plus two small Tkinter demo apps: `export_gesture_app.py` (draw and save gesture
+templates) and `recognize_app.py` (match a drawn stroke against saved templates).
+
+![Demo of recognize_app.py matching hand-drawn gestures against registered templates](assets/demo.gif)
+
+## Install
+
+```bash
+git clone https://github.com/yuzujelly2222/dolla_one_recognizer_python.git
+cd dolla_one_recognizer
+pip install -r requirements.txt
+```
+
+Dependencies are `numpy` (geometry) and `pillow` (PNG I/O for the demo apps).
+
+## Usage
+
+```python
+from dolla_one_recognizer_py import dolla_one_recognizer
+
+# Register templates — one example stroke per shape is enough
+line_template = [[x, x] for x in range(0, 101, 5)]
+check_template = [[0, 30], [30, 0], [90, 60]]
+
+recognizer = dolla_one_recognizer(
+    size=250,
+    templates=[line_template, check_template],
+    templates_name=["line", "checkmark"],
+    n=64,
+)
+
+# Raw points to recognize (e.g. collected from a mouse drag)
+query = [[x, x * 0.9 + 2] for x in range(0, 101, 4)]
+
+best_points, best_name, score = recognizer.recognize(query)
+print(best_name, score)  # -> line 0.96...
+```
+
+Try the GUI demos:
+
+```bash
+python export_gesture_app.py   # draw and save to gestures/ as CSV + PNG
+python recognize_app.py        # auto-load gestures/ and test recognition
+```
+
+## How it works
+
+$1 applies four steps to the input points and returns the nearest template:
+
+1. **Resample** (`_resample`) to `n` (default 64) evenly spaced points, absorbing
+   differences in drawing speed.
+2. **Rotate** (`_rotate_to_zero`) so the angle from the centroid to the first point is zero.
+3. **Scale & translate** (`_scale_to_square` -> `_translate_to_origin`) into a
+   `size x size` square (default 250) centered at the origin.
+4. **Match** (`recognize`) against each template, searching +/-45 degrees for the
+   rotation that minimizes the average point-to-point distance (Golden Section Search),
+   and return the closest. The distance is converted to a 0-1 score.
+
+The Protractor enhancement (a closed-form optimal angle instead of the search) is not
+included in this implementation. See [README.ja.md](README.ja.md) for a fuller walkthrough.
+
+## API
+
+Only the members below are part of the public API; the geometry helpers are prefixed
+with `_` and are internal.
+
+| Member | Description |
+|---|---|
+| `__init__(size, templates, templates_name, n)` | Initialize with a list of template strokes and their names |
+| `add_template(points, name)` | Add one more template |
+| `recognize(points)` | Normalize a raw stroke, match all templates, return `(best_points, best_name, score)` |
+
+## License & citation
+
+Distributed under the **New BSD License** — see [LICENSE](LICENSE).
+
+This is an independent implementation based on the pseudocode from the paper below.
+The original authors and copyright holders exist separately from this port.
+
+> Wobbrock, J.O., Wilson, A.D. and Li, Y. (2007). Gestures without libraries, toolkits
+> or training: A $1 recognizer for user interface prototypes. *Proceedings of the ACM
+> Symposium on User Interface Software and Technology (UIST '07)*, pp. 159-168.
+
+Official site (algorithm, pseudocode, reference implementation):
+<https://depts.washington.edu/acelab/proj/dollar/index.html>

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+setup.py
+dolla_one_recognizer_py/__init__.py
+dolla_one_recognizer_py/recognizer.py
+dolla_one_recognizer_py.egg-info/PKG-INFO
+dolla_one_recognizer_py.egg-info/SOURCES.txt
+dolla_one_recognizer_py.egg-info/dependency_links.txt
+dolla_one_recognizer_py.egg-info/requires.txt
+dolla_one_recognizer_py.egg-info/top_level.txt

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

dolla_one_recognizer_py-0.1.2/dolla_one_recognizer_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+dolla_one_recognizer_py

dolla_one_recognizer_py-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dolla_one_recognizer_py-0.1.2/setup.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+import dolla_one_recognizer_py
+from setuptools import setup
+
+long_description = Path(__file__).parent.joinpath("README.md").read_text(encoding="utf-8")
+
+setup(
+    name="dolla_one_recognizer_py",
+    version=dolla_one_recognizer_py.__version__,
+    description="A Python 3 implementation of the $1 Unistroke Recognizer",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="yuzujelly2222",
+    url="https://github.com/yuzujelly2222/dolla_one_recognizer_python",
+    license="BSD-3-Clause",
+    packages=["dolla_one_recognizer_py"],
+    install_requires=["numpy"],
+    python_requires=">=3.9",
+    classifiers=[
+        "License :: OSI Approved :: BSD License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3 :: Only",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+)