replay_recording.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "import sys\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from IPython.display import display, clear_output\n",
    "\n",
    "def update(*args):\n",
    "    clear_output(wait=True)\n",
    "    display(*args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append(\"/Users/rom/work/pupil/pupil_src/shared_modules/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import file_methods as fm\n",
    "import zmq_tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load recording"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize calibration timestamps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_recording_messages(rec_dir):\n",
    "    N = fm.load_pldata_file(rec_dir, \"notify\")\n",
    "    P = fm.load_pldata_file(rec_dir, \"pupil\")\n",
    "\n",
    "    messages = []\n",
    "    messages.extend(N.data)\n",
    "    messages.extend(P.data)\n",
    "\n",
    "    # Filter 3d data\n",
    "    def is_not_pupil(msg):\n",
    "        return not msg[\"topic\"].startswith(\"pupil\")\n",
    "\n",
    "    def is_pupil_3d(msg):\n",
    "\n",
    "        return \"3d\" in msg[\"method\"]\n",
    "\n",
    "\n",
    "    messages = filter(lambda m: is_not_pupil(m) or is_pupil_3d(m), messages)\n",
    "\n",
    "    # Filter calibration data\n",
    "    start, stop = N.timestamps[[0, -1]]\n",
    "    messages = filter(lambda m: start <= m[\"timestamp\"] <= stop, messages)\n",
    "\n",
    "    # Sort by time\n",
    "    messages = sorted(messages, key=lambda m: m[\"timestamp\"])\n",
    "\n",
    "    return messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "messages = load_recording_messages(\"hmd_gazer_4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_calibration_timestamps(messages):\n",
    "    ts = [m[\"timestamp\"] for m in messages]\n",
    "    topics_all = [m[\"topic\"] for m in messages]\n",
    "    topics = sorted(set(topics_all), reverse=True)\n",
    "    topic_idc = [topics.index(t) for t in topics_all]\n",
    "\n",
    "    plt.scatter(ts, topic_idc)\n",
    "    plt.yticks(range(len(topics)), topics)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_calibration_timestamps(messages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay recording"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def enumerate_notifications(messages):\n",
    "    replay_speed = 2  # increasing too much might drop packages\n",
    "    first_ts = messages[0][\"timestamp\"]\n",
    "    last_ts = first_ts\n",
    "\n",
    "    for idx, msg in enumerate(messages):\n",
    "        msg = msg._deep_copy_dict()\n",
    "        new_ts = msg[\"timestamp\"]\n",
    "\n",
    "        yield idx, msg, new_ts\n",
    "\n",
    "        time_to_sleep = max(0.0, new_ts - last_ts)\n",
    "        time_to_sleep /= replay_speed\n",
    "        time.sleep(time_to_sleep)\n",
    "        last_ts = new_ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NetworkInterface:\n",
    "    def __init__(self, req_port: int = 50020):\n",
    "        zmq = zmq_tools.zmq\n",
    "        addr = \"tcp://localhost:{}\"\n",
    "\n",
    "        self.ctx = zmq.Context.instance()\n",
    "\n",
    "        self.req = self.ctx.socket(zmq.REQ)\n",
    "        self.req.connect(addr.format(req_port))\n",
    "\n",
    "        self.req.send_string(\"SUB_PORT\")\n",
    "        sub_port = self.req.recv_string()\n",
    "\n",
    "        self.req.send_string(\"PUB_PORT\")\n",
    "        pub_port = self.req.recv_string()\n",
    "\n",
    "        self.pub_msg_streamer = zmq_tools.Msg_Streamer(\n",
    "            self.ctx,\n",
    "            addr.format(pub_port),\n",
    "        )\n",
    "\n",
    "        self.log_msg_receiver = zmq_tools.Msg_Receiver(\n",
    "            self.ctx,\n",
    "            addr.format(sub_port),\n",
    "            topics=(\"logging.\",),\n",
    "        )\n",
    "\n",
    "        self.calibration_msg_receiver = zmq_tools.Msg_Receiver(\n",
    "            self.ctx,\n",
    "            addr.format(sub_port),\n",
    "            topics=(\"notify.calibration.\",)\n",
    "        )\n",
    "\n",
    "    def sync_time(self, timestamp):\n",
    "        self.req.send_string(f\"T {timestamp}\")\n",
    "        response_string = self.req.recv_string()\n",
    "        return response_string\n",
    "\n",
    "    def send_start_plugin_notification(self, plugin_name: str):\n",
    "        self.pub_msg_streamer.send(\n",
    "            {\n",
    "                \"topic\": \"notify.start_plugin\",\n",
    "                \"subject\": \"start_plugin\",\n",
    "                \"name\": \"HMD3DChoreographyPlugin\",\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Service v1.23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replay_speed = 2  # increasing too much might drop packages\n",
    "\n",
    "# pub = zmq_tools.Msg_Streamer(ctx, addr.format(pub_port))\n",
    "# logs = zmq_tools.Msg_Receiver(\n",
    "#     ctx,\n",
    "#     addr.format(sub_port),\n",
    "#     topics=(\"logging.\", \"notify.calibration.successful\"))\n",
    "\n",
    "# try:\n",
    "#     first_ts = messages[0][\"timestamp\"]\n",
    "    \n",
    "#     pub.send(\n",
    "#         {\n",
    "#             \"topic\": \"notify.start_plugin\",\n",
    "#             \"subject\": \"start_plugin\",\n",
    "#             \"name\": \"HMD_Calibration_3D\",\n",
    "#         }\n",
    "#     )\n",
    "    \n",
    "#     req.send_string(f\"T {first_ts}\")\n",
    "#     print(req.recv_string())\n",
    "\n",
    "#     last_ts = first_ts\n",
    "#     for idx, msg in enumerate(messages):\n",
    "#         msg = msg._deep_copy_dict()\n",
    "#         new_ts = msg[\"timestamp\"]\n",
    "#         time_to_sleep = max(0.0, new_ts - last_ts)\n",
    "#         time_to_sleep /= replay_speed\n",
    "#         time.sleep(time_to_sleep)\n",
    "#         last_ts = new_ts\n",
    "\n",
    "#         pub.send(msg)\n",
    "        \n",
    "#         if idx % 100 == 0:\n",
    "#             update(f\"({idx}) Sending {msg['topic']}\")\n",
    "\n",
    "#     update(f\"(Finished) Sending {msg['topic']}\")\n",
    "        \n",
    "# except KeyboardInterrupt:\n",
    "#     del pub\n",
    "\n",
    "# # Flush all recent logs\n",
    "# while logs.new_data:\n",
    "#     topic, payload = logs.recv()\n",
    "#     print(f'[{payload[\"levelname\"]}] {payload[\"name\"]} - {payload[\"msg\"]}')\n",
    "\n",
    "# try:\n",
    "#     while True:\n",
    "#         topic, payload = logs.recv()\n",
    "#         if topic == \"notify.calibration.successful\":\n",
    "#             print(\"Calibration successful.\")\n",
    "#             break\n",
    "#         print(f'[{payload[\"levelname\"]}] {payload[\"name\"]} - {payload[\"msg\"]}')\n",
    "# except KeyboardInterrupt:\n",
    "#     pass\n",
    "\n",
    "# del logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Service 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def send_notifications(net_api, choreo_plugin_name, messages):\n",
    "\n",
    "    def send_message(msg):\n",
    "        net_api.pub_msg_streamer.send(msg)\n",
    "\n",
    "    def expect_recv(expected_topics: tuple):\n",
    "        if not isinstance(expected_topics, tuple):\n",
    "            expected_topics = (expected_topics,)\n",
    "        actual_topic, payload = net_api.calibration_msg_receiver.recv()\n",
    "        assert actual_topic in expected_topics, f'Expected message with topics \"{expected_topics}\", but got \"{actual_topic}\"'\n",
    "        return actual_topic\n",
    "\n",
    "    net_api.send_start_plugin_notification(choreo_plugin_name)\n",
    "\n",
    "    if len(messages) == 0:\n",
    "        return\n",
    "\n",
    "    for idx, msg, ts in enumerate_notifications(messages):\n",
    "        if idx == 0:\n",
    "            response_string = net_api.sync_time(ts)\n",
    "            print(f\"(i) {response_string}\")\n",
    "\n",
    "        send_message(msg)\n",
    "\n",
    "        topic = msg[\"topic\"]\n",
    "        if topic.startswith(\"pupil.\"):\n",
    "            pass\n",
    "        elif topic.startswith(\"notify.\"):\n",
    "            expect_recv(topic) #echo\n",
    "            print(topic)\n",
    "\n",
    "            if topic == \"notify.calibration.should_start\":\n",
    "                recv_topic = expect_recv(\"notify.calibration.started\")\n",
    "                print(recv_topic)\n",
    "\n",
    "            elif topic == \"notify.calibration.add_ref_data\":\n",
    "                pass\n",
    "\n",
    "            elif topic == \"notify.calibration.should_stop\":\n",
    "                recv_topic = expect_recv(\"notify.calibration.stopped\")\n",
    "                print(recv_topic)\n",
    "\n",
    "                recv_topic = expect_recv(\"notify.calibration.setup.v2\")\n",
    "                print(recv_topic)\n",
    "\n",
    "                recv_topic = expect_recv((\"notify.calibration.successful\", \"notify.calibration.failed\"))\n",
    "                print(recv_topic)\n",
    "\n",
    "                if recv_topic == \"notify.calibration.successful\":\n",
    "                    expect_recv(\"notify.calibration.result.v2\")\n",
    "                    print(recv_topic)\n",
    "            else:\n",
    "                print(f\"UNEXPECTED: {topic}\")\n",
    "        else:\n",
    "            print(f\"UNEXPECTED: {topic}\")\n",
    "\n",
    "    print(\"(i) Finished sending messages.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(i) Timesync successful.\n",
      "notify.calibration.should_start\n",
      "notify.calibration.started\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.add_ref_data\n",
      "notify.calibration.should_stop\n",
      "notify.calibration.stopped\n",
      "notify.calibration.setup.v2\n",
      "notify.calibration.successful\n",
      "notify.calibration.successful\n",
      "(i) Finished sending messages.\n"
     ]
    }
   ],
   "source": [
    "send_notifications(\n",
    "    net_api=NetworkInterface(),\n",
    "    choreo_plugin_name=\"HMD3DChoreographyPlugin\",\n",
    "#     choreo_plugin_name=\"CustomHMD3DChoreographyPlugin\",\n",
    "    messages=messages,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}