monochrome 2024.3.21__tar.gz → 2024.11.20__tar.gz

{monochrome-2024.3.21 → monochrome-2024.11.20}/.github/workflows/build.yml

@@ -23,9 +23,9 @@ jobs:
           fetch-depth: 0
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.16.5
+        uses: pypa/cibuildwheel@v2.21.3
         env:
-          CIBW_BUILD: "cp38-macosx* cp38-manylinux_x86_64 cp38-win_amd64"
+          CIBW_BUILD: "cp39-macosx* cp39-manylinux_x86_64 cp39-win_amd64"
 
       - name: Upload wheels
         uses: actions/upload-artifact@v4
@@ -40,7 +40,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.7", "3.12"]
+        python-version: ["3.8", "3.12"]
 
     steps:
       - name: Checkout
@@ -80,6 +80,8 @@ jobs:
     runs-on: ubuntu-latest
     container:
       image: quay.io/pypa/manylinux2014_x86_64
+    env:
+      ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: "true"  # https://github.com/actions/checkout/issues/1809
     steps:
     - name: Install dependencies
       run: |

{monochrome-2024.3.21 → monochrome-2024.11.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: monochrome
-Version: 2024.3.21
+Version: 2024.11.20
 Summary: Viewer for monochromatic video data
 Author-Email: Jan Lebert <mail@janlebert.com>
 Classifier: Development Status :: 5 - Production/Stable

monochrome-2024.11.20/docs/tutorial.ipynb

@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Python Tutorial\n",
+    "\n",
+    "\n",
+    "```{note}\n",
+    "This tutorial is currently in preparation. Please check back later.\n",
+    "```\n",
+    "\n",
+    "This tutorial demonstrates how to use the `monochrome` Python library to visualize videos and other data in the Monochrome viewer.\n",
+    "\n",
+    "## Basic Usage\n",
+    "\n",
+    "First, import the necessary libraries:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import monochrome as mc\n",
+    "import optimap as om"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we use [optimap](https://github.com/cardiacvision/optimap) to download a sample video as a numpy array."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = om.download_example_data(\"VF_Rabbit_1.npy\")\n",
+    "video = om.load_video(filename)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Display the video in Monochrome using {func}`mc.show`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mc.show(video, name=\"Example Recording\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can display multiple videos simultaneously. They will play in sync if they have the same length:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Converting video to np.float32 with values between 0 and 1\n",
+    "video2 = om.video.normalize(video)\n",
+    "print(f\"Video shape: {video2.shape}, dtype: {video2.dtype}\")\n",
+    "\n",
+    "# vmin and vmax are optional and used to set the minimum and maximum values of the colormap\n",
+    "mc.show(video2, name=\"Another Recording\", cmap=\"viridis\", vmin=0.1, vmax=0.9)\n",
+    "mc.show(video2[0], name=\"First Frame\", cmap=\"gray\", vmin=0.1, vmax=0.9)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can load videos directly from a file path using {func}`mc.show` or {func}`mc.show_file`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mc.show(filename)  # Equivalent to mc.show_file(filename)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Advanced Usage\n",
+    "\n",
+    "### Overlays\n",
+    "\n",
+    "You can add a video as an overlay to another video using {func}`mc.show_layer`. This is useful for comparing different videos or visualizing different aspects of the same video. The overlay will be blended with the parent video using the specified opacity function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a synthetic overlay\n",
+    "overlay = video.copy()\n",
+    "overlay[:, 32:96, 32:96] = np.nan  # Create a transparent region\n",
+    "\n",
+    "# Display the overlay\n",
+    "mc.show_layer(overlay, parent=\"Example Recording\", name=\"Overlay\", cmap=\"hsv\", opacity=0.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Optical Flow\n",
+    "\n",
+    "You can visualize optical flow using {func}`mc.show_flow`. This function takes a 4D numpy array of shape `(T, H, W, 2)` where `T` is the number of frames, `H` and `W` are the height and width of the video, and the last dimension represents the x and y components of the flow vectors.\n",
+    "\n",
+    "First, let's create some synthetic optical flow data:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "monochrome",
+   "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/cpp/fileformats/AbstractFile.h

@@ -50,6 +50,7 @@ class AbstractFile {
   virtual std::optional<ColorMap> cmap() const                              = 0;
   virtual std::optional<float> vmin() const { return std::nullopt; };
   virtual std::optional<float> vmax() const { return std::nullopt; };
+  virtual std::optional<OpacityFunction> opacity() const { return std::nullopt; };
 
   [[nodiscard]] virtual Eigen::MatrixXf read_frame(long t)      = 0;
   [[nodiscard]] virtual float get_pixel(long t, long x, long y) = 0;

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/cpp/fileformats/InMemoryFile.h

@@ -52,6 +52,7 @@ class InMemoryFile : public AbstractFile {
   std::optional<ColorMap> cmap() const final { return _data->meta.cmap; }
   std::optional<float> vmin() const final { return _data->meta.vmin; };
   std::optional<float> vmax() const final { return _data->meta.vmax; };
+  std::optional<OpacityFunction> opacity() const final { return _data->meta.opacity; };
 
   Eigen::MatrixXf read_frame(long t) final {
     std::visit(

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/cpp/recording.h

@@ -38,6 +38,7 @@ class Recording {
   std::shared_ptr<AbstractFile> _file;
   long t_frame = 0;
   std::string _name;
+  std::string _filepath;
 
   static inline RotationCtrl rotations = {};
 
@@ -52,6 +53,7 @@ class Recording {
       return;
     }
     _name = _file->path().filename().string();
+    _filepath = _file->path().has_parent_path() ? _file->path().string() : "";
     frame.setZero(_file->Nx(), _file->Ny());
     apply_rotation();
   }
@@ -62,6 +64,7 @@ class Recording {
 
   virtual std::string name() const { return _name; }
   virtual void set_name(const std::string &new_name) { _name = new_name; };
+  virtual std::string filepath() const { return _filepath; }
 
   [[nodiscard]] bool good() const { return _file && _file->good(); }
   int Nx() const { return frame.rows(); }

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/cpp/recordingwindow.cpp

@@ -128,6 +128,9 @@ RecordingWindow::RecordingWindow(std::shared_ptr<AbstractFile> file_,
     // assume that's its a phase map and the user prefers HSV in this circumstances
     cmap_ = ColorMap::HSV;
   }
+  if (_file->opacity()) {
+    opacity = _file->opacity().value();
+  }
 
   set_transformation(transformation_);
 }

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/cpp/ui/recording_controls.h

@@ -171,6 +171,10 @@ void show_controls_ui(const SharedRecordingPtr &rec, RecordingWindow *parent) {
   if (ImGui::InputText("Name", &rec_name)) {
     rec->set_name(rec_name);
   }
+  auto rec_filepath = rec->filepath();
+  if (!rec_filepath.empty()) {
+    ImGui::InputText("Filepath", &rec_filepath, ImGuiInputTextFlags_ReadOnly);
+  }
   if (ImGui::Button(u8"Delete " ICON_FA_TRASH_ALT)) {
     if (!parent) {
       glfwSetWindowShouldClose(rec->window, GLFW_TRUE);

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/python/monochrome/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2024.3.21'
-__version_tuple__ = version_tuple = (2024, 3, 21)
+__version__ = version = '2024.11.20'
+__version_tuple__ = version_tuple = (2024, 11, 20)

{monochrome-2024.3.21 → monochrome-2024.11.20}/src/python/monochrome/ipc.py

@@ -451,6 +451,8 @@ def show_video(array: np.ndarray,
             opacity = OpacityFunction.FIXED_25
         elif opacity == 0:
             opacity = OpacityFunction.FIXED_0
+        else:
+            raise ValueError("Invalid opacity value")
     if isinstance(opacity, str):
         opacity = getattr(OpacityFunction, opacity.upper())
 

monochrome-2024.3.21/docs/tutorial.ipynb

@@ -1,115 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Python Tutorial\n",
-    "\n",
-    "```{note}\n",
-    "\n",
-    "This tutorial is currently in preparation. Please check back later.\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import monochrome as mc\n",
-    "import optimap as om"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "filename = om.utils.retrieve_example_data(\"Example_02_VF_Rabbit_Di-4-ANEPPS_Basler_acA720-520um.npy\")\n",
-    "video = om.load_video(filename)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mc.show(video, name=\"Example Recording\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Several videos can be shown at the same time, they will be played in sync if they have the same length:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Converting video to np.float32 with values between 0 and 1\n",
-    "video2 = om.video.normalize(video)\n",
-    "print(f\"Video shape: {video2.shape}, dtype: {video2.dtype}\")\n",
-    "\n",
-    "# vmin and vmax are optional and used to set the minimum and maximum values of the colormap\n",
-    "mc.show(video2, name=\"Another Recording\", cmap=\"viridis\", vmin=0.1, vmax=0.9)\n",
-    "mc.show(video2[0], name=\"First Frame\", cmap=\"gray\", vmin=0.1, vmax=0.9)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The functions {func}`show` or {func}`show_file` can be used to load a video from a file in Monochrome:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(filename)\n",
-    "mc.show(filename)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "om.motion_compensate"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "monochrome",
-   "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.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

monochrome-2024.3.21/vendor/imgui/examples/example_emscripten_wgpu/web/index.html

@@ -1,80 +0,0 @@
-<!doctype html>
-<html lang="en-us">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"/>
-    <title>Dear ImGui Emscripten+WebGPU example</title>
-    <style>
-        body { margin: 0; background-color: black }
-        .emscripten {
-            position: absolute;
-            top: 0px;
-            left: 0px;
-            margin: 0px;
-            border: 0;
-            width: 100%;
-            height: 100%;
-            overflow: hidden;
-            display: block;
-            image-rendering: optimizeSpeed;
-            image-rendering: -moz-crisp-edges;
-            image-rendering: -o-crisp-edges;
-            image-rendering: -webkit-optimize-contrast;
-            image-rendering: optimize-contrast;
-            image-rendering: crisp-edges;
-            image-rendering: pixelated;
-            -ms-interpolation-mode: nearest-neighbor;
-        }
-    </style>
-  </head>
-  <body>
-    <canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()"></canvas>
-    <script type='text/javascript'>
-      var Module;
-      (async () => {
-        Module = {
-          preRun: [],
-          postRun: [],
-          print: (function() {
-              return function(text) {
-                  text = Array.prototype.slice.call(arguments).join(' ');
-                  console.log(text);
-              };
-          })(),
-          printErr: function(text) {
-              text = Array.prototype.slice.call(arguments).join(' ');
-              console.error(text);
-          },
-          canvas: (function() {
-              var canvas = document.getElementById('canvas');
-              //canvas.addEventListener("webglcontextlost", function(e) { alert('FIXME: WebGL context lost, please reload the page'); e.preventDefault(); }, false);
-              return canvas;
-          })(),
-          setStatus: function(text) {
-              console.log("status: " + text);
-          },
-          monitorRunDependencies: function(left) {
-              // no run dependencies to log
-          }
-        };
-        window.onerror = function() {
-          console.log("onerror: " + event);
-        };
-
-      // Initialize the graphics adapter
-      {
-          const adapter = await navigator.gpu.requestAdapter();
-          const device = await adapter.requestDevice();
-          Module.preinitializedWebGPUDevice = device;
-      }
-
-      {
-          const js = document.createElement('script');
-          js.async = true;
-          js.src = "index.js";
-          document.body.appendChild(js);
-      }
-      })();
-    </script>
-  </body>
-</html>