teody-vision 0.1.0__tar.gz

teody_vision-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: teody-vision
+Version: 0.1.0
+Summary: A deterministic, non-neural topological tensor framework for real-time UI text and field localization.
+Author-email: Teody Arboneda Banagan <teody882011@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: opencv-python>=4.5.0
+Requires-Dist: mss>=9.0.0
+Dynamic: license-file

teody_vision-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "teody-vision"
+version = "0.1.0"
+description = "A deterministic, non-neural topological tensor framework for real-time UI text and field localization."
+authors = [
+    { name="Teody Arboneda Banagan", email="teody882011@gmail.com" }
+]
+
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.21.0",
+    "opencv-python>=4.5.0",
+    "mss>=9.0.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Image Processing",
+]

teody_vision-0.1.0/setup.cfg

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

teody_vision-0.1.0/teody_vision/__init__.py

@@ -0,0 +1,11 @@
+"""
+TEODY-Vision Package Initialization
+"""
+
+from .core import TEODYEngine
+from .tensor import TEODYTensorEngine
+from .topology import TEODYTopologyEngine
+from .matcher import TEODYMatcher
+
+__version__ = "0.1.0"
+__all__ = ["TEODYEngine", "TEODYTensorEngine", "TEODYTopologyEngine", "TEODYMatcher"]

teody_vision-0.1.0/teody_vision/core.py

@@ -0,0 +1,27 @@
+import cv2
+import numpy as np
+from mss import mss
+from .tensor import TEODYTensorEngine
+from .topology import TEODYTopologyEngine
+
+class TEODYEngine:
+    def __init__(self, monitor_index: int = 1, block_size: int = 3, k: float = 0.04):
+        self.monitor_index = monitor_index
+        self.sct = mss()
+        # Initialize tensor engine with block_size and k matching its definition
+        self.tensor_engine = TEODYTensorEngine(block_size=block_size, k=k)
+        self.topology_engine = TEODYTopologyEngine()
+
+    def capture_frame(self) -> np.ndarray:
+        """Captures a high-speed screen frame using mss."""
+        monitor = self.sct.monitors[self.monitor_index]
+        sct_img = self.sct.grab(monitor)
+        frame = np.array(sct_img)
+        # Convert BGRA to BGR
+        return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR) if frame.shape[2] == 4 else frame
+
+    def process_frame(self, frame: np.ndarray) -> tuple[np.ndarray, list[tuple[int, int, int, int]]]:
+        """Runs the tensor coherence and topological region extraction pipeline."""
+        coherence = self.tensor_engine.compute_coherence(frame)
+        regions = self.topology_engine.extract_regions(coherence)
+        return coherence, regions

teody_vision-0.1.0/teody_vision/matcher.py

@@ -0,0 +1,60 @@
+import cv2
+import numpy as np
+
+class TEODYMatcher:
+    @staticmethod
+    def match_template_in_regions(frame: np.ndarray, 
+                                  template: np.ndarray, 
+                                  regions: list[tuple[int, int, int, int]], 
+                                  threshold: float = 0.48) -> list[tuple[int, int, int, int]]:
+        """
+        Performs Multi-Scale Gradient Magnitude Template Matching.
+        Resilient to browser anti-aliasing, font smoothing, and variable font sizes.
+        """
+        if template is None or len(regions) == 0:
+            return []
+
+        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if len(frame.shape) == 3 else frame
+        gray_template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY) if len(template.shape) == 3 else template
+
+        def get_gradient_magnitude(img):
+            grad_x = cv2.Sobel(img, cv2.CV_32F, 1, 0, ksize=3)
+            grad_y = cv2.Sobel(img, cv2.CV_32F, 0, 1, ksize=3)
+            magnitude = cv2.magnitude(grad_x, grad_y)
+            return cv2.normalize(magnitude, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+
+        template_grad_base = get_gradient_magnitude(gray_template)
+        
+        # Scale pyramid range supporting small sidebar fonts (0.6x) up to large headers (1.8x)
+        scales = [0.6, 0.8, 1.0, 1.2, 1.5, 1.8]
+        matched_boxes = []
+
+        for (x, y, w, h) in regions:
+            roi = gray_frame[y:y+h, x:x+w]
+            if roi.size == 0:
+                continue
+            
+            roi_grad = get_gradient_magnitude(roi)
+            best_match_val = -1
+            best_box = None
+
+            for scale in scales:
+                scaled_w = int(template_grad_base.shape[1] * scale)
+                scaled_h = int(template_grad_base.shape[0] * scale)
+                
+                if scaled_w <= 0 or scaled_h <= 0 or scaled_w > roi_grad.shape[1] or scaled_h > roi_grad.shape[0]:
+                    continue
+                
+                scaled_template = cv2.resize(template_grad_base, (scaled_w, scaled_h), interpolation=cv2.INTER_AREA)
+
+                result = cv2.matchTemplate(roi_grad, scaled_template, cv2.TM_CCOEFF_NORMED)
+                _, max_val, _, max_loc = cv2.minMaxLoc(result)
+
+                if max_val > best_match_val:
+                    best_match_val = max_val
+                    best_box = (x + max_loc[0], y + max_loc[1], scaled_w, scaled_h)
+
+            if best_match_val >= threshold and best_box is not None:
+                matched_boxes.append(best_box)
+
+        return matched_boxes

teody_vision-0.1.0/teody_vision/tensor.py

@@ -0,0 +1,51 @@
+import cv2
+import numpy as np
+
+class TEODYTensorEngine:
+    def __init__(self, block_size: int = 3, k: float = 0.04):
+        self.block_size = block_size
+        self.k = k
+
+    def compute_structure_tensor(self, frame: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Calculates spatial image derivatives and structure tensor components."""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if len(frame.shape) == 3 else frame
+        
+        # Spatial gradients using Sobel operators
+        Ix = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
+        Iy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
+        
+        # Structure tensor elements
+        Ixx = Ix * Ix
+        Iyy = Iy * Iy
+        Ixy = Ix * Iy
+        
+        # Smooth components over the local neighborhood
+        ksize = (self.block_size, self.block_size)
+        Sxx = cv2.GaussianBlur(Ixx, ksize, 0)
+        Syy = cv2.GaussianBlur(Iyy, ksize, 0)
+        Sxy = cv2.GaussianBlur(Ixy, ksize, 0)
+        
+        return Sxx, Syy, Sxy
+
+    def compute_coherence(self, frame: np.ndarray) -> np.ndarray:
+        """Computes anisotropic coherence map from structure tensor eigenvalues."""
+        Sxx, Syy, Sxy = self.compute_structure_tensor(frame)
+        
+        # Trace and determinant
+        trace = Sxx + Syy
+        det = (Sxx * Syy) - (Sxy ** 2)
+        
+        # Difference squared term for eigenvalues
+        diff = Sxx - Syy
+        lambda_diff_sq = (diff ** 2) + (4 * (Sxy ** 2))
+        lambda_diff = np.sqrt(np.maximum(lambda_diff_sq, 0))
+        
+        # Eigenvalues
+        lambda1 = 0.5 * (trace + lambda_diff)
+        lambda2 = 0.5 * (trace - lambda_diff)
+        
+        # Anisotropic coherence metric (normalized difference)
+        denom = lambda1 + lambda2 + 1e-6
+        coherence = (lambda1 - lambda2) / denom
+        
+        return np.clip(coherence * 255, 0, 255).astype(np.uint8)

teody_vision-0.1.0/teody_vision/topology.py

@@ -0,0 +1,27 @@
+import cv2
+import numpy as np
+
+class TEODYTopologyEngine:
+    def __init__(self, min_width: int = 10, min_height: int = 6):
+        self.min_width = min_width
+        self.min_height = min_height
+
+    def extract_regions(self, coherence_map: np.ndarray) -> list[tuple[int, int, int, int]]:
+        """Isolates UI text and layout boundaries via morphological operations and contour analysis."""
+        # Binarize coherence map
+        _, thresh = cv2.threshold(coherence_map, 40, 255, cv2.THRESH_BINARY)
+        
+        # Morphological closing to connect nearby character strokes and text components
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 3))
+        closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+        
+        # Find external contours
+        contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        regions = []
+        for cnt in contours:
+            x, y, w, h = cv2.boundingRect(cnt)
+            if w >= self.min_width and h >= self.min_height:
+                regions.append((x, y, w, h))
+                
+        return regions

teody_vision-0.1.0/teody_vision.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: teody-vision
+Version: 0.1.0
+Summary: A deterministic, non-neural topological tensor framework for real-time UI text and field localization.
+Author-email: Teody Arboneda Banagan <teody882011@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: opencv-python>=4.5.0
+Requires-Dist: mss>=9.0.0
+Dynamic: license-file

teody_vision-0.1.0/teody_vision.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+teody_vision/__init__.py
+teody_vision/core.py
+teody_vision/matcher.py
+teody_vision/tensor.py
+teody_vision/topology.py
+teody_vision.egg-info/PKG-INFO
+teody_vision.egg-info/SOURCES.txt
+teody_vision.egg-info/dependency_links.txt
+teody_vision.egg-info/requires.txt
+teody_vision.egg-info/top_level.txt
+tests/test_engine.py

teody_vision-0.1.0/teody_vision.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

teody_vision-0.1.0/teody_vision.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.21.0
+opencv-python>=4.5.0
+mss>=9.0.0

teody_vision-0.1.0/teody_vision.egg-info/top_level.txt

@@ -0,0 +1 @@
+teody_vision

teody_vision-0.1.0/tests/test_engine.py

@@ -0,0 +1,80 @@
+"""
+TEODY-Vision: Automated Unit Test Suite
+File: tests/test_engine.py
+"""
+
+import unittest
+import numpy as np
+import cv2
+from teody_vision import TEODYTensorEngine, TEODYTopologyEngine, TEODYMatcher
+
+class TestTEODYVisionEngine(unittest.TestCase):
+    """Test cases for core TEODY-Vision non-neural computer vision components."""
+
+    def setUp(self):
+        """Set up synthetic test images simulating UI screens with text and borders."""
+        self.tensor_engine = TEODYTensorEngine(sigma=1.0, rho=2.0)
+        self.topology_engine = TEODYTopologyEngine(min_width=10, min_height=5)
+        
+        # Create a blank 300x300 grayscale synthetic UI screen canvas
+        self.synthetic_screen = np.full((300, 300), 255, dtype=np.uint8)
+        
+        # Draw a simulated UI box (representing a button or input field)
+        cv2.rectangle(self.synthetic_screen, (50, 50), (180, 90), 0, 2)
+        
+        # Draw simulated text/label inside the box
+        cv2.putText(self.synthetic_screen, "Login", (60, 78), cv2.FONT_HERSHEY_SIMPLEX, 0.7, 0, 2, cv2.LINE_AA)
+
+    def test_tensor_anisotropy_computation(self):
+        """Test that the structure tensor computes anisotropic coherence maps successfully."""
+        coherence_map = self.tensor_engine.compute_anisotropic_coherence(self.synthetic_screen)
+        
+        # Verify output dimensions match input frame
+        self.assertEqual(coherence_map.shape, self.synthetic_screen.shape)
+        # Verify output is an 8-bit unsigned integer array
+        self.assertEqual(coherence_map.dtype, np.uint8)
+        # Verify that tensor values detect high-contrast edges (max coherence > 0)
+        self.assertGreater(np.max(coherence_map), 0)
+
+    def test_topology_boundary_extraction(self):
+        """Test that topological morphology isolates UI text and field bounding boxes."""
+        coherence_map = self.tensor_engine.compute_anisotropic_coherence(self.synthetic_screen)
+        regions = self.topology_engine.extract_field_boundaries(coherence_map)
+        
+        # Verify that regions are returned as a list
+        self.assertIsInstance(regions, list)
+        # Verify that at least one valid bounding box was detected around our simulated UI elements
+        self.assertGreater(len(regions), 0, "Failed to isolate any structural UI regions.")
+        
+        # Check that bounding box tuples have 4 elements (x, y, w, h)
+        for box in regions:
+            self.assertEqual(len(box), 4)
+            x, y, w, h = box
+            self.assertGreater(w, 0)
+            self.assertGreater(h, 0)
+
+    def test_deterministic_matcher(self):
+        """Test that template matching successfully locates a target word within extracted regions."""
+        # Generate a synthetic template for the word "Login"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        (tw, th), _ = cv2.getTextSize("Login", font, 0.7, 2)
+        template = np.full((th + 10, tw + 10), 255, dtype=np.uint8)
+        cv2.putText(template, "Login", (5, th + 5), font, 0.7, 0, 2, cv2.LINE_AA)
+
+        # Extract regions from synthetic screen
+        coherence_map = self.tensor_engine.compute_anisotropic_coherence(self.synthetic_screen)
+        regions = self.topology_engine.extract_field_boundaries(coherence_map)
+
+        # Run matcher
+        matches = TEODYMatcher.match_template_in_regions(self.synthetic_screen, template, regions, threshold=0.75)
+        
+        # Verify matching behavior
+        self.assertIsInstance(matches, list)
+        if len(matches) > 0:
+            mx, my, mw, mh = matches[0]
+            self.assertGreaterEqual(mw, tw)
+            self.assertGreaterEqual(mh, th)
+
+
+if __name__ == "__main__":
+    unittest.main()