Repository: UCL-Chimera/medical-waveforms (language: python)

Issue:
Should `get_cycles()` be run once then given as an argument to each child of `CycleFeatureExtractor`?



Discussion / hints:

Fix patch:
diff --git a/abpfeature_annotated.m b/abpfeature_annotated.m
new file mode 100644
index 0000000..8295e8f
--- /dev/null
+++ b/abpfeature_annotated.m
@@ -0,0 +1,195 @@
+function r = abpfeature(abp,OnsetTimes, Fs)
+    % ABPFEATURE  ABP waveform feature extractor.
+    %   r = ABPFEATURE(ABP,ONSETTIMES) extracts features from ABP waveform such
+    %   as systolic pressure, mean pressure, etc.
+    %
+    %   In:     ABP = signal (default 125Hz sampled)
+    %           ONSETTIMES = times of onset (in samples)
+    %   Out:    Beat-to-beat ABP features
+    %           Col 1:  Time of systole   [samples]
+    %               2:  Systolic BP       [mmHg]
+    %               3:  Time of diastole  [samples]
+    %               4:  Diastolic BP      [mmHg]
+    %               5:  Pulse pressure    [mmHg]
+    %               6:  Mean pressure     [mmHg]
+    %               7:  Beat Period       [samples]
+    %               8:  mean_dyneg
+    %               9:  End of systole time  0.3*sqrt(RR)  method
+    %              10:  Area under systole   0.3*sqrt(RR)  method
+    %              11:  End of systole time  1st min-slope method
+    %              12:  Area under systole   1st min-slope method
+    %              13:  Pulse             [samples]
+    % 
+    %   Usage:
+    %   - OnsetTimes must be obtained using wabp.m
+    %
+    %   Written by James Sun (xinsun@mit.edu) on Nov 19, 2005.
+    %   Updated by Alistair Johnson, 2014.
+    %
+    %   LICENSE:    
+    %       This software is offered freely and without warranty under 
+    %       the GNU (v3 or later) public license. See license file for
+    %       more information
+    
+    % NOTE THAT ONLY THE FOLLOWING FEATURES ARE USED DOWNSTREAM BY jSQI.m
+    % - Systolic BP
+    % - Diastolic BP
+    % - Pulse pressure
+    % - MAP
+    % - Beat duration
+    % - Mean dyneg
+    
+    
+    if length(OnsetTimes)<30 % don't process anything if too little onsets
+        r = [];
+        return
+    end
+    
+    %% P_sys, P_dias
+    if nargin<3
+    Fs        = 125; % Sampling Frequency
+    end
+    Window    = ceil(0.32*Fs);
+    OT        = OnsetTimes(1:end-1);  % exclude last element of vector
+    BeatQty   = length(OT);
+    
+    % [MinDomain,MaxDomain] = init(zeros(BeatQty,Window));
+    
+    % iterate over columns
+    % n_rows is number of beats
+    % n_columns is size of window, with increasing size each side on onset
+    for i=1:Window % Vectorized version (this isn't vectorized)
+        MinDomain(:,i) = OT-i+1;  % these are matrices created on fly
+        MaxDomain(:,i) = OT+i-1;
+    end
+    
+    %MinDomain = bsxfun(@minus,OT,(0:Window-1)); 
+    %MaxDomain = bsxfun(@plus,OT,(0:Window-1));
+    
+    % Ensures window doesn't go off edges of signal
+    MinDomain(MinDomain<1) = 1;  % Error protection
+    MaxDomain(MaxDomain<1) = 1;
+    MinDomain(MinDomain>length(abp)) = length(abp);
+    MaxDomain(MaxDomain>length(abp)) = length(abp);
+    
+    % Get min or max across an axis
+    % 2 selects column axis
+    % [] is default arg
+    % What is abp(...) doing here?
+    [P_dias Dindex]  = min(abp(MinDomain),[],2);% Get lowest value across 'Window' samples before beat onset
+    [P_sys  Sindex]  = max(abp(MaxDomain),[],2);% Get highest value across 'Window' samples after beat onset
+    
+    % Flattens indices
+    DiasTime         = MinDomain(sub2ind(size(MinDomain),(1:BeatQty)',Dindex)); % Map offset indices Dindex to original indices
+    SysTime          = MaxDomain(sub2ind(size(MaxDomain),(1:BeatQty)',Sindex)); % Map offset indices Sindex to original indices
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % Pulse Pressure [mmHg]
+    PP         = P_sys - P_dias;
+    
+    % Beat Period [samples]
+    % Differences bnetween adjacent elements
+    BeatPeriod = diff(OnsetTimes);
+    
+    % Mean,StdDev, Median Deriv- (noise detector)
+    % This seems to be a homegrown noise metric
+    dyneg          = diff(abp);
+    dyneg(dyneg>0) = 0;
+    
+    % what does init do here? why assign 3 outputs?
+    % assume this inits 3 zero vectors of len BeatQty
+    % is init borrowed from the neural net library?
+    [MAP,stddev,mean_dyneg] = init(zeros(BeatQty,1));
+    
+    % shift last onset time if it is at the very end of the signal
+    if OnsetTimes(end)==numel(abp)
+        OnsetTimes(end) = numel(abp) - 1;
+    end
+    
+    
+    for i=1:BeatQty
+        interval       = abp(OnsetTimes(i):OnsetTimes(i+1));  % equivalent to get_cycles()
+        MAP(i)         = mean(interval);
+        stddev(i)      = std(interval);
+    
+        dyneg_interval = dyneg(OnsetTimes(i):OnsetTimes(i+1));
+        dyneg_interval(dyneg_interval==0) = [];  % chop out all the zeros...
+        if min(size(dyneg_interval))==0
+            dyneg_interval = 0;  % ...and if there's nothing left (if no negative) make it zero
+        end
+        mean_dyneg(i)  = mean(dyneg_interval);  % if artefact may have high magnitude
+    end
+    
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % Systolic Area calculation using 0.3*sqrt(RR)
+    RR                  = BeatPeriod/Fs;  % RR time in seconds
+    sys_duration        = 0.3*sqrt(RR); % does the sqrt account for relatively greater shortening of diastole as HR increases
+    EndOfSys1           = round(OT + sys_duration*Fs);
+    
+    % This looks like an approximation for speed, not the actual integral
+    SysArea1            = localfun_area(abp,OT,EndOfSys1',P_dias);
+    
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % Systolic Area calculation using 'first minimum slope' method
+    % Looks like this trying to find the dicrotic notch, then obtain the systolic integral that way
+    
+    SlopeWindow         = ceil(0.28*Fs);
+    ST                  = EndOfSys1; % start 12 samples after P_sys
+    
+    if ST(end) > (length(abp)-SlopeWindow)   % error protection
+        ST(end) = length(abp)-SlopeWindow;  % avoid going over edge of signal
+    end
+    
+    SlopeDomain = zeros(BeatQty,SlopeWindow);  % init matrix
+    for i=1:SlopeWindow  % loop over columns
+        SlopeDomain(:,i) = ST+i-1;
+    end
+    % y[n] = x[n]-x[n-1]
+    % abp is 2 dimensional, just with 1 row
+    
+    Slope              = diff(abp(SlopeDomain),1,2);  % 1 means adjacent diffs, 2 selects column axis
+    Slope(Slope>0)     = 0; % Set positive slopes to zero
+    
+    [MinSlope index]   = min(abs(Slope),[],2); % Find first positive slope
+    EndOfSys2          = SlopeDomain(sub2ind(size(SlopeDomain),(1:BeatQty)',index));
+    SysArea2           = localfun_area(abp,OT,EndOfSys2,P_dias);
+    Pulse              = 60./BeatPeriod;
+    
+    
+    % OUTPUT:
+    % Ensure that there is no concatenation error by using
+    % (:) indexing to force column vectors
+    r = [SysTime(:),P_sys(:),DiasTime(:),P_dias(:),PP(:),...
+        MAP(:),BeatPeriod(:),mean_dyneg(:),EndOfSys1(:),SysArea1(:),...
+        EndOfSys2(:),SysArea2(:),Pulse(:)];
+    end
+    
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % Helper function:
+    
+    function SysArea = localfun_area(abp,onset,EndSys,P_dias)
+    %% Input:  abp,
+    %%         onset, P_dias, end of systole, beat duration in unit of samples, same length
+    %% Output: systolic area, warner correction factor
+
+    % Just approximates integral
+    
+    BeatQty = length(onset);
+    SysArea = init(zeros(BeatQty,1));
+    for i=1:BeatQty
+        SysArea(i) = sum(abp(onset(i):EndSys(i))); % faster than trapz below
+        %b(i) = trapz(abp(onset(i):EndSys(i)));
+    end
+    EndSys = EndSys(:); onset = onset(:); % force col vectors
+    SysPeriod  = EndSys     - onset;
+    
+    % Time scale and subtract the diastolic area under each systolic interval
+    SysArea = (SysArea - P_dias.*SysPeriod)/125; % Area [mmHg*sec]
+    end
+    
+    % for initializing a variable
+    function varargout = init(z)
+    for i=1:nargout
+        varargout(i) = {z};
+    end
+    end
\ No newline at end of file
diff --git a/examples/get_cycles_benchmarking.ipynb b/examples/get_cycles_benchmarking.ipynb
new file mode 100644
index 0000000..4bed58d
--- /dev/null
+++ b/examples/get_cycles_benchmarking.ipynb
@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Testing performance overhead of running `get_cycles()` once per cycle feature extraction\n",
+    "\n",
+    "The alternative is a memory overhead where we run `get_cycles()` once and store the result, but this might be a big overhead if there are lots of data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os, sys\n",
+    "sys.path.append(os.pardir)  # Needed for sidewinder import before we install it\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from sidewinder import synthetic\n",
+    "from sidewinder.waveforms import Waveforms\n",
+    "from sidewinder.features.waveform import find_troughs\n",
+    "from sidewinder.features import cycle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load reasonably large amount of waveform data\n",
+    "\n",
+    "We generate 20 minutes of synthetic arterial blood pressure data at 100Hz for demonstration purposes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = synthetic.synthetic_arterial_pressure_data(\n",
+    "    systolic_pressure=120,\n",
+    "    diastolic_pressure=80,\n",
+    "    heart_rate=70,\n",
+    "    n_beats_target=20 * 60 / (60 / 70),\n",
+    "    hertz=100\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load the data into `sidewinder`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wf = Waveforms(data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "240002"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "wf.waveforms.size"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Find troughs in a waveform\n",
+    "\n",
+    "For example, we could use the troughs to split our arterial blood pressure data into separate heartbeats."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wf = find_troughs(wf, name='pressure')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "25.2 ms ± 3.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "cycles = cycle.get_cycles(wf, 'pressure')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is quite a small performance overhead."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.2 ('sidewinder-axJzVSFK-py3.10')",
+   "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.10.2"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "52b33a274511e606d62a0c6c9d6ddb3dbbb94c75bbbe067dfc3130d53f815d2e"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/tutorial.ipynb b/examples/tutorial.ipynb
index 63b055b..223ffb5 100644
--- a/examples/tutorial.ipynb
+++ b/examples/tutorial.ipynb
@@ -12,6 +12,16 @@
    "execution_count": 1,
    "metadata": {},
    "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "import os, sys\n",
     "sys.path.append(os.pardir)  # Needed for sidewinder import before we install it\n",
@@ -20,7 +30,8 @@
     "\n",
     "from sidewinder.synthetic import synthetic_arterial_pressure_data\n",
     "from sidewinder.waveforms import Waveforms\n",
-    "from sidewinder import features"
+    "from sidewinder.features.waveform import find_troughs\n",
+    "from sidewinder.features import cycle"
    ]
   },
   {
@@ -34,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -101,7 +112,7 @@
        "4  0.020  82.081690"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -120,12 +131,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 720x180 with 1 Axes>"
       ]
@@ -152,7 +163,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -170,21 +181,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
-    "wf = features.find_troughs(wf, name='pressure')"
+    "wf = find_troughs(wf, name='pressure')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 720x180 with 1 Axes>"
       ]
@@ -199,21 +210,68 @@
     "fig, ax = plt.subplots(figsize=(10, 2.5), constrained_layout=True)\n",
     "ax.plot(data.time, data.pressure)\n",
     "ax.scatter(\n",
-    "    data.time[wf.features['pressure']['troughs']],\n",
-    "    data.pressure[wf.features['pressure']['troughs']],\n",
+    "    data.time[wf.waveform_features['pressure']['troughs']],\n",
+    "    data.pressure[wf.waveform_features['pressure']['troughs']],\n",
     "    color='red',\n",
     ")\n",
     "ax.set(xlabel='Time (s)', ylabel='Arterial pressure (mmHg)')\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Extract per-cycle features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for feature_extractor in [\n",
+    "    cycle.Duration,\n",
+    "    cycle.MaximumValue,\n",
+    "    cycle.MinimumValue,\n",
+    "    cycle.MeanValue,\n",
+    "    cycle.MaximumMinusMinimumValue,\n",
+    "    cycle.MeanNegativeFirstDifference\n",
+    "]:\n",
+    "    wf = feature_extractor().extract_feature(wf, 'pressure')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'pressure': {'Duration': array([0.85 , 0.86 , 0.855, 0.86 , 0.855]),\n",
+       "  'MaximumValue': array([120.        , 119.97736746, 119.99709951, 119.99027587,\n",
+       "         119.98921318]),\n",
+       "  'MinimumValue': array([80.00332686, 80.00103817, 80.00103817, 80.00115878, 80.        ]),\n",
+       "  'MeanValue': array([92.64628119, 92.50011353, 92.57275326, 92.50011546, 92.57275413]),\n",
+       "  'MaximumMinusMinimumValue': array([39.99667314, 39.97632929, 39.99606134, 39.98911708, 39.98921318]),\n",
+       "  'MeanNegativeFirstDifference': array([-0.2996558 , -0.29514956, -0.2996549 , -0.29734221, -0.29958959])}}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "wf.cycle_features"
+   ]
   }
  ],
  "metadata": {
-  "interpreter": {
-   "hash": "f2c1554fc2f673ff3983ee6916670176b140c542ca5d14124814c0e65b9d8c04"
-  },
   "kernelspec": {
-   "display_name": "Python 3.9.9 64-bit ('sidewinder-lxfscp8q-py3.9': poetry)",
+   "display_name": "Python 3.9.9 ('sidewinder-lxfscp8q-py3.9')",
    "language": "python",
    "name": "python3"
   },
@@ -229,7 +287,12 @@
    "pygments_lexer": "ipython3",
    "version": "3.9.9"
   },
-  "orig_nbformat": 4
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "f2c1554fc2f673ff3983ee6916670176b140c542ca5d14124814c0e65b9d8c04"
+   }
+  }
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/poetry.lock b/poetry.lock
index 623ffd9..a76e906 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -287,6 +287,33 @@ python-versions = ">=3.5"
 [package.dependencies]
 traitlets = "*"
 
+[[package]]
+name = "mypy"
+version = "0.971"
+description = "Optional static typing for Python"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+mypy-extensions = ">=0.4.3"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+typed-ast = {version = ">=1.4.0,<2", markers = "python_version < \"3.8\""}
+typing-extensions = ">=3.10"
+
+[package.extras]
+dmypy = ["psutil (>=4.0)"]
+python2 = ["typed-ast (>=1.4.0,<2)"]
+reports = ["lxml"]
+
+[[package]]
+name = "mypy-extensions"
+version = "0.4.3"
+description = "Experimental type system extensions for programs checked with the mypy typechecker."
+category = "dev"
+optional = false
+python-versions = "*"
+
 [[package]]
 name = "nest-asyncio"
 version = "1.5.4"
@@ -619,6 +646,14 @@ python-versions = ">=3.7"
 [package.extras]
 test = ["pytest"]
 
+[[package]]
+name = "typed-ast"
+version = "1.5.4"
+description = "a fork of Python 2 and 3 ast modules with type comment support"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
 [[package]]
 name = "typing-extensions"
 version = "4.0.1"
@@ -650,7 +685,7 @@ testing = ["pytest (>=4.6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytes
 [metadata]
 lock-version = "1.1"
 python-versions = ">=3.7.1,<3.11"
-content-hash = "e13cc28f1bb7c0508cd25ae14f1101c8a3c2e32e358dc1c28f7defecdb58c9f8"
+content-hash = "b6fb71b2147dddb759e240492f555e6714629e8a1acc91aadb2c6624ebdd468f"
 
 [metadata.files]
 appnope = [
@@ -883,6 +918,11 @@ matplotlib-inline = [
     {file = "matplotlib-inline-0.1.3.tar.gz", hash = "sha256:a04bfba22e0d1395479f866853ec1ee28eea1485c1d69a6faf00dc3e24ff34ee"},
     {file = "matplotlib_inline-0.1.3-py3-none-any.whl", hash = "sha256:aed605ba3b72462d64d475a21a9296f400a19c4f74a31b59103d2a99ffd5aa5c"},
 ]
+mypy = []
+mypy-extensions = [
+    {file = "mypy_extensions-0.4.3-py2.py3-none-any.whl", hash = "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d"},
+    {file = "mypy_extensions-0.4.3.tar.gz", hash = "sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8"},
+]
 nest-asyncio = [
     {file = "nest_asyncio-1.5.4-py3-none-any.whl", hash = "sha256:3fdd0d6061a2bb16f21fe8a9c6a7945be83521d81a0d15cff52e9edee50101d6"},
     {file = "nest_asyncio-1.5.4.tar.gz", hash = "sha256:f969f6013a16fadb4adcf09d11a68a4f617c6049d7af7ac2c676110169a63abd"},
@@ -1217,6 +1257,7 @@ traitlets = [
     {file = "traitlets-5.1.1-py3-none-any.whl", hash = "sha256:2d313cc50a42cd6c277e7d7dc8d4d7fedd06a2c215f78766ae7b1a66277e0033"},
     {file = "traitlets-5.1.1.tar.gz", hash = "sha256:059f456c5a7c1c82b98c2e8c799f39c9b8128f6d0d46941ee118daace9eb70c7"},
 ]
+typed-ast = []
 typing-extensions = [
     {file = "typing_extensions-4.0.1-py3-none-any.whl", hash = "sha256:7f001e5ac290a0c0401508864c7ec868be4e701886d5b573a9528ed3973d9d3b"},
     {file = "typing_extensions-4.0.1.tar.gz", hash = "sha256:4ca091dea149f945ec56afb48dae714f21e8692ef22a395223bcd328961b6a0e"},
diff --git a/pyproject.toml b/pyproject.toml
index c2134cb..21bc2cb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,6 +16,7 @@ pyampd = "^0.0.1"
 pytest = "^6.2.5"
 ipykernel = "^6.6.0"
 statsmodels = "^0.13.1"
+mypy = "^0.971"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
diff --git a/sidewinder/features/__init__.py b/sidewinder/features/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/sidewinder/features/cycle.py b/sidewinder/features/cycle.py
new file mode 100644
index 0000000..dcc12fb
--- /dev/null
+++ b/sidewinder/features/cycle.py
@@ -0,0 +1,143 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+import numpy as np
+import pandas as pd
+
+from ..waveforms import Waveforms
+
+
+def get_cycles(waveforms: Waveforms, name: str) -> List[pd.DataFrame]:
+    """Makes a list of the individual cycles from a waveform. This is useful
+    for per-cycle feature extraction.
+
+    Each cycle includes the troughs at its start and end.
+
+    Args:
+        waveforms: `sidewinder.waveforms.Waveforms` instance holding your data
+        name: Name of column in `waveforms` to get cycles for
+
+    Returns:
+        Each element contains data from one cycle (e.g. a heartbeat)
+    """
+    return [
+        waveforms.waveforms.iloc[
+            waveforms.waveform_features[name]["troughs"][
+                cycle_i
+            ] : waveforms.waveform_features[name]["troughs"][cycle_i + 1]
+            + 1
+        ]
+        for cycle_i in range(
+            waveforms.waveform_features[name]["troughs"].size - 1
+        )
+    ]
+
+
+class CycleFeatureExtractor(ABC):
+    """Abstract base class for per-cycle (e.g. per heartbeat) feature
+    extraction classes."""
+
+    @property
+    def class_name(self) -> str:
+        """The name of the class itself."""
+        return self.__class__.__name__
+
+    @abstractmethod
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        """Extracts a feature for each cycle in a waveform.
+
+        Args:
+            waveforms: `sidewinder.waveforms.Waveforms` instance holding your
+                data
+            name: Name of column in `waveforms` to extract feature from
+
+        Returns:
+            `waveforms` with new np.ndarray of shape (n_cycles,) at
+                `waveforms.cycle_features[`name`][`self.class_name`]`
+                where each element is the feature for the corresponding cycle
+        """
+        pass
+
+
+class Duration(CycleFeatureExtractor):
+    """Calculates duration (seconds) of each cycle in the waveform."""
+
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        feature = [
+            cycle[waveforms.time_column_name].values[-1]
+            - cycle[waveforms.time_column_name].values[0]
+            for cycle in get_cycles(waveforms, name)
+        ]
+        waveforms.cycle_features[name][self.class_name] = np.array(feature)
+        return waveforms
+
+
+class MaximumValue(CycleFeatureExtractor):
+    """Calculates maximum value of each cycle in the waveform."""
+
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        feature = [cycle[name].max() for cycle in get_cycles(waveforms, name)]
+        waveforms.cycle_features[name][self.class_name] = np.array(feature)
+        return waveforms
+
+
+class MinimumValue(CycleFeatureExtractor):
+    """Calculates minimum value of each cycle in the waveform."""
+
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        feature = [cycle[name].min() for cycle in get_cycles(waveforms, name)]
+        waveforms.cycle_features[name][self.class_name] = np.array(feature)
+        return waveforms
+
+
+class MaximumMinusMinimumValue(CycleFeatureExtractor):
+    """Calculates maximum minus minimum value of each cycle in the waveform."""
+
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        feature = [
+            cycle[name].max() - cycle[name].min()
+            for cycle in get_cycles(waveforms, name)
+        ]
+        waveforms.cycle_features[name][self.class_name] = np.array(feature)
+        return waveforms
+
+
+class MeanValue(CycleFeatureExtractor):
+    """Calculates mean value of each cycle in the waveform."""
+
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        feature = [cycle[name].mean() for cycle in get_cycles(waveforms, name)]
+        waveforms.cycle_features[name][self.class_name] = np.array(feature)
+        return waveforms
+
+
+class MeanNegativeFirstDifference(CycleFeatureExtractor):
+    """Calculates the mean of only the negative first differences for each cycle
+    in the waveform. This feature is similar to `mean_dyneg` from
+    https://bit.ly/3AwtazE"""
+
+    def extract_feature(self, waveforms: Waveforms, name: str) -> Waveforms:
+        feature = [
+            np.mean(
+                self._remove_zeros(
+                    np.clip(
+                        np.diff(cycle[name].values, n=1, axis=0),
+                        a_min=None,
+                        a_max=0,
+                    )
+                )
+            )
+            for cycle in get_cycles(waveforms, name)
+        ]
+        # TODO: See https://github.com/UCL-Chimera/sidewinder/issues/16
+
+        waveforms.cycle_features[name][self.class_name] = np.array(feature)
+        return waveforms
+
+    @staticmethod
+    def _remove_zeros(array: np.ndarray) -> np.ndarray:
+        zeros_removed = array[array < 0]
+        if zeros_removed.size > 0:
+            return zeros_removed
+        # if no negative differences, indicates poor quality waveform
+        return np.array([-np.inf])
diff --git a/sidewinder/features.py b/sidewinder/features/waveform.py
similarity index 59%
rename from sidewinder/features.py
rename to sidewinder/features/waveform.py
index f2f2ca5..cbfaa9e 100644
--- a/sidewinder/features.py
+++ b/sidewinder/features/waveform.py
@@ -1,20 +1,21 @@
 from pyampd import ampd
 
-from .waveforms import Waveforms
+from ..waveforms import Waveforms
 
 
-def find_troughs(waveforms: Waveforms, name: str):
+def find_troughs(waveforms: Waveforms, name: str) -> Waveforms:
     """Finds indices of troughs in a waveform.
 
     Args:
-        waveforms: `sidewinder.waveforms.Waveforms` instance holding you data
+        waveforms: `sidewinder.waveforms.Waveforms` instance holding your data
         name: Name of column in `waveforms` to find troughs in
 
     Returns:
-        `waveforms` with trough indices added to `waveforms.features[`name`]`
+        `waveforms` with trough indices added to
+            `waveforms.waveform_features[`name`]['troughs']`
     """
     waveforms.waveforms[name] *= -1  # invert signal, so troughs become peaks
-    waveforms.features[name]['troughs'] = ampd.find_peaks(
+    waveforms.waveform_features[name]["troughs"] = ampd.find_peaks(
         waveforms.waveforms[name]
     )
     waveforms.waveforms[name] *= -1  # un-invert signal
diff --git a/sidewinder/synthetic.py b/sidewinder/synthetic.py
index 2439cb1..f9a9112 100644
--- a/sidewinder/synthetic.py
+++ b/sidewinder/synthetic.py
@@ -1,5 +1,6 @@
-import os
 import math
+import os
+from typing import Tuple
 
 import numpy as np
 import pandas as pd
@@ -21,14 +22,14 @@ def make_waveform_generator_from_file(filepath: str) -> interpolate.interp1d:
     """
     waveform = np.load(filepath)
     time = np.linspace(start=0, stop=1, num=waveform.size)
-    return interpolate.interp1d(time, waveform, kind='cubic')
+    return interpolate.interp1d(
+        time, waveform, kind="cubic", fill_value="extrapolate"
+    )
 
 
 def make_generator_timestamps_and_inputs(
-    cycles_per_minute: float,
-    n_cycles_target: float,
-    hertz: float
-) -> (np.ndarray, np.ndarray):
+    cycles_per_minute: float, n_cycles_target: float, hertz: float
+) -> Tuple[np.ndarray, np.ndarray]:
     """Make timestamps and corresponding inputs for a synthetic waveform
         generator function.
 
@@ -45,12 +46,16 @@ def make_generator_timestamps_and_inputs(
         Inputs. The units are standardised such that 0 is the start of the
             generated waveform and 1 is the end.
     """
-    seconds_per_cycle = 60. / cycles_per_minute
+    seconds_per_cycle = 60.0 / cycles_per_minute
     dt = 1 / hertz
     fractional_samples_per_cycle = seconds_per_cycle / dt
-    n_samples = round(fractional_samples_per_cycle * n_cycles_target)
-    n_seconds = n_samples * dt
-    n_cycles_actual = n_samples / fractional_samples_per_cycle
+
+    # Add 1 as we have a sample at time zero
+    n_samples = round(fractional_samples_per_cycle * n_cycles_target) + 1
+
+    # Minus 1 to account for the zero sample
+    n_seconds = (n_samples - 1) * dt
+    n_cycles_actual = (n_samples - 1) / fractional_samples_per_cycle
     n_cycle_starts = math.ceil(n_cycles_actual)
 
     start_times = np.zeros(n_cycle_starts)
@@ -58,11 +63,11 @@ def make_generator_timestamps_and_inputs(
         np.repeat(seconds_per_cycle, n_cycle_starts - 1)
     )
 
-    timestamps = np.linspace(0, n_seconds, n_samples, endpoint=False)
+    timestamps = np.linspace(0, n_seconds, n_samples, endpoint=True)
 
-    """`insertion_i` is the indices where `start_times` would be inserted into
-    `timestamps` to maintain order. Each element in `offsets` is the number
-    of seconds that elapse in a cycle before the first sample in that cycle."""
+    # `insertion_i` is the indices where `start_times` would be inserted into
+    #  `timestamps` to maintain order. Each element in `offsets` is the number
+    #  of seconds that elapse in a cycle before the first sample in that cycle.
     insertion_i = np.searchsorted(timestamps, start_times)
     offsets = timestamps[insertion_i] - start_times
 
@@ -72,15 +77,21 @@ def make_generator_timestamps_and_inputs(
     samples_per_cycle = samples_per_cycle.astype(int)
 
     def cycle_timestamps(cycle_i: int) -> np.ndarray:
-        return np.linspace(
-            start=0,
-            stop=(samples_per_cycle[cycle_i] - 1) / hertz,
-            num=samples_per_cycle[cycle_i]
-        ) + offsets[cycle_i]
-
-    inputs = np.concatenate([
-        cycle_timestamps(cycle_i) for cycle_i in range(n_cycle_starts)
-    ]) / seconds_per_cycle
+        return (
+            np.linspace(
+                start=0,
+                stop=(samples_per_cycle[cycle_i] - 1) / hertz,
+                num=samples_per_cycle[cycle_i],
+            )
+            + offsets[cycle_i]
+        )
+
+    inputs = (
+        np.concatenate(
+            [cycle_timestamps(cycle_i) for cycle_i in range(n_cycle_starts)]
+        )
+        / seconds_per_cycle
+    )
 
     return timestamps, inputs
 
@@ -90,7 +101,7 @@ def synthetic_arterial_pressure_data(
     diastolic_pressure: float,
     heart_rate: float,
     n_beats_target: float,
-    hertz: float
+    hertz: float,
 ) -> pd.DataFrame:
     """Make synthetic arterial pressure data.
 
@@ -112,13 +123,13 @@ def synthetic_arterial_pressure_data(
     timestamps, inputs = make_generator_timestamps_and_inputs(
         cycles_per_minute=heart_rate,
         n_cycles_target=n_beats_target,
-        hertz=hertz
+        hertz=hertz,
     )
     waveform_filepath = os.path.join(
         get_root_directory(),
-        'sidewinder',
-        'data',
-        'example_arterial_pressure_waveform.npy'
+        "sidewinder",
+        "data",
+        "example_arterial_pressure_waveform.npy",
     )
     generator = make_waveform_generator_from_file(waveform_filepath)
     waveform = generator(inputs)
@@ -126,7 +137,7 @@ def synthetic_arterial_pressure_data(
     # Scale
     waveform -= waveform.min()
     waveform /= waveform.max()
-    waveform *= (systolic_pressure - diastolic_pressure)
+    waveform *= systolic_pressure - diastolic_pressure
     waveform += diastolic_pressure
 
-    return pd.DataFrame({'time': timestamps, 'pressure': waveform})
+    return pd.DataFrame({"time": timestamps, "pressure": waveform})
diff --git a/sidewinder/waveforms.py b/sidewinder/waveforms.py
index 33982c2..e6bab1e 100644
--- a/sidewinder/waveforms.py
+++ b/sidewinder/waveforms.py
@@ -1,4 +1,4 @@
-from typing import Tuple, Dict
+from typing import Dict, Tuple
 
 import numpy as np
 import pandas as pd
@@ -7,7 +7,9 @@
 class Waveforms:
     """Holds waveforms for downstream processing."""
 
-    def __init__(self, waveforms: pd.DataFrame, time_column_name: str = 'time'):
+    def __init__(
+        self, waveforms: pd.DataFrame, time_column_name: str = "time"
+    ):
         """
         Args:
             waveforms: Contains a timestamps column (in seconds) and one or more
@@ -18,12 +20,13 @@ def __init__(self, waveforms: pd.DataFrame, time_column_name: str = 'time'):
         self.time_column_name = time_column_name
         self._validate_arguments()
         self.names = self._init_names()
-        self.features = self._init_features()
+        self.waveform_features = self._init_features_container()
+        self.cycle_features = self._init_features_container()
 
     def _validate_arguments(self):
-        assert isinstance(self.waveforms, pd.DataFrame), (
-            '`waveforms` must be a pandas DataFrame'
-        )
+        assert isinstance(
+            self.waveforms, pd.DataFrame
+        ), "`waveforms` must be a pandas DataFrame"
         assert self.time_column_name in self.waveforms.columns, (
             "`waveforms` must contain a column called "
             f"'{self.time_column_name}'"
@@ -33,11 +36,12 @@ def _init_names(self) -> Tuple[str, ...]:
         """Makes a tuple of names of the waveform-containing columns in
         self.waveforms"""
         return tuple(
-            name for name in self.waveforms.columns
+            name
+            for name in self.waveforms.columns
             if name is not self.time_column_name
         )
 
-    def _init_features(self) -> Dict[str, Dict[str, np.ndarray]]:
-        """Makes the holder for waveform features (the features themselves
-        haven't been derived yet)"""
+    def _init_features_container(self) -> Dict[str, Dict[str, np.ndarray]]:
+        """Makes a holder for features (the features themselves haven't been
+        derived yet)"""
         return {name: {} for name in self.names}


Test patch:
diff --git a/tests/test_features.py b/tests/test_features.py
index 3e55623..0338dc3 100644
--- a/tests/test_features.py
+++ b/tests/test_features.py
@@ -1,19 +1,120 @@
 import numpy as np
+import pandas as pd
+import pytest
+from numpy.testing import assert_allclose, assert_equal
 
-from sidewinder import synthetic, waveforms, features
+from sidewinder import synthetic, waveforms
+from sidewinder.features import cycle, waveform
 
 
-def test_find_troughs():
-    data = synthetic.synthetic_arterial_pressure_data(
-        systolic_pressure=120.,
-        diastolic_pressure=80.,
-        heart_rate=60.,
-        n_beats_target=2.5,
-        hertz=10.
+@pytest.fixture(scope="function")
+def abp_data_fixture() -> pd.DataFrame:
+    return synthetic.synthetic_arterial_pressure_data(
+        systolic_pressure=120.0,
+        diastolic_pressure=80.0,
+        heart_rate=60.0,
+        n_beats_target=2.3,
+        hertz=10.0,
     )
-    w = waveforms.Waveforms(data)
-    w = features.find_troughs(w, name='pressure')
-    np.testing.assert_array_equal(
-        w.features['pressure']['troughs'],
-        np.array([0, 10, 20])
+
+
+@pytest.fixture(scope="function")
+def abp_waveforms_fixture(abp_data_fixture) -> waveforms.Waveforms:
+    w = waveforms.Waveforms(abp_data_fixture)
+    w = waveform.find_troughs(w, name="pressure")
+    return w
+
+
+def test_find_troughs(abp_waveforms_fixture):
+    assert_equal(
+        abp_waveforms_fixture.waveform_features["pressure"]["troughs"],
+        np.array([0, 10, 20]),
     )
+
+
+def test_get_cycles(abp_waveforms_fixture):
+    expected = cycle.get_cycles(abp_waveforms_fixture, "pressure")
+    assert len(expected) == 2
+    assert_equal(
+        expected[0].pressure.values,
+        abp_waveforms_fixture.waveforms.pressure.values[:11],
+    )
+    assert_equal(
+        expected[1].pressure.values,
+        abp_waveforms_fixture.waveforms.pressure.values[10:21],
+    )
+
+
+class TestDuration:
+    def test_extract_feature(self, abp_waveforms_fixture):
+        wf = cycle.Duration().extract_feature(
+            abp_waveforms_fixture, "pressure"
+        )
+        assert_equal(
+            wf.cycle_features["pressure"]["Duration"], np.array([1.0, 1.0])
+        )
+
+
+class TestMaximumValue:
+    def test_extract_feature(self, abp_waveforms_fixture):
+        wf = cycle.MaximumValue().extract_feature(
+            abp_waveforms_fixture, "pressure"
+        )
+        assert_equal(
+            wf.cycle_features["pressure"]["MaximumValue"],
+            np.array([120.0, 120.0]),
+        )
+
+
+class TestMinimumValue:
+    def test_extract_feature(self, abp_waveforms_fixture):
+        wf = cycle.MinimumValue().extract_feature(
+            abp_waveforms_fixture, "pressure"
+        )
+        assert_equal(
+            wf.cycle_features["pressure"]["MinimumValue"],
+            np.array([80.0, 80.0]),
+        )
+
+
+class TestMaximumMinusMinimumValue:
+    def test_extract_feature(self, abp_waveforms_fixture):
+        wf = cycle.MaximumMinusMinimumValue().extract_feature(
+            abp_waveforms_fixture, "pressure"
+        )
+        expected_pulse_pressure = 120.0 - 80.0
+        assert_equal(
+            wf.cycle_features["pressure"]["MaximumMinusMinimumValue"],
+            np.array([expected_pulse_pressure, expected_pulse_pressure]),
+        )
+
+
+class TestMeanValue:
+    def test_extract_feature(self, abp_waveforms_fixture):
+        wf = cycle.MeanValue().extract_feature(
+            abp_waveforms_fixture, "pressure"
+        )
+        approx_expected_map = 80.0 + (120.0 - 80.0) / 3
+        assert_allclose(
+            wf.cycle_features["pressure"]["MeanValue"],
+            np.array([approx_expected_map, approx_expected_map]),
+            atol=1.0,  # allow approximation to be wrong by <1mmHg
+        )
+
+
+class TestMeanNegativeFirstDifference:
+    def test_extract_feature(self):
+        # Make simple synthetic signal where MNFD is predictable (note that it
+        #  contains zeros which will have to be removed). Note that 'time' is
+        #  ignored. See See https://github.com/UCL-Chimera/sidewinder/issues/16
+        data = pd.DataFrame({"time": [0, 1, 2, 3], "signal": [0, 0, 1, 0]})
+        wf = waveforms.Waveforms(data)
+
+        # Define manual troughs such that the data contains a single cycle
+        wf.waveform_features["signal"]["troughs"] = np.array([0, 3])
+
+        wf = cycle.MeanNegativeFirstDifference().extract_feature(wf, "signal")
+        assert_equal(
+            wf.cycle_features["signal"]["MeanNegativeFirstDifference"],
+            np.array([-1]),
+        )
diff --git a/tests/test_synthetic.py b/tests/test_synthetic.py
index 8322bdf..6ac2f19 100644
--- a/tests/test_synthetic.py
+++ b/tests/test_synthetic.py
@@ -2,18 +2,18 @@
 
 import numpy as np
 import pandas as pd
+from numpy.testing import assert_equal
 from scipy import interpolate
 
-from sidewinder import utils
-from sidewinder import synthetic
+from sidewinder import synthetic, utils
 
 
 def test_make_waveform_generator_from_file():
     waveform_filepath = os.path.join(
         utils.get_root_directory(),
-        'sidewinder',
-        'data',
-        'example_arterial_pressure_waveform.npy'
+        "sidewinder",
+        "data",
+        "example_arterial_pressure_waveform.npy",
     )
     generator = synthetic.make_waveform_generator_from_file(waveform_filepath)
     assert isinstance(generator, interpolate.interp1d)
@@ -21,24 +21,30 @@ def test_make_waveform_generator_from_file():
 
 def test_make_generator_timestamps_and_inputs():
     timestamps, inputs = synthetic.make_generator_timestamps_and_inputs(
-        cycles_per_minute=60.,
-        n_cycles_target=2.,
-        hertz=10.
+        cycles_per_minute=60.0, n_cycles_target=2.0, hertz=10.0
+    )
+    assert_equal(timestamps, np.linspace(0, 2, 21, endpoint=True))
+    assert_equal(
+        inputs,
+        np.concatenate(
+            [
+                np.linspace(0, 1, 10, endpoint=False),
+                np.linspace(0, 1, 11, endpoint=True),
+            ]
+        ),
     )
-    assert (timestamps == np.linspace(0, 2, 20, endpoint=False)).all()
-    assert (inputs == np.tile(np.linspace(0, 1, 10, endpoint=False), 2)).all()
 
 
 def test_synthetic_arterial_pressure_data():
     art = synthetic.synthetic_arterial_pressure_data(
-        systolic_pressure=120.,
-        diastolic_pressure=80.,
-        heart_rate=60.,
-        n_beats_target=2.,
-        hertz=10.
+        systolic_pressure=120.0,
+        diastolic_pressure=80.0,
+        heart_rate=60.0,
+        n_beats_target=2.0,
+        hertz=10.0,
     )
-    assert (art.time.values == np.linspace(0, 2, 20, endpoint=False)).all()
-    assert art.pressure.max() == 120.
-    assert art.pressure.min() == 80.
-    assert art.shape == (20, 2)
+    assert_equal(art.time.values, np.linspace(0, 2, 21, endpoint=True))
+    assert art.pressure.max() == 120.0
+    assert art.pressure.min() == 80.0
+    assert art.shape == (21, 2)
     assert isinstance(art, pd.DataFrame)
diff --git a/tests/test_utils.py b/tests/test_utils.py
index e135ff0..a28e300 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -5,5 +5,5 @@
 
 def test_get_root_directory():
     root_dir_files = os.listdir(utils.get_root_directory())
-    assert 'README.md' in root_dir_files
-    assert 'sidewinder' in root_dir_files
+    assert "README.md" in root_dir_files
+    assert "sidewinder" in root_dir_files
diff --git a/tests/test_waveforms.py b/tests/test_waveforms.py
index 4a82c3e..444a85b 100644
--- a/tests/test_waveforms.py
+++ b/tests/test_waveforms.py
@@ -1,15 +1,15 @@
-import pytest
 import pandas as pd
+import pytest
 
 from sidewinder import waveforms
 
 
 class TestWaveforms:
-    @pytest.fixture(scope='class')
+    @pytest.fixture(scope="class")
     def example_data(self):
-        return pd.DataFrame({'time': [1, 2, 3], 'signal': [0.1, 0.4, 0.8]})
+        return pd.DataFrame({"time": [1, 2, 3], "signal": [0.1, 0.4, 0.8]})
 
-    @pytest.fixture(scope='class')
+    @pytest.fixture(scope="class")
     def example_waveforms(self, example_data):
         return waveforms.Waveforms(waveforms=example_data)
 
@@ -21,11 +21,12 @@ def test_validate_time_column_name(self, example_data):
         with pytest.raises(Exception):
             waveforms.Waveforms(
                 waveforms=example_data,
-                time_column_name='a_different_time_column_name'
+                time_column_name="a_different_time_column_name",
             )
 
     def test_names(self, example_waveforms):
-        assert example_waveforms.names == ('signal',)
+        assert example_waveforms.names == ("signal",)
 
     def test_features(self, example_waveforms):
-        assert example_waveforms.features == {'signal': {}}
+        assert example_waveforms.waveform_features == {"signal": {}}
+        assert example_waveforms.cycle_features == {"signal": {}}