docs: finalize JOSS paper content, citations, and add preview action

Author: Jshulgach

.github/workflows/paper.yml

@@ -0,0 +1,30 @@
+name: JOSS Paper Preview
+on:
+  push:
+    paths:
+      - 'paper.md'
+      - 'paper.bib'
+      - 'docs/figs/**'
+  pull_request:
+    paths:
+      - 'paper.md'
+      - 'paper.bib'
+      - 'docs/figs/**'
+  workflow_dispatch:
+
+jobs:
+  paper:
+    runs-on: ubuntu-latest
+    name: Paper Draft
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build Paper
+        uses: openjournals/paper-action@master
+        with:
+          paper_path: paper.md
+      - name: Upload PDF
+        uses: actions/upload-artifact@v4
+        with:
+          name: paper
+          path: paper.pdf

paper.bib

@@ -59,3 +59,50 @@ @software{paszke2019pytorch
   pages={8024--8035},
   year={2019}
 }
+@software{OpenEphysPythonTools,
+  author = {Kulik, Pavel and others},
+  title = {open-ephys-python-tools},
+  url = {https://github.com/open-ephys/open-ephys-python-tools},
+  year = {2024}
+}
+
+@article{Campbell2022,
+  doi = {10.21105/joss.04460},
+  url = {https://doi.org/10.21105/joss.04460},
+  year = {2022},
+  publisher = {The Open Journal},
+  volume = {7},
+  number = {76},
+  pages = {4460},
+  author = {Ethan Campbell and Angkoon Phinyomark and Erik Scheme},
+  title = {{LibEMG}: An Open-Source Library for the Real-time Control Pipeline using Electromyography},
+  journal = {Journal of Open Source Software}
+}
+
+@software{pyqtgraph,
+  author = {Campagnola, Luke and others},
+  title = {PyQtGraph: Scientific Graphics and {GUI} Library for {Python}},
+  url = {https://github.com/pyqtgraph/pyqtgraph},
+  year = {2024}
+}
+
+@software{pyzmq,
+  author = {Min Ragan-Kelley and Brian Granger},
+  title = {PyZMQ: {Python} bindings for {ZeroMQ}},
+  url = {https://github.com/zeromq/pyzmq},
+  year = {2024}
+}
+
+@software{LSL,
+  author = {Christian Kothe and others},
+  title = {{Lab Streaming Layer}},
+  url = {https://github.com/sccn/labstreaminglayer},
+  year = {2024}
+}
+
+@software{PyQt5,
+  author = {{Riverbank Computing Limited}},
+  title = {{PyQt5}},
+  url = {https://www.riverbankcomputing.com/software/pyqt/},
+  year = {2024}
+}

paper.md

@@ -20,20 +20,20 @@ bibliography: paper.bib
 
 # Summary
 
-`python-oephys` is an open-source Python library designed to facilitate the acquisition, processing, and analysis of high-density electrophysiology data, specifically targeting the Open Ephys ecosystem. It provides a unified interface for both offline analysis of binary recordings and real-time streaming via ZeroMQ (ZMQ). Key capabilities include modular signal processing pipelines, automated channel quality assessment (QC), and integrated machine learning models (CNN-LSTM) optimized for low-latency gesture classification.
+`python-oephys` is an open-source Python library designed to facilitate the acquisition, processing, and analysis of high-density electrophysiology data, specifically targeting the Open Ephys ecosystem. It provides a unified interface for both offline analysis of binary recordings and real-time streaming via ZeroMQ [@pyzmq]. Key capabilities include modular signal processing pipelines, automated channel quality assessment (QC), and integrated machine learning models (CNN-LSTM) optimized for low-latency gesture classification.
 
 # Statement of need
 
 The Open Ephys GUI [@siegle2017open] is a widely used platform for neural data acquisition, but researchers often face significant friction when transitioning from raw data acquisition to real-time closed-loop control or advanced offline analysis. Existing tools often handle either file I/O or real-time streaming, but rarely both in a unified, high-performance package. 
 
 `python-oephys` satisfies this need by providing:
 1. **Unified I/O**: A consistent API for both `.oebin` and `.npz` formats.
-2. **Real-time Integration**: Low-latency ZMQ clients that allow Python scripts and GUI applications to react to live neural streams.
+2. **Real-time Integration**: Low-latency ZeroMQ [@pyzmq] clients that allow Python scripts and GUI applications to react to live neural streams.
 3. **ML-Ready Pipelines**: Pre-integrated deep learning architectures tailored for spatio-temporal neural signals, reducing the time required to build predictive models for BCIs or myoelectric control.
 
 # State of the field
 
-The field of neural data analysis is supported by several specialized tools. The official `open-ephys-python-tools` provide basic file loading capabilities but lack high-level processing or real-time application layers. In the domain of myoelectric control, libraries like `LibEMG` offer comprehensive pipelines but are often decoupled from the specific streaming protocols used by hardware like Open Ephys.
+The field of neural data analysis is supported by several specialized tools. The official `open-ephys-python-tools` [@OpenEphysPythonTools] provide basic file loading capabilities but lack high-level processing or real-time application layers. In the domain of myoelectric control, libraries like `LibEMG` [@Campbell2022] offer comprehensive pipelines but are often decoupled from the specific streaming protocols used by hardware like Open Ephys.
 
 `python-oephys` bridges these domains by specializing in the high-density spatial configurations typical of Open Ephys hardware while providing the real-time application layer (viewers and decoders) missing from low-level I/O libraries. It leverages the scientific Python stack, including NumPy [@harris2020array], SciPy [@virtanen2020scipy], and Matplotlib [@hunter2007matplotlib], to provide robust data structures and visualizations.
 
@@ -43,17 +43,17 @@ The field of neural data analysis is supported by several specialized tools. The
 
 ![EMG Processing Pipeline. A) Raw signals from five representative channels (20–30s). B) Signals after CAR, bandpass (20-500Hz), and 60Hz notch filtering. C) Automated channel quality indicators evaluated on the first 5s of data. D) Mean RMS features extracted from the processed segment.](docs/figs/pipeline.png)
 
-- **Interface Layer**: Implements ZMQ and LSL clients for low-latency data streaming. The `ZMQClient` is designed to run asynchronously, ensuring that data acquisition does not block processing or UI updates.
+- **Interface Layer**: Implements ZeroMQ [@pyzmq] and LSL [@LSL] clients for low-latency data streaming. The `ZMQClient` is designed to run asynchronously, ensuring that data acquisition does not block processing or UI updates.
 - **Processing Layer**: Provides a suite of filters and feature extraction tools. This includes the `EMGPreprocessor` for standardized filtering and `ChannelQC` for real-time signal quality monitoring.
 - **ML Layer**: Integrated with PyTorch [@paszke2019pytorch] and scikit-learn [@pedregosa2011scikit], this layer provides pre-configured models like `EMGClassifierCNNLSTM`. These models are designed to handle the variable channel counts and sampling rates common in high-density recordings.
-- **Visualization Layer**: Built on PyQt5 and pyqtgraph, providing high-frame-rate real-time plots and interactive offline analysis tools.
+- **Visualization Layer**: Built on PyQt5 [@PyQt5] and pyqtgraph [@pyqtgraph], providing high-frame-rate real-time plots and interactive offline analysis tools.
 
 # Research Impact
 
 `python-oephys` has been deployed in the Neuromechatronics Lab at Carnegie Mellon University to support research in high-density EMG-based human-computer interaction and robotic control. Its ability to provide sub-millisecond latency for feature extraction has enabled more responsive myoelectric interfaces compared to previous custom implementations.
 
 # Acknowledgements
 
-This work was supported by the Neuromechatronics Lab at Carnegie Mellon University.
+This work was supported by the Neuromechatronics Lab at Carnegie Mellon University. We would like to express our gratitude to the Open Ephys community and the developers of the Open Ephys GUI for their foundational work and support of open-source electrophysiology tools.
 
 # References