lannotex 0.1.0__py3-none-any.whl

lannotex/canvas.py

@@ -0,0 +1,289 @@
+"""Native canvas. Geometry lives in the document, never in disposable graphics items."""
+from copy import deepcopy
+import math
+from PySide6.QtCore import QPointF, QRectF, Qt, Signal
+from PySide6.QtGui import QColor, QFont, QPainter, QPen, QPolygonF
+from PySide6.QtWidgets import QWidget
+from .domain import Annotation, validate
+
+
+class Canvas(QWidget):
+    edited = Signal(object)
+    selected = Signal(object)
+    zoomed = Signal(int)
+    message = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.setMouseTracking(True)
+        self.setMinimumSize(280, 200)
+        self.setAccessibleName('Image annotation canvas')
+        self.image = None
+        self.annotations = []
+        self.colors = {}
+        self.label = ''
+        self.mode = 'select'
+        self.selection = None
+        self.vertex = None
+        self.opacity = .15
+        self.zoom = 1.
+        self.pan = QPointF()
+        self.points = []
+        self.drag = None
+        self.preview = None
+        self.redraw_id = None
+        self.space = False
+        self.empty_title = 'Your next dataset starts here'
+        self.empty_detail = 'Create or open a project, then import your images.'
+
+    def set_image(self, image):
+        self.cancel()
+        self.image = image
+        self.fit()
+
+    def set_annotations(self, annotations):
+        self.annotations = deepcopy(annotations)
+        if not any(a.id == self.selection for a in annotations): self.select(None)
+        self.update()
+
+    def set_mode(self, mode):
+        self.cancel()
+        self.mode = mode
+        self.setCursor(Qt.CrossCursor if mode in ('box', 'polygon') else Qt.ArrowCursor)
+        self.setFocus()
+
+    def select(self, ident):
+        self.selection = ident
+        self.vertex = None
+        self.selected.emit(ident)
+        self.update()
+
+    def fit(self):
+        self.zoom = 1.
+        self.pan = QPointF()
+        self.zoomed.emit(100)
+        self.update()
+
+    def image_rect(self):
+        if self.image is None: return QRectF()
+        w, h = self.image.width(), self.image.height()
+        scale = min(max(1, self.width()-64)/w, max(1, self.height()-64)/h)*self.zoom
+        return QRectF((self.width()-w*scale)/2+self.pan.x(), (self.height()-h*scale)/2+self.pan.y(), w*scale, h*scale)
+
+    def screen(self, p):
+        r = self.image_rect()
+        return QPointF(r.left()+p[0]*r.width(), r.top()+p[1]*r.height())
+
+    def normalized(self, p):
+        r = self.image_rect()
+        return [max(0., min(1., (p.x()-r.left())/max(1,r.width()))), max(0., min(1., (p.y()-r.top())/max(1,r.height())))]
+
+    @staticmethod
+    def vertices(a):
+        if a.kind == 'polygon': return a.geometry
+        if a.kind == 'box':
+            x,y,r,b = a.geometry
+            return [[x,y],[r,y],[r,b],[x,b]]
+        return []
+
+    def sized_font(self, points, weight=QFont.Normal):
+        font = QFont(self.font())
+        font.setPointSize(points)
+        font.setWeight(weight)
+        return font
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), self.palette().base())
+        painter.setRenderHint(QPainter.Antialiasing)
+        if self.image is None:
+            painter.setPen(self.palette().text().color())
+            painter.setFont(self.sized_font(20, QFont.DemiBold))
+            painter.drawText(self.rect().adjusted(24,-30,-24,-30), Qt.AlignCenter, self.empty_title)
+            painter.setFont(self.sized_font(10))
+            painter.drawText(self.rect().adjusted(24,50,-24,50), Qt.AlignCenter | Qt.TextWordWrap, self.empty_detail)
+            return
+        r = self.image_rect()
+        painter.setRenderHint(QPainter.SmoothPixmapTransform, self.zoom < 2)
+        painter.drawImage(r, self.image)
+        painter.setClipRect(r)
+        shown = self.preview if self.preview is not None else self.annotations
+        for n, a in enumerate(shown, 1):
+            pts = self.vertices(a)
+            if not pts: continue
+            color = QColor(self.colors.get(a.label, '#38bfa7'))
+            selected = a.id == self.selection
+            painter.setPen(QPen(color, 2.4 if selected else 1.5))
+            fill = QColor(color); fill.setAlphaF(self.opacity)
+            painter.setBrush(fill)
+            poly = QPolygonF([self.screen(p) for p in pts])
+            painter.drawPolygon(poly)
+            anchor = poly.boundingRect().topLeft()
+            text = f'{n}  {a.label}'
+            painter.setFont(self.sized_font(9, QFont.DemiBold))
+            width = painter.fontMetrics().horizontalAdvance(text)+14
+            badge = QRectF(anchor.x(), max(r.top(), anchor.y()-23), width, 22)
+            painter.fillRect(badge, color)
+            painter.setPen(QColor('#101820'))
+            painter.drawText(badge, Qt.AlignCenter, text)
+            if selected:
+                for i, p in enumerate(poly):
+                    painter.setPen(QPen(color, 1.5))
+                    painter.setBrush(QColor('#f4f8fc') if i != self.vertex else QColor('#f4ba58'))
+                    painter.drawRect(QRectF(p.x()-4,p.y()-4,8,8))
+        painter.setClipping(False)
+        if self.points:
+            painter.setPen(QPen(QColor('#f4ba58'), 2, Qt.DashLine))
+            painter.setBrush(Qt.NoBrush)
+            painter.drawPolyline(QPolygonF([self.screen(p) for p in self.points]))
+            for p in self.points:
+                painter.setBrush(QColor('#f4ba58')); painter.drawEllipse(self.screen(p), 3.5, 3.5)
+
+    def wheelEvent(self, event):
+        if self.image is None: return
+        before = self.image_rect()
+        pos = event.position()
+        u = (pos.x()-before.x())/before.width()
+        v = (pos.y()-before.y())/before.height()
+        self.zoom = max(.1, min(32., self.zoom * (1.15 if event.angleDelta().y()>0 else 1/1.15)))
+        after = self.image_rect()
+        self.pan += QPointF(pos.x()-(after.x()+u*after.width()), pos.y()-(after.y()+v*after.height()))
+        self.zoomed.emit(round(self.zoom*100))
+        self.update()
+
+    def mousePressEvent(self, event):
+        self.setFocus()
+        if self.image is None: return
+        if event.button() == Qt.MiddleButton or (self.space and event.button() == Qt.LeftButton):
+            self.drag = {'kind':'pan','start':event.position(),'pan':QPointF(self.pan)}
+            self.setCursor(Qt.ClosedHandCursor)
+            return
+        if event.button() != Qt.LeftButton or not self.image_rect().contains(event.position()): return
+        p = self.normalized(event.position())
+        if self.mode in ('box','polygon'):
+            if not self.label:
+                self.message.emit('Add and select a label before drawing.'); return
+            if self.mode == 'polygon':
+                if len(self.points) >= 1000: self.message.emit('A polygon supports up to 1000 vertices.'); return
+                self.points.append(p); self.update(); return
+            self.drag = {'kind':'draw','start':p}
+            return
+        chosen = next((a for a in self.annotations if a.id == self.selection), None)
+        if chosen:
+            for i, vertex in enumerate(self.vertices(chosen)):
+                q = self.screen(vertex)
+                if math.hypot(q.x()-event.position().x(),q.y()-event.position().y()) < 10:
+                    self.vertex = i
+                    self.drag = {'kind':'vertex','start':p,'original':deepcopy(chosen),'vertex':i}
+                    self.update(); return
+        for a in reversed(self.annotations):
+            if QPolygonF([self.screen(v) for v in self.vertices(a)]).containsPoint(event.position(), Qt.OddEvenFill):
+                self.select(a.id)
+                self.drag = {'kind':'move','start':p,'original':deepcopy(a)}
+                return
+        self.select(None)
+
+    def mouseMoveEvent(self, event):
+        if not self.drag: return
+        d = self.drag
+        if d['kind'] == 'pan':
+            self.pan = d['pan']+event.position()-d['start']; self.update(); return
+        p = self.normalized(event.position())
+        if d['kind'] == 'draw':
+            x,y = d['start']
+            a = Annotation(self.label, 'box', [min(x,p[0]),min(y,p[1]),max(x,p[0]),max(y,p[1])])
+            if self.redraw_id: a.id = self.redraw_id
+            self.preview = [b for b in self.annotations if b.id != a.id]+[a]
+        else:
+            a = deepcopy(d['original'])
+            if d['kind'] == 'move':
+                pts = self.vertices(a)
+                dx = max(-min(v[0] for v in pts),min(1-max(v[0] for v in pts),p[0]-d['start'][0]))
+                dy = max(-min(v[1] for v in pts),min(1-max(v[1] for v in pts),p[1]-d['start'][1]))
+                if a.kind == 'box': a.geometry = [a.geometry[0]+dx,a.geometry[1]+dy,a.geometry[2]+dx,a.geometry[3]+dy]
+                else: a.geometry = [[v[0]+dx,v[1]+dy] for v in pts]
+            elif a.kind == 'polygon': a.geometry[d['vertex']] = p
+            else:
+                opposite = self.vertices(a)[(d['vertex']+2)%4]
+                a.geometry = [min(p[0],opposite[0]),min(p[1],opposite[1]),max(p[0],opposite[0]),max(p[1],opposite[1])]
+            self.preview = [a if b.id == a.id else b for b in self.annotations]
+        self.update()
+
+    def mouseReleaseEvent(self, event):
+        if not self.drag: return
+        kind = self.drag['kind']
+        self.drag = None
+        if kind == 'pan': self.setCursor(Qt.OpenHandCursor if self.space else Qt.ArrowCursor); return
+        if self.preview is not None:
+            errors = [error for a in self.preview for error in validate(a,set(self.colors))]
+            if errors: self.message.emit(errors[0])
+            else:
+                if kind == 'draw': self.selection = self.preview[-1].id
+                self.edited.emit(deepcopy(self.preview))
+                self.selected.emit(self.selection)
+                self.redraw_id = None
+        self.preview = None
+        self.update()
+
+    def finish_polygon(self):
+        if not self.points: return
+        a = Annotation(self.label,'polygon',deepcopy(self.points))
+        if self.redraw_id: a.id = self.redraw_id
+        errors = validate(a, set(self.colors))
+        if errors: self.message.emit(errors[0]); return
+        self.selection = a.id
+        self.edited.emit([b for b in self.annotations if b.id != a.id]+[a])
+        self.selected.emit(a.id)
+        self.points = []; self.redraw_id = None; self.update()
+
+    def mouseDoubleClickEvent(self, event):
+        if self.mode != 'select' or self.image is None: return
+        a = next((deepcopy(x) for x in self.annotations if x.id == self.selection and x.kind == 'polygon'), None)
+        if a is None: return
+        pos = event.position(); best = None
+        for i, (p,q) in enumerate(zip(a.geometry,a.geometry[1:]+a.geometry[:1])):
+            u,v = self.screen(p),self.screen(q)
+            dx,dy = v.x()-u.x(),v.y()-u.y()
+            t = max(0,min(1,((pos.x()-u.x())*dx+(pos.y()-u.y())*dy)/max(1e-8,dx*dx+dy*dy)))
+            distance = math.hypot(pos.x()-u.x()-t*dx,pos.y()-u.y()-t*dy)
+            if best is None or distance < best[0]: best = (distance,i,[p[0]+t*(q[0]-p[0]),p[1]+t*(q[1]-p[1])])
+        if best and best[0] < 12:
+            a.geometry.insert(best[1]+1,best[2])
+            if not validate(a,set(self.colors)): self.edited.emit([a if b.id==a.id else b for b in self.annotations])
+        self.drag = None
+
+    def delete_vertex(self):
+        a = next((deepcopy(x) for x in self.annotations if x.id == self.selection and x.kind=='polygon'), None)
+        if a is None or self.vertex is None: return
+        if len(a.geometry) <= 3: self.message.emit('A polygon must retain at least three vertices.'); return
+        a.geometry.pop(self.vertex)
+        errors = validate(a,set(self.colors))
+        if errors: self.message.emit(errors[0]); return
+        self.vertex = None
+        self.edited.emit([a if b.id==a.id else b for b in self.annotations])
+
+    def redraw(self):
+        a = next((x for x in self.annotations if x.id == self.selection and x.kind != 'classification'), None)
+        if a:
+            self.set_mode(a.kind); self.redraw_id = a.id; self.label = a.label
+            self.message.emit('Draw the replacement. Escape keeps the original annotation.')
+
+    def cancel(self):
+        self.points = []; self.drag = None; self.preview = None; self.redraw_id = None
+        self.update()
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key_Space:
+            self.space = True; self.setCursor(Qt.OpenHandCursor); event.accept(); return
+        super().keyPressEvent(event)
+
+    def keyReleaseEvent(self, event):
+        if event.key() == Qt.Key_Space:
+            self.space = False; self.setCursor(Qt.ArrowCursor); event.accept(); return
+        super().keyReleaseEvent(event)
+
+    def focusOutEvent(self, event):
+        self.space = False
+        if self.drag: self.cancel()
+        super().focusOutEvent(event)

lannotex/cli.py

@@ -0,0 +1,97 @@
+"""Lannotex command-line interface.
+
+Running bare ``lannotex`` launches the desktop application. Subcommands
+(``export``, ``analyze``, ``new``) run headlessly for automation and CI and
+do not import Qt.
+"""
+from __future__ import annotations
+import argparse
+import json
+import sys
+from pathlib import Path
+import threading
+
+from . import __version__
+
+EXPORT_FORMATS = ['Labelme JSON', 'YOLO boxes', 'COCO JSON', 'Classification CSV', 'Native JSONL']
+
+
+def _progress(value, message):
+    print(f'[{value:3d}%] {message}', file=sys.stderr)
+
+
+def _cancel():
+    return threading.Event()
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog='lannotex',
+        description='Fast, offline-first image annotation for classifications, boxes, and polygons.',
+    )
+    parser.add_argument('--version', action='version', version=f'%(prog)s {__version__}')
+    sub = parser.add_subparsers(dest='command')
+
+    gui = sub.add_parser('gui', help='launch the desktop application (this is the default)')
+    gui.add_argument('--smoke-test', action='store_true', help=argparse.SUPPRESS)
+
+    exp = sub.add_parser('export', help='export a project headlessly to a local directory')
+    exp.add_argument('project', help='project folder that contains project.sqlite3')
+    exp.add_argument('destination', help='directory that receives the exported files')
+    exp.add_argument('--format', choices=EXPORT_FORMATS, default='Labelme JSON', help='export format (default: %(default)s)')
+
+    ana = sub.add_parser('analyze', help='validate a project and print a health report as JSON')
+    ana.add_argument('project', help='project folder that contains project.sqlite3')
+
+    proj = sub.add_parser('new', help='create a new empty project folder')
+    proj.add_argument('folder', help='folder to initialize as a project')
+
+    host = sub.add_parser('host', help='serve a team project from this computer')
+    host.add_argument('project')
+    host.add_argument('--bind', default='127.0.0.1', help='use 0.0.0.0 to accept LAN connections')
+    host.add_argument('--port', type=int, default=8765)
+    host.add_argument('--cert', help='TLS certificate PEM')
+    host.add_argument('--key', help='TLS private key PEM')
+    invite = sub.add_parser('invite', help='create a reviewer token on a project host')
+    invite.add_argument('project')
+    invite.add_argument('name')
+
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    if args.command in (None, 'gui'):
+        from .app import main as gui_main
+        return gui_main()
+    if args.command == 'export':
+        from .exporters import export_project
+        result = export_project(args.project, args.destination, args.format, _cancel(), _progress)
+        print(f"Exported {result['included']} images to {result['path']}")
+        if result['errors']:
+            print('Errors:', file=sys.stderr)
+            print('\n'.join(result['errors']), file=sys.stderr)
+        return 0
+    if args.command == 'analyze':
+        from .exporters import analyze
+        result = analyze(args.project, _cancel(), _progress)
+        print(json.dumps(result, indent=2))
+        return 0
+    if args.command == 'new':
+        from .storage import Project
+        Project(args.folder, create=True).close()
+        print(f'Created project at {Path(args.folder).resolve()}')
+        return 0
+    if args.command == 'invite':
+        from .team import add_member
+        print(add_member(args.project, args.name))
+        return 0
+    if args.command == 'host':
+        from .team import TeamServer
+        server = TeamServer(args.project,args.bind,args.port,args.cert,args.key)
+        print(f"Team host listening on {args.bind}:{server.server_address[1]}. Ctrl+C stops hosting.")
+        try: server.serve_forever()
+        except KeyboardInterrupt: pass
+        finally: server.server_close()
+        return 0
+    return 0

lannotex/domain.py

@@ -0,0 +1,119 @@
+"""Annotation invariants and reversible document changes; no Qt or file I/O."""
+from __future__ import annotations
+from copy import deepcopy
+from dataclasses import asdict, dataclass, field
+import math
+import uuid
+
+
+@dataclass
+class Annotation:
+    label: str
+    kind: str
+    geometry: list = field(default_factory=list)
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    def to_dict(self):
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(data['label'], data['kind'], deepcopy(data.get('geometry', [])), data['id'])
+
+
+def finite_unit(n):
+    return isinstance(n, (float, int)) and not isinstance(n, bool) and math.isfinite(n) and 0 <= n <= 1
+
+
+def box_valid(box):
+    return (isinstance(box, list) and len(box) == 4 and all(finite_unit(n) for n in box)
+            and box[2] - box[0] > 1e-8 and box[3] - box[1] > 1e-8)
+
+
+def polygon_area(points):
+    return abs(sum(a[0]*b[1] - b[0]*a[1] for a, b in zip(points, points[1:]+points[:1]))) / 2
+
+
+def polygon_self_intersects(points):
+    def cross(a, b, c):
+        return (b[0]-a[0])*(c[1]-a[1]) - (b[1]-a[1])*(c[0]-a[0])
+
+    def on(a, b, c):
+        return (abs(cross(a, b, c)) < 1e-12 and min(a[0], b[0])-1e-12 <= c[0] <= max(a[0], b[0])+1e-12
+                and min(a[1], b[1])-1e-12 <= c[1] <= max(a[1], b[1])+1e-12)
+
+    n = len(points)
+    for i in range(n):
+        a, b = points[i], points[(i+1) % n]
+        for j in range(i+1, n):
+            if (i+1) % n == j or (j+1) % n == i: continue
+            c, d = points[j], points[(j+1) % n]
+            if (cross(a,b,c)*cross(a,b,d) < 0 and cross(c,d,a)*cross(c,d,b) < 0
+                    or on(a,b,c) or on(a,b,d) or on(c,d,a) or on(c,d,b)):
+                return True
+    return False
+
+
+def validate(a, labels):
+    errors = []
+    if not isinstance(a.id, str) or not a.id.strip(): errors.append('Missing annotation ID')
+    if a.label not in labels: errors.append(f'Unknown label: {a.label}')
+    if a.kind not in ('box', 'polygon', 'classification'): errors.append('Unknown annotation type')
+    if a.kind == 'box' and not box_valid(a.geometry): errors.append('Box must have positive size inside the image')
+    if a.kind == 'classification' and a.geometry: errors.append('Classification cannot contain geometry')
+    if a.kind == 'polygon':
+        pts = a.geometry
+        if not isinstance(pts, list) or not 3 <= len(pts) <= 1000:
+            errors.append('Polygon needs 3–1000 vertices')
+        elif any(not isinstance(p, list) or len(p) != 2 or not all(finite_unit(x) for x in p) for p in pts):
+            errors.append('Polygon vertices must be inside the image')
+        elif len({tuple(p) for p in pts}) != len(pts) or polygon_area(pts) < 1e-10:
+            errors.append('Polygon has duplicate vertices or zero area')
+        elif polygon_self_intersects(pts): errors.append('Polygon edges intersect')
+    return errors
+
+
+def validate_all(annotations, labels, negative=False):
+    errors, seen, classes = [], set(), set()
+    for a in annotations:
+        errors.extend(validate(a, labels))
+        if a.id in seen: errors.append(f'Duplicate annotation ID: {a.id}')
+        seen.add(a.id)
+        if a.kind == 'classification':
+            if a.label in classes: errors.append(f'Duplicate class: {a.label}')
+            classes.add(a.label)
+    if negative and annotations: errors.append('No-target images cannot contain annotations')
+    return errors
+
+
+class Document:
+    """One active image. History is bounded; persisted drafts survive navigation."""
+    def __init__(self, annotations=(), negative=False):
+        self.annotations = deepcopy(list(annotations))
+        self.negative = negative
+        self.undo_stack = []
+        self.redo_stack = []
+
+    def snapshot(self):
+        return deepcopy((self.annotations, self.negative))
+
+    def change(self, annotations, negative=False):
+        next_state = deepcopy((list(annotations), negative))
+        if self.snapshot() == next_state: return False
+        self.undo_stack.append(self.snapshot())
+        self.undo_stack = self.undo_stack[-100:]
+        self.redo_stack.clear()
+        self.annotations, self.negative = next_state
+        return True
+
+    def undo(self):
+        if not self.undo_stack: return False
+        self.redo_stack.append(self.snapshot())
+        self.annotations, self.negative = self.undo_stack.pop()
+        return True
+
+    def redo(self):
+        if not self.redo_stack: return False
+        self.undo_stack.append(self.snapshot())
+        self.annotations, self.negative = self.redo_stack.pop()
+        return True