nucleuskit-toolkit 2.2.0__py3-none-any.whl

nucleuskit_toolkit/tools/recording_merger.py

@@ -0,0 +1,437 @@
+"""Backend for the Recording Merger tool.
+
+Merges up to 5 recordings into a single session folder containing
+``results/`` (CSVs, time-shifted and null-padded) and ``rawData/``
+(video concatenated with black-screen gaps).
+
+FFmpeg and ffprobe must be available on PATH.
+"""
+
+from __future__ import annotations
+
+import queue
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+_RESULT_STEP = 0.5          # seconds per CSV sample (2 Hz)
+_VIDEO_CODEC = "libx264"
+_AUDIO_CODEC = "aac"
+_AUDIO_SR    = 44100
+_PIX_FMT     = "yuv420p"
+
+
+# ── logging helper ─────────────────────────────────────────────────────────────
+
+def _log(q: queue.SimpleQueue[str], msg: str) -> None:
+    q.put(msg + "\n")
+
+
+# ── dependency check ───────────────────────────────────────────────────────────
+
+def _require_ffmpeg() -> None:
+    for cmd in ("ffmpeg", "ffprobe"):
+        if shutil.which(cmd) is None:
+            raise FileNotFoundError(
+                f"'{cmd}' not found on PATH. "
+                "Install FFmpeg and make sure it is accessible from the command line "
+                "before using the Recording Merger."
+            )
+
+
+# ── ffprobe helpers ────────────────────────────────────────────────────────────
+
+def _ffprobe(*args: str) -> str:
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", *args],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout
+
+
+def _probe_duration(path: Path) -> float | None:
+    """Return video duration in seconds, or None on failure."""
+    try:
+        out = _ffprobe(
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            str(path),
+        )
+        return float(out.strip())
+    except (subprocess.CalledProcessError, ValueError):
+        return None
+
+
+def _probe_video_info(path: Path) -> dict:
+    """Return {width, height, fps, has_audio} for the given video file."""
+    info: dict = {
+        "width": 1920, "height": 1080,
+        "fps": 30.0,   "has_audio": False,
+    }
+    try:
+        out = _ffprobe(
+            "-show_streams",
+            "-show_entries",
+            "stream=width,height,r_frame_rate,codec_type",
+            "-of", "default=noprint_wrappers=1",
+            str(path),
+        )
+        for line in out.splitlines():
+            k, _, v = line.partition("=")
+            k, v = k.strip(), v.strip()
+            if k == "width" and v not in ("", "N/A"):
+                info["width"] = int(v)
+            elif k == "height" and v not in ("", "N/A"):
+                info["height"] = int(v)
+            elif k == "r_frame_rate" and v not in ("", "N/A"):
+                n, _, d = v.partition("/")
+                info["fps"] = float(n) / float(d) if d and d != "0" else float(n)
+            elif k == "codec_type" and v == "audio":
+                info["has_audio"] = True
+    except (subprocess.CalledProcessError, ValueError):
+        pass
+    return info
+
+
+# ── duration resolution ────────────────────────────────────────────────────────
+
+def _resolve_duration(folder: Path, log_q: queue.SimpleQueue[str]) -> float:
+    """Return recording duration (s): ffprobe video first, fall back to CSV max timestamp."""
+    video = folder / "rawData" / "video.mp4"
+    if video.exists():
+        dur = _probe_duration(video)
+        if dur is not None:
+            return dur
+        _log(log_q, f"  [warn] ffprobe failed for {video.name}; falling back to CSVs.")
+
+    results_dir = folder / "results"
+    max_ts = 0.0
+    found = False
+    if results_dir.is_dir():
+        for csv_path in results_dir.glob("*.csv"):
+            try:
+                df = pd.read_csv(csv_path, usecols=["Timestamp"])
+                if not df.empty:
+                    max_ts = max(max_ts, float(df["Timestamp"].max()))
+                    found = True
+            except Exception:
+                pass
+    if found:
+        return max_ts + _RESULT_STEP
+
+    _log(log_q, f"  [warn] Cannot determine duration for {folder.name!r}; defaulting to 0 s.")
+    return 0.0
+
+
+# ── CSV merging ────────────────────────────────────────────────────────────────
+
+def _collect_csv_names(folders: list[Path]) -> list[str]:
+    """Union of *.csv names found in any recording's results/ folder."""
+    names: set[str] = set()
+    for folder in folders:
+        rd = folder / "results"
+        if rd.is_dir():
+            for p in rd.glob("*.csv"):
+                names.add(p.name)
+    return sorted(names)
+
+
+def _merge_csvs(
+    folders: list[Path],
+    durations: list[float],
+    shifts: list[float],
+    offsets: list[float],
+    output_results: Path,
+    log_q: queue.SimpleQueue[str],
+) -> None:
+    csv_names = _collect_csv_names(folders)
+    if not csv_names:
+        _log(log_q, "[csv] No result CSVs found in any recording — skipping.")
+        return
+
+    for name in csv_names:
+        _log(log_q, f"[csv] {name}")
+
+        # Determine the union of data columns from all recordings that have this file
+        data_cols: list[str] = []
+        seen: set[str] = set()
+        for folder in folders:
+            p = folder / "results" / name
+            if p.exists():
+                try:
+                    header = pd.read_csv(p, nrows=0)
+                    for col in header.columns:
+                        if col != "Timestamp" and col not in seen:
+                            data_cols.append(col)
+                            seen.add(col)
+                except Exception:
+                    pass
+
+        if not data_cols:
+            _log(log_q, f"  [warn] Could not determine columns — skipping {name}.")
+            continue
+
+        segments: list[pd.DataFrame] = []
+
+        for i, folder in enumerate(folders):
+            shift = shifts[i]
+            dur   = durations[i]
+            p     = folder / "results" / name
+
+            loaded = False
+            if p.exists():
+                try:
+                    df = pd.read_csv(p)
+                    for col in data_cols:
+                        if col not in df.columns:
+                            df[col] = np.nan
+                    df = df[["Timestamp"] + data_cols].copy()
+                    df["Timestamp"] += shift
+                    segments.append(df)
+                    loaded = True
+                except Exception as exc:
+                    _log(log_q, f"  [warn] Read error in recording {i + 1}: {exc}")
+
+            if not loaded and dur > 0:
+                ts_arr = np.arange(0.0, dur, _RESULT_STEP) + shift
+                null_df = pd.DataFrame({"Timestamp": ts_arr})
+                for col in data_cols:
+                    null_df[col] = np.nan
+                segments.append(null_df)
+
+            # Null-padded gap before the next recording
+            if i < len(folders) - 1 and offsets[i] > 0:
+                gap_start = shift + dur
+                gap_end   = shifts[i + 1]
+                if gap_end > gap_start + _RESULT_STEP * 0.5:
+                    ts_arr = np.arange(gap_start, gap_end, _RESULT_STEP)
+                    null_df = pd.DataFrame({"Timestamp": ts_arr})
+                    for col in data_cols:
+                        null_df[col] = np.nan
+                    segments.append(null_df)
+
+        if not segments:
+            continue
+
+        merged = pd.concat(segments, ignore_index=True)
+        merged = merged.sort_values("Timestamp").reset_index(drop=True)
+        out_path = output_results / name
+        merged.to_csv(out_path, index=False)
+        _log(log_q, f"  → {len(merged)} rows  ({out_path.name})")
+
+
+# ── video merging ──────────────────────────────────────────────────────────────
+
+def _ffmpeg(*args: str) -> None:
+    result = subprocess.run(
+        ["ffmpeg", "-y", *args],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise subprocess.CalledProcessError(
+            result.returncode, "ffmpeg", result.stdout, result.stderr
+        )
+
+
+def _encode_to_ref(
+    src: Path,
+    dst: Path,
+    src_has_audio: bool,
+    width: int,
+    height: int,
+    fps: float,
+    ref_has_audio: bool,
+    log_q: queue.SimpleQueue[str],
+) -> None:
+    """Re-encode a source video clip to the reference format."""
+    _log(log_q, f"  encode  {src.name} → {dst.name}")
+    base_args = [
+        "-vf", f"scale={width}:{height}",
+        "-r", str(fps), "-vsync", "cfr",
+        "-c:v", _VIDEO_CODEC, "-pix_fmt", _PIX_FMT, "-preset", "fast",
+    ]
+    if ref_has_audio and src_has_audio:
+        _ffmpeg("-i", str(src), *base_args,
+                "-c:a", _AUDIO_CODEC, "-ar", str(_AUDIO_SR), str(dst))
+    elif ref_has_audio and not src_has_audio:
+        # Add a silent audio track alongside the video
+        _ffmpeg(
+            "-i", str(src),
+            "-f", "lavfi", "-i", f"anullsrc=r={_AUDIO_SR}:cl=stereo",
+            "-map", "0:v", "-map", "1:a",
+            *base_args,
+            "-c:a", _AUDIO_CODEC, "-ar", str(_AUDIO_SR),
+            str(dst),
+        )
+    else:
+        _ffmpeg("-i", str(src), *base_args, "-an", str(dst))
+
+
+def _make_black_clip(
+    dst: Path,
+    duration: float,
+    width: int,
+    height: int,
+    fps: float,
+    has_audio: bool,
+    log_q: queue.SimpleQueue[str],
+) -> None:
+    """Generate a black-screen clip of the given duration."""
+    _log(log_q, f"  black   {duration:.1f} s → {dst.name}")
+    lavfi_video = f"color=c=black:s={width}x{height}:r={fps}"
+    base_args = [
+        "-t", str(duration),
+        "-c:v", _VIDEO_CODEC, "-pix_fmt", _PIX_FMT, "-preset", "fast",
+    ]
+    if has_audio:
+        _ffmpeg(
+            "-f", "lavfi", "-i", lavfi_video,
+            "-f", "lavfi", "-i", f"anullsrc=r={_AUDIO_SR}:cl=stereo",
+            "-map", "0:v", "-map", "1:a",
+            *base_args,
+            "-c:a", _AUDIO_CODEC, "-ar", str(_AUDIO_SR),
+            str(dst),
+        )
+    else:
+        _ffmpeg(
+            "-f", "lavfi", "-i", lavfi_video,
+            *base_args, "-an",
+            str(dst),
+        )
+
+
+def _merge_videos(
+    folders: list[Path],
+    durations: list[float],
+    offsets: list[float],
+    output_rawdata: Path,
+    log_q: queue.SimpleQueue[str],
+) -> None:
+    video_paths = [folder / "rawData" / "video.mp4" for folder in folders]
+    has_videos  = [p.exists() for p in video_paths]
+
+    if not any(has_videos):
+        _log(log_q, "[video] No video files found in any recording — skipping.")
+        return
+
+    # Use recording 1's video as reference; fall back to first available if rec 1 has none
+    ref_idx  = 0 if has_videos[0] else next(i for i, h in enumerate(has_videos) if h)
+    ref_info = _probe_video_info(video_paths[ref_idx])
+    W, H     = ref_info["width"], ref_info["height"]
+    fps      = ref_info["fps"]
+    has_audio = ref_info["has_audio"]
+    _log(log_q, f"[video] Reference: {W}×{H} @ {fps:.3f} fps  audio={has_audio}")
+
+    with tempfile.TemporaryDirectory() as tmp_str:
+        tmp        = Path(tmp_str)
+        clip_paths: list[Path] = []
+
+        for i in range(len(folders)):
+            clip_dst = tmp / f"clip_{i:02d}.mp4"
+            if has_videos[i]:
+                src_info = _probe_video_info(video_paths[i])
+                _encode_to_ref(
+                    video_paths[i], clip_dst,
+                    src_info["has_audio"],
+                    W, H, fps, has_audio, log_q,
+                )
+            else:
+                _make_black_clip(clip_dst, durations[i], W, H, fps, has_audio, log_q)
+            clip_paths.append(clip_dst)
+
+            if i < len(folders) - 1 and offsets[i] > 0:
+                gap_dst = tmp / f"gap_{i:02d}.mp4"
+                _make_black_clip(gap_dst, offsets[i], W, H, fps, has_audio, log_q)
+                clip_paths.append(gap_dst)
+
+        concat_txt = tmp / "concat.txt"
+        concat_txt.write_text(
+            "".join(f"file '{p}'\n" for p in clip_paths),
+            encoding="utf-8",
+        )
+
+        out_video = output_rawdata / "video.mp4"
+        _log(log_q, f"[video] Concatenating {len(clip_paths)} clips → video.mp4")
+        _ffmpeg(
+            "-f", "concat", "-safe", "0",
+            "-i", str(concat_txt),
+            "-c", "copy",
+            str(out_video),
+        )
+        _log(log_q, f"[video] Done → {out_video}")
+
+
+# ── public API ─────────────────────────────────────────────────────────────────
+
+def merge_recordings(
+    folders: list[str],
+    offsets: list[float],
+    output_dir: str,
+    log_q: queue.SimpleQueue[str],
+    *,
+    skip_video: bool = False,
+) -> None:
+    """Merge N recordings into a single output folder.
+
+    Parameters
+    ----------
+    folders:
+        Absolute paths to recording root folders (1–5 items).
+    offsets:
+        Gap in seconds between consecutive recordings.
+        Must satisfy ``len(offsets) == len(folders) - 1``.
+    output_dir:
+        Destination root; created automatically if absent.
+    log_q:
+        Thread-safe queue for log messages displayed in the UI.
+    skip_video:
+        When True, skip the video merge step entirely.
+    """
+    if not skip_video:
+        _require_ffmpeg()
+
+    fpaths      = [Path(f) for f in folders]
+    output      = Path(output_dir)
+    out_results = output / "results"
+    out_rawdata = output / "rawData"
+    out_results.mkdir(parents=True, exist_ok=True)
+    out_rawdata.mkdir(parents=True, exist_ok=True)
+
+    _log(log_q, f"Output folder: {output}\n")
+
+    # ── durations ──────────────────────────────────────────────────────────────
+    _log(log_q, "=== Resolving durations ===")
+    durations: list[float] = []
+    for i, fp in enumerate(fpaths):
+        dur = _resolve_duration(fp, log_q)
+        durations.append(dur)
+        _log(log_q, f"  [{i + 1}] {fp.name!r}:  {dur:.2f} s")
+    _log(log_q, "")
+
+    # Cumulative start time of each recording in merged time
+    shifts: list[float] = [0.0]
+    for i in range(len(fpaths) - 1):
+        shifts.append(shifts[-1] + durations[i] + offsets[i])
+
+    # ── CSVs ───────────────────────────────────────────────────────────────────
+    _log(log_q, "=== Merging result CSVs ===")
+    _merge_csvs(fpaths, durations, shifts, offsets, out_results, log_q)
+    _log(log_q, "")
+
+    # ── video ──────────────────────────────────────────────────────────────────
+    _log(log_q, "=== Merging video ===")
+    if skip_video:
+        _log(log_q, "[video] Skipped by user.")
+    else:
+        _merge_videos(fpaths, durations, offsets, out_rawdata, log_q)
+    _log(log_q, "")
+
+    _log(log_q, "=== Complete ===")
+    _log(log_q, f"Merged recording saved to:  {output}")

nucleuskit_toolkit/ui/__init__.py

@@ -0,0 +1 @@
+"""PySide6 desktop UI for nucleuskit-pipeline."""

nucleuskit_toolkit/ui/icons.py

@@ -0,0 +1,165 @@
+"""Line icons (24 x 24, stroke-based) rendered in any colour, plus a small spinner widget.
+
+The icons are drawn for Nucleus-Kit in the style of outline icon sets: 2 px strokes, round caps and joins.
+``icon(name, color)`` returns a QIcon; ``icon_file(name, color)`` writes an SVG to a cache folder for Qt
+style sheets (``image: url(...)``), which cannot load in-memory images.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+
+from PySide6.QtCore import QByteArray, QRectF, QSize, Qt, QTimer
+from PySide6.QtGui import QColor, QIcon, QPainter, QPen, QPixmap
+from PySide6.QtSvg import QSvgRenderer
+from PySide6.QtWidgets import QSizePolicy, QWidget
+
+_PATHS: dict[str, str] = {
+    "activity": '<polyline points="22 12 18 12 15 21 9 3 6 12 2 12"/>',
+    "play": '<polygon points="7 4 20 12 7 20 7 4"/>',
+    "square": '<rect x="6" y="6" width="12" height="12" rx="1.5"/>',
+    "settings": (
+        '<circle cx="12" cy="12" r="3"/>'
+        '<path d="M12 2.5v3M12 18.5v3M2.5 12h3M18.5 12h3M5.3 5.3l2.1 2.1M16.6 16.6l2.1 2.1'
+        'M5.3 18.7l2.1-2.1M16.6 7.4l2.1-2.1"/>'
+        '<circle cx="12" cy="12" r="6.5"/>'
+    ),
+    "book": (
+        '<path d="M2 4.5h6a4 4 0 0 1 4 4V21a3 3 0 0 0-3-3H2z"/>'
+        '<path d="M22 4.5h-6a4 4 0 0 0-4 4V21a3 3 0 0 1 3-3h7z"/>'
+    ),
+    "info": '<circle cx="12" cy="12" r="9.5"/><path d="M12 16.5v-5M12 7.5h.01"/>',
+    "help": (
+        '<circle cx="12" cy="12" r="9.5"/>'
+        '<path d="M9.2 9a3 3 0 0 1 5.8 1c0 2-3 2.5-3 4.5"/><path d="M12 17.5h.01"/>'
+    ),
+    "folder": '<path d="M3 6.5a2 2 0 0 1 2-2h4l2 2.5h8a2 2 0 0 1 2 2V18a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>',
+    "database": (
+        '<ellipse cx="12" cy="5.5" rx="8" ry="3"/>'
+        '<path d="M4 5.5v13c0 1.7 3.6 3 8 3s8-1.3 8-3v-13"/><path d="M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>'
+    ),
+    "file-text": (
+        '<path d="M14 2.5H6a2 2 0 0 0-2 2v15a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8.5z"/>'
+        '<path d="M14 2.5v6h6M8 13h8M8 17h8M8 9h2"/>'
+    ),
+    "trash": (
+        '<path d="M3 6h18M8 6V4a1 1 0 0 1 1-1h6a1 1 0 0 1 1 1v2"/>'
+        '<path d="M5.5 6l1 14a2 2 0 0 0 2 2h7a2 2 0 0 0 2-2l1-14M10 11v6M14 11v6"/>'
+    ),
+    "radio": (
+        '<circle cx="12" cy="12" r="2"/><path d="M16.2 7.8a6 6 0 0 1 0 8.4M7.8 16.2a6 6 0 0 1 0-8.4"/>'
+        '<path d="M19.1 4.9a10 10 0 0 1 0 14.2M4.9 19.1a10 10 0 0 1 0-14.2"/>'
+    ),
+    "film": (
+        '<rect x="3" y="3" width="18" height="18" rx="2"/>'
+        '<path d="M7 3v18M17 3v18M3 7.5h4M3 12h18M3 16.5h4M17 7.5h4M17 16.5h4"/>'
+    ),
+    "wrench": (
+        '<path d="M14.7 6.3a4 4 0 0 0 5.3 5.3l-8.8 8.8a2.1 2.1 0 0 1-3-3l8.8-8.8a4 4 0 0 1-5.3-5.3'
+        'l2.9 2.9 2.4-.4.4-2.4z"/>'
+    ),
+    "network": (
+        '<rect x="9" y="2.5" width="6" height="5" rx="1"/><rect x="2.5" y="16.5" width="6" height="5" rx="1"/>'
+        '<rect x="15.5" y="16.5" width="6" height="5" rx="1"/><path d="M12 7.5v4.5M5.5 16.5V12h13v4.5"/>'
+    ),
+    "chevron-down": '<polyline points="6 9 12 15 18 9"/>',
+    "chevron-left": '<polyline points="15 18 9 12 15 6"/>',
+    "chevron-up": '<polyline points="6 15 12 9 18 15"/>',
+    "check": '<polyline points="20 6 9 17 4 12"/>',
+    "dot": '<circle cx="12" cy="12" r="5" fill="currentColor"/>',
+    "radio-off": '<circle cx="12" cy="12" r="9"/>',
+    "radio-on": '<circle cx="12" cy="12" r="9"/><circle cx="12" cy="12" r="4.5" fill="currentColor"/>',
+    "alert": '<circle cx="12" cy="12" r="9.5"/><path d="M12 7.5v5.5M12 16.5h.01"/>',
+    "check-circle": '<circle cx="12" cy="12" r="9.5"/><polyline points="16.5 9 10.5 15 7.5 12"/>',
+    "sliders": (
+        '<path d="M4 21v-7M4 10V3M12 21v-9M12 8V3M20 21v-5M20 12V3"/>'
+        '<path d="M1.5 14h5M9.5 8h5M17.5 16h5"/>'
+    ),
+    "bluetooth": '<polyline points="7 7 17 17 12 22 12 2 17 7 7 17"/>',
+    "external": (
+        '<path d="M18 13.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h5.5"/>'
+        '<path d="M15 3h6v6M10 14L21 3"/>'
+    ),
+}
+
+ICON_NAMES = tuple(_PATHS)
+
+
+def svg(name: str, color: str, stroke_width: float = 2.0) -> str:
+    """The SVG document of ``name`` drawn in ``color``."""
+    body = _PATHS[name].replace("currentColor", color)
+    return (
+        '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" '
+        f'stroke="{color}" stroke-width="{stroke_width}" stroke-linecap="round" stroke-linejoin="round">'
+        f"{body}</svg>"
+    )
+
+
+def pixmap(name: str, color: str, size: int = 18, ratio: float = 2.0) -> QPixmap:
+    renderer = QSvgRenderer(QByteArray(svg(name, color).encode("utf-8")))
+    pm = QPixmap(int(size * ratio), int(size * ratio))
+    pm.fill(Qt.GlobalColor.transparent)
+    painter = QPainter(pm)
+    renderer.render(painter)
+    painter.end()
+    pm.setDevicePixelRatio(ratio)
+    return pm
+
+
+def icon(name: str, color: str, size: int = 18) -> QIcon:
+    return QIcon(pixmap(name, color, size))
+
+
+def icon_file(name: str, color: str, stroke_width: float = 2.0) -> str:
+    """Path of a cached SVG file of ``name`` in ``color``, with forward slashes for style sheets."""
+    folder = os.path.join(tempfile.gettempdir(), "nucleuskit_icons")
+    os.makedirs(folder, exist_ok=True)
+    path = os.path.join(folder, f"{name}_{color.lstrip('#')}_{stroke_width:g}.svg")
+    if not os.path.isfile(path):
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write(svg(name, color, stroke_width))
+    return path.replace("\\", "/")
+
+
+class Spinner(QWidget):
+    """An animated arc showing that work is in progress."""
+
+    def __init__(self, size: int = 22, color: str = "#4F85EE", parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._angle = 0
+        self._color = QColor(color)
+        self.setFixedSize(QSize(size, size))
+        self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        self._timer = QTimer(self)
+        self._timer.setInterval(16)
+        self._timer.timeout.connect(self._tick)
+
+    def set_color(self, color: str) -> None:
+        self._color = QColor(color)
+        self.update()
+
+    def start(self) -> None:
+        self._timer.start()
+        self.show()
+
+    def stop(self) -> None:
+        self._timer.stop()
+        self.hide()
+
+    def _tick(self) -> None:
+        self._angle = (self._angle + 6) % 360
+        self.update()
+
+    def paintEvent(self, _event) -> None:  # type: ignore[no-untyped-def]
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        width = max(2.0, self.width() / 9)
+        rect = QRectF(width, width, self.width() - 2 * width, self.height() - 2 * width)
+        track = QColor(self._color)
+        track.setAlpha(50)
+        painter.setPen(QPen(track, width))
+        painter.drawEllipse(rect)
+        painter.setPen(QPen(self._color, width, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
+        painter.drawArc(rect, -self._angle * 16, 100 * 16)
+        painter.end()