diff --git a/.gitignore b/.gitignore
index 881bd15..4691721 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,7 +29,11 @@ suite2p.egg-info/
build/
FaceMap/ops_user.npy
*.ipynb
+*.pth
+*.pt
+*.gif
+#
# =========================
# Operating System Files
# =========================
diff --git a/README.md b/README.md
index bdf0b57..dce8b35 100644
--- a/README.md
+++ b/README.md
@@ -1,28 +1,25 @@
-# facemap 
+[](https://pepy.tech/project/facemap)
+[](https://pepy.tech/project/facemap)
+[](https://github.com/MouseLand/facemap/stargazers)
+[](https://github.com/MouseLand/facemap/network/members)
+[](https://github.com/MouseLand/facemap/blob/main/LICENSE)
+[](https://badge.fury.io/py/facemap)
+[](https://pypi.org/project/facemap/)
+[](https://github.com/MouseLand/facemap/issues)
-GUI for processing videos of rodents, implemented in python and MATLAB. Works for grayscale and RGB movies. Can process multi-camera videos. Some example movies to test the GUI on are located [here](https://drive.google.com/open?id=1cRWCDl8jxWToz50dCX1Op-dHcAC-ttto). You can save the output from both the python and matlab versions as a matlab file with a checkbox in the GUI (if you'd like to use the python version - it has a better GUI).
+# Facemap
-# Data acquisition info
+Pose tracking of mouse face from different camera views (python only) and svd processing of videos (python and MATLAB). Includes GUI and CLI for easy use.
-IR ILLUMINATION:
+## [Installation](https://github.com/MouseLand/facemap/blob/dev/docs/installation.md)
-For recording in darkness we use [IR illumination](https://www.amazon.com/Logisaf-Invisible-Infrared-Security-Cameras/dp/B01MQW8K7Z/ref=sr_1_12?s=security-surveillance&ie=UTF8&qid=1505507302&sr=1-12&keywords=ir+light) at 850nm, which works well with 2p imaging at 970nm and even 920nm. Depending on your needs, you might want to choose a different wavelength, which changes all the filters below as well. 950nm works just as well, and probably so does 750nm, which still outside of the visible range for rodents.
+- For latest released version (from PyPI) including svd processing only, run `pip install facemap` for headless version or `pip install facemap[gui]` for using GUI.
-If you want to focus the illumination on the mouse eye or face, you will need a different, more expensive system. Here is an example, courtesy of Michael Krumin from the Carandini lab: [driver](https://www.thorlabs.com/thorproduct.cfm?partnumber=LEDD1B), [power supply](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=1710&pn=KPS101#8865), [LED](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=2692&pn=M850L3#4426), [lens](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=259&pn=AC254-030-B#2231), and [lens tube](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=4109&pn=SM1V10#3389), and another [lens tube](https://www.thorlabs.com/thorproduct.cfm?partnumber=SM1L10).
-
-CAMERAS:
-
-We use [ptgrey cameras](https://www.ptgrey.com/flea3-13-mp-mono-usb3-vision-vita-1300-camera). The software we use for simultaneous acquisition from multiple cameras is [BIAS](http://public.iorodeo.com/notes/bias/) software. A basic lens that works for zoomed out views [here](https://www.bhphotovideo.com/c/product/414195-REG/Tamron_12VM412ASIR_12VM412ASIR_1_2_4_12_F_1_2.html). To see the pupil well you might need a better zoom lens [10x here](https://www.edmundoptics.com/imaging-lenses/zoom-lenses/10x-13-130mm-fl-c-mount-close-focus-zoom-lens/#specs).
-
-For 2p imaging, you'll need a tighter filter around 850nm so you don't see the laser shining through the mouse's eye/head, for example [this](https://www.thorlabs.de/thorproduct.cfm?partnumber=FB850-40). Depending on your lenses you'll need to figure out the right adapter(s) for such a filter. For our 10x lens above, you might need all of these: [adapter1](https://www.edmundoptics.com/optics/optical-filters/optical-filter-accessories/M52-to-M46-Filter-Thread-Adapter/), [adapter2](https://www.thorlabs.de/thorproduct.cfm?partnumber=SM2A53), [adapter3](https://www.thorlabs.de/thorproduct.cfm?partnumber=SM2A6), [adapter4](https://www.thorlabs.de/thorproduct.cfm?partnumber=SM1L03).
+- For using tracker and svd processing, run `pip install git+https://github.com/mouseland/facemap.git` that will install the latest development version on github.
-# Installation
+To upgrade Facemap ([PyPI package](https://pypi.org/project/facemap/)), within the environment run: `pip install facemap --upgrade`
-## PYTHON
-
-This package only supports python 3. We recommend installing python 3 with **[Anaconda](https://www.anaconda.com/download/)**.
-
-### Using the environment.yml file (recommended)
+Facemap installeding is recommended using the environment.yml:
1. Download the `environment.yml` file from the repository
2. Open an anaconda prompt / command prompt with `conda` for **python 3** in the path
@@ -30,98 +27,67 @@ This package only supports python 3. We recommend installing python 3 with **[An
4. To activate this new environment, run `conda activate facemap`
5. You should see `(facemap)` on the left side of the terminal line. Now run `python -m facemap` and you're all set.
-To upgrade FaceMap (package [here](https://pypi.org/project/facemap/)), within the environment run:
-~~~~
-pip install facemap --upgrade
-~~~~
-
-### Using pip package
-
-Run the following
-~~~
-pip install facemap
-~~~
+# Pose tracking
-If you are using running ROIs, you will want to install mkl_fft via conda:
-~~~~
-conda install -c conda-forge mkl_fft
-~~~~
+
-### Common issues
+The latest python version is integrated with Facemap network for tracking 14 distinct keypoints on mouse face and an additional point for tracking paw. The keypoints can be tracked from different camera views (some examples shown below).
-If you have pip issues, there might be some interaction between pre-installed dependencies and the ones FaceMap needs. First thing to try is
-~~~~
-python -m pip install --upgrade pip
-~~~~
+
+
+
+
+
+## [GUI Instructions](docs/pose_tracking_gui_tutorial.md)
+For pose tracking, load video and check `keypoints` then click `process` button. A dialog box will appear for selecting a bounding box for the face. The keypoints will be tracked in the selected bounding box. Please ensure that the bouding box is focused on the face where all the keypoints shown above will be visible. See example frames [here](figs/mouse_views.png).
-If when running `python -m facemap`, you receive the error: `No module named PyQt5.sip`, then try uninstalling and reinstalling pyqt5
-~~~
-pip uninstall pyqt5 pyqt5-tools
-pip install pyqt5 pyqt5-tools pyqt5.sip
-~~~
+Use the file menu to set path of output folder. The processed keypoints file will be saved in the output folder with an extension of `.h5` and corresponding metadata file with extension `.pkl`.
-If you are on Yosemite Mac OS, PyQt doesn't work, and you won't be able to install FaceMap. More recent versions of Mac OS are fine.
+## [CLI Instructions](docs/pose_tracking_cli_tutorial.md)
-The software has been heavily tested on Ubuntu 18.04, and less well tested on Windows 10 and Mac OS. Please post an issue if you have installation problems.
+For more examples, please see [tutorial notebooks](https://github.com/MouseLand/facemap/tree/dev/notebooks).
-### Dependencies
+## :mega: User contributions :video_camera: :camera:
+Facemap's goal is to provide a simple way to generate keypoints for rodent face tracking. However, we need a large dataset of images from different camera views to reduce any errors on new mice videos. Hence, we would like to get your help to further expand our dataset. You can contribute by sending us a video or few frames of your mouse on following email address(es): `syedaa[at]janelia.hhmi.org` or `stringerc[at]janelia.hhmi.org`. Please let us know of any issues using the software by sending us an email or [opening an issue on GitHub](https://github.com/MouseLand/facemap/issues).
-FaceMap python relies on these awesome packages:
-- [pyqtgraph](http://pyqtgraph.org/)
-- [PyQt5](http://pyqt.sourceforge.net/Docs/PyQt5/)
-- [numpy](http://www.numpy.org/) (>=1.13.0)
-- [scipy](https://www.scipy.org/)
-- [opencv](https://opencv.org/)
-- [numba](http://numba.pydata.org/numba-doc/latest/user/5minguide.html)
-- [natsort](https://natsort.readthedocs.io/en/master/)
-## MATLAB
+# SVD processing
-The matlab version needs to be downloaded/cloned from github (no install required). It works in Matlab 2014b and above - please submit issues if it's not working. The Image Processing Toolbox is necessary to use the GUI. For GPU functionality, the Parallel Processing Toolbox is required. If you don't have the Parallel Processing Toolbox, uncheck the box next to "use GPU" in the GUI before processing.
+Works for grayscale and RGB movies. Can process multi-camera videos. Some example movies to test the GUI on are located [here](https://drive.google.com/open?id=1cRWCDl8jxWToz50dCX1Op-dHcAC-ttto). You can save the output from both the python and matlab versions as a matlab file with a checkbox in the GUI (if you'd like to use the python version - it has a better GUI).
-### Supported movie files
+Supported movie files:
'.mj2','.mp4','.mkv','.avi','.mpeg','.mpg','.asf'
-# Start processing! *HOW TO GUI*
+### Data acquisition info
-## PYTHON
+IR ILLUMINATION:
-([video](https://www.youtube.com/watch?v=Rq8fEQ-DOm4) with old install instructions)
+For recording in darkness we use [IR illumination](https://www.amazon.com/Logisaf-Invisible-Infrared-Security-Cameras/dp/B01MQW8K7Z/ref=sr_1_12?s=security-surveillance&ie=UTF8&qid=1505507302&sr=1-12&keywords=ir+light) at 850nm, which works well with 2p imaging at 970nm and even 920nm. Depending on your needs, you might want to choose a different wavelength, which changes all the filters below as well. 950nm works just as well, and probably so does 750nm, which still outside of the visible range for rodents.
-
+If you want to focus the illumination on the mouse eye or face, you will need a different, more expensive system. Here is an example, courtesy of Michael Krumin from the Carandini lab: [driver](https://www.thorlabs.com/thorproduct.cfm?partnumber=LEDD1B), [power supply](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=1710&pn=KPS101#8865), [LED](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=2692&pn=M850L3#4426), [lens](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=259&pn=AC254-030-B#2231), and [lens tube](https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=4109&pn=SM1V10#3389), and another [lens tube](https://www.thorlabs.com/thorproduct.cfm?partnumber=SM1L10).
-Run the following command in a terminal
-```
-python -m facemap
-```
-The following window should appear. The upper left "file" button loads single files, the upper middle "folder" button loads whole folders (from which you can select movies), and the upper right "folder" button loads processed files ("_proc.npy" files). Load a video or a group of videos (see below for file formats for simultaneous videos). The video(s) will pop up in the left side of the GUI. You can zoom in and out with the mouse wheel, and you can drag by holding down the mouse. Double-click to return to the original, full view.
+CAMERAS:
-Choose a type of ROI to add and then click "add ROI" to add it to the view. The pixels in the ROI will show up in the right window (with different processing depending on the ROI type - see below). You can move it and resize the ROI anytime. You can delete the ROI with "right-click" and selecting "remove". You can change the saturation of the ROI with the upper right saturation bar. You can also just click on the ROI at any time to see what it looks like in the right view.
+We use [ptgrey cameras](https://www.ptgrey.com/flea3-13-mp-mono-usb3-vision-vita-1300-camera). The software we use for simultaneous acquisition from multiple cameras is [BIAS](http://public.iorodeo.com/notes/bias/) software. A basic lens that works for zoomed out views [here](https://www.bhphotovideo.com/c/product/414195-REG/Tamron_12VM412ASIR_12VM412ASIR_1_2_4_12_F_1_2.html). To see the pupil well you might need a better zoom lens [10x here](https://www.edmundoptics.com/imaging-lenses/zoom-lenses/10x-13-130mm-fl-c-mount-close-focus-zoom-lens/#specs).
-By default, the "Compute multivideo SVD" box is unchecked. If you check it, then the motion SVD is computed across ALL videos - all videos are concatenated at each timepoint, and the SVD of this matrix of ALL_PIXELS x timepoints is computed. If you have just one video acquired at a time, then it is the SVD of this video.
+For 2p imaging, you'll need a tighter filter around 850nm so you don't see the laser shining through the mouse's eye/head, for example [this](https://www.thorlabs.de/thorproduct.cfm?partnumber=FB850-40). Depending on your lenses you'll need to figure out the right adapter(s) for such a filter. For our 10x lens above, you might need all of these: [adapter1](https://www.edmundoptics.com/optics/optical-filters/optical-filter-accessories/M52-to-M46-Filter-Thread-Adapter/), [adapter2](https://www.thorlabs.de/thorproduct.cfm?partnumber=SM2A53), [adapter3](https://www.thorlabs.de/thorproduct.cfm?partnumber=SM2A6), [adapter4](https://www.thorlabs.de/thorproduct.cfm?partnumber=SM1L03).
-
-
-
-
-
-## Default starting folder
-
-**python**: wherever you run `python -m FaceMap`
-
-**MATLAB**: set at line 59 of MovieGUI.m (h.filepath)
-
-## File loading structure
-
-If you choose a folder instead of a single file, it will assemble a list of all video files in that folder and also all videos 1 folder down. The MATLAB GUI will ask *"would you like to process all movies?"*. If you say no, then a list of movies to choose from will appear. By default the python version shows you a list of movies. If you choose no movies in the python version then it's assumed you want to process ALL of them.
-
-## Processing movies captured simultaneously (multiple camera setups)
-
-Both GUIs will then ask *"are you processing multiple videos taken simultaneously?"*. If you say yes, then the script will look if across movies the **FIRST FOUR** letters of the filename vary. If the first four letters of two movies are the same, then the GUI assumed that they were acquired *sequentially* not *simultaneously*.
-
-Example file list:
-+ cam1_G7c1_1.avi
-+ cam1_G7c1_2.avi
-+ cam2_G7c1_1.avi
-+ cam2_G7c1_2.avi
-+ cam3_G7c1_1.avi
-+ cam3_G7c1_2.avi
-
-*"are you processing multiple videos taken simultaneously?"* ANSWER: Yes
-
-Then the GUIs assume {cam1_G7c1_1.avi, cam2_G7c1_1.avi, cam3_G7c1_1.avi} were acquired simultaneously and {cam1_G7c1_2.avi, cam2_G7c1_2.avi, cam3_G7c1_2.avi} were acquired simultaneously. They will be processed in alphabetical order (1 before 2) and the results from the videos will be concatenated in time. If one of these files was missing, then the GUI will error and you will have to choose file folders again. Also you will get errors if the files acquired at the same time aren't the same frame length (e.g. {cam1_G7c1_1.avi, cam2_G7c1_1.avi, cam3_G7c1_1.avi} should all have the same number of frames).
-
-Note: if you have many simultaneous videos / overall pixels (e.g. 2000 x 2000) you will need around 32GB of RAM to compute the full SVD motion masks.
-
-**python**: you will be able to see all the videos that were simultaneously collected at once. However, you can only draw ROIs that are within ONE video. Only the "multivideo SVD" is computed over all videos.
-
-**MATLAB**: after the file choosing process is over, you will see all the movies in the drop down menu (by filename). You can switch between them and inspect how well an ROI works for each of the movies.
-
-# ROI types
-
-## Pupil computation
-
-The minimum pixel value is subtracted from the ROI. Use the saturation bar to reduce the background of the eye. The algorithm zeros out any pixels less than the saturation level (I recommend a *very* low value - so most pixels are white in the GUI).
-
-Next it finds the pixel with the largest magnitude. It draws a box around that area (1/2 the size of the ROI) and then finds the center-of-mass of that region. It then centers the box on that area. It fits a multivariate gaussian to the pixels in the box using maximum likelihood (see [pupil.py](facemap/pupil.py) or [fitMVGaus.m](matlab/utils/fitMVGaus.m)).
-
-After a Gaussian is fit, it zeros out pixels whose squared distance from the center (normalized by the standard deviation of the Gaussian fit) is greater than 2 * sigma^2 where sigma is set by the user in the GUI (default sigma = 2.5). It now performs the fit again with these points erased, and repeats this process 4 more times. The pupil is then defined as an ellipse sigma standard deviations away from the center-of-mass of the gaussian. This is plotted with '+' around the ellipse and with one '+' at the center.
-
-If there are reflections on the mouse's eye, then you can draw ellipses to account for this "corneal reflection" (plotted in black). You can add as many of these per pupil ROI as needed. The algorithm fills in these areas of the image with the predicted values, which allows for smooth transitions between big and small pupils.
-
-
-
-This raw pupil area trace is post-processed (see [smoothPupil.m](pupil/smoothPupil.m))). The trace is median filtered with a window of 30 timeframes. At each timepoint, the difference between the raw trace and the median filtered trace is computed. If the difference at a given point exceeds half the standard deviation of the raw trace, then the raw value is replaced by the median filtered value.
-
-
-
-## Blink computation
-
-You may want to ignore frames in which the animal is blinking if you are looking at pupil size. The blink area is the number of pixels above the saturation level that you set (all non-white pixels).
-
-
-## Motion SVD
-
-The motion SVDs (small ROIs / multivideo) are computed on the movie downsampled in space by the spatial downsampling input box in the GUI (default 4 pixels). Note the saturation set in this window is NOT used for any processing.
-
-The motion *M* is defined as the abs(current_frame - previous_frame), and the average motion energy across frames is computed using a subset of frames (*avgmot*) (at least 1000 frames - set at line 45 in [subsampledMean.m](matlab/subsampledMean.m) or line 183 in [process.py](facemap/process.py)). Then the singular vectors of the motion energy are computed on chunks of data, also from a subset of frames (15 chunks of 1000 frames each). Let *F* be the chunk of frames [pixels x time]. Then
-```
-uMot = [];
-for j = 1:nchunks
- M = abs(diff(F,1,2));
- [u,~,~] = svd(M - avgmot);
- uMot = cat(2, uMot, u);
-end
-[uMot,~,~] = svd(uMot);
-uMotMask = normc(uMot(:, 1:500)); % keep 500 components
-```
-*uMotMask* are the motion masks that are then projected onto the video at all timepoints (done in chunks of size *nt*=500):
-```
-for j = 1:nchunks
- M = abs(diff(F,1,2));
- motSVD0 = (M - avgmot)' * uMotMask;
- motSVD((j-1)*nt + [1:nt],:) = motSVD0;
-end
-```
-Example motion masks *uMotMask* and traces *motSVD*:
-
-
-
-We found that these extracted singular vectors explained up to half of the total explainable variance in neural activity in visual cortex and in other forebrain areas. See our [paper](https://science.sciencemag.org/content/364/6437/eaav7893) for more details.
-
-In the python version, we also compute the average of *M* across all pixels in each motion ROI and that is returned as the **motion**. The first **motion** field is non-empty if "multivideo SVD" is on, and in that case it is the average motion energy across all pixels in all views.
-
-## Running computation
-
-The phase-correlation between consecutive frames (in running ROI) are computed in the fourier domain (see [running.py](/facemap/running.py) or [processRunning.m](/matlab/running/processRunning.m)). The XY position of maximal correlation gives the amount of shift between the two consecutive frames. Depending on how fast the movement is frame-to-frame you may want at least a 50x50 pixel ROI to compute this.
-
-## Multivideo SVD ROIs
-
-**PYTHON**: Check box "Compute multivideo SVD" to compute the SVD of all pixels in all videos.
-
-**MATLAB**: You can draw areas to be included and excluded in the multivideo SVD (or single video if you only have one view). The buttons are "area to keep" and "area to exclude" and will draw blue and red boxes respectively. The union of all pixels in "areas to include" are used, excluding any pixels that intersect this union from "areas to exclude" (you can toggle between viewing the boxes and viewing the included pixels using the "Show areas" checkbox, see example below).
-
-
-
-The motion energy is then computed from these non-red pixels.
-
-# Output of processing
-
-The GUIs create one file for all videos (saved in current folder), the npy file has name "videofile_proc.npy" and the mat file has name "videofile_proc.mat".
-
-**PYTHON**:
-- **filenames**: list of lists of video filenames - each list are the videos taken simultaneously
-- **Ly**, **Lx**: list of number of pixels in Y (Ly) and X (Lx) for each video taken simultaneously
-- **sbin**: spatial bin size for motion SVDs
-- **Lybin**, **Lxbin**: list of number of pixels binned by sbin in Y (Ly) and X (Lx) for each video taken simultaneously
-- **sybin**, **sxbin**: coordinates of multivideo (for plotting/reshaping ONLY)
-- **LYbin**, **LXbin**: full-size of all videos embedded in rectangle (binned)
-- **fullSVD**: whether or not "multivideo SVD" is computed
-- **save_mat**: whether or not to save proc as *.mat file
-- **avgframe**: list of average frames for each video from a subset of frames (binned by sbin)
-- **avgframe_reshape**: average frame reshaped to be y-pixels x x-pixels
-- **avgmotion**: list of average motions for each video from a subset of frames (binned by sbin)
-- **avgmotion_reshape**: average motion reshaped to be y-pixels x x-pixels
-- **iframes**: array containing number of frames in each consecutive video
-- **motion**: list of absolute motion energies across time - first is "multivideo" motion energy (empty if not computed)
-- **motSVD**: list of motion SVDs - first is "multivideo SVD" (empty if not computed) - each is nframes x components
-- **motMask**: list of motion masks for each motion SVD - each motMask is pixels x components
-- **motMask_reshape**: motion masks reshaped to be y-pixels x x-pixels x components
-- **pupil**: list of pupil ROI outputs - each is a dict with 'area', 'area_smooth', and 'com' (center-of-mass)
-- **blink**: list of blink ROI outputs - each is nframes, the blink area on each frame
-- **running**: list of running ROI outputs - each is nframes x 2, for X and Y motion on each frame
-- **rois**: ROIs that were drawn and computed
- - *rind*: type of ROI in number
- - *rtype*: what type of ROI ('motion SVD', 'pupil', 'blink', 'running')
- - *ivid*: in which video is the ROI
- - *color*: color of ROI
- - *yrange*: y indices of ROI
- - *xrange*: x indices of ROI
- - *saturation*: saturation of ROI (0-255)
- - *pupil_sigma*: number of stddevs used to compute pupil radius (for pupil ROIs)
- - *yrange_bin*: binned indices in y (if motion SVD)
- - *xrange_bin*: binned indices in x (if motion SVD)
-
-Note this is a dict, so say *.item() after loading:
-```
-import numpy as np
-proc = np.load('cam1_proc.npy').item()
-```
-These *_proc.npy* files can be loaded into the GUI (and will automatically be loaded after processing). The checkboxes in the lower left allow you to view different traces from the processing.
-
-**MATLAB**:
-- **nX**,**nY**: cell arrays of number of pixels in X and Y in each video taken simultaneously
-- **sc**: spatial downsampling constant used
-- **ROI**: [# of videos x # of areas] - areas to be included for multivideo SVD (in downsampled reference)
-- **eROI**: [# of videos x # of areas] - areas to be excluded from multivideo SVD (in downsampled reference)
-- **locROI**: location of small ROIs (in order running, ROI1, ROI2, ROI3, pupil1, pupil2); in downsampled reference
-- **ROIfile**: in which movie is the small ROI
-- **plotROIs**: which ROIs are being processed (these are the ones shown on the frame in the GUI)
-- **files**: all the files you processed together
-- **npix**: array of number of pixels from each video used for multivideo SVD
-- **tpix**: array of number of pixels in each view that was used for SVD processing
-- **wpix**: cell array of which pixels were used from each video for multivideo SVD
-- **avgframe**: [sum(tpix) x 1] average frame across videos computed on a subset of frames
-- **avgmotion**: [sum(tpix) x 1] average frame across videos computed on a subset of frames
-- **motSVD**: cell array of motion SVDs [components x time] (in order: multivideo, ROI1, ROI2, ROI3)
-- **uMotMask**: cell array of motion masks [pixels x time]
-- **runSpeed**: 2D running speed computed using phase correlation [time x 2]
-- **pupil**: structure of size 2 (pupil1 and pupil2) with 3 fields: area, area_raw, and com
-- **thres**: pupil sigma used
-- **saturation**: saturation levels (array in order running, ROI1, ROI2, ROI3, pupil1, pupil2); only saturation levels for pupil1 and pupil2 are used in the processing, others are just for viewing ROIs
-
-an ROI is [1x4]: [y0 x0 Ly Lx]
-
-## Motion SVD Masks in MATLAB
-
-Use the script [plotSVDmasks.m](figs/plotSVDmasks.m) to easily view motion masks from the multivideo SVD. The motion masks from the smaller ROIs have been reshaped to be [xpixels x ypixels x components].
diff --git a/docs/installation.md b/docs/installation.md
new file mode 100644
index 0000000..b812c94
--- /dev/null
+++ b/docs/installation.md
@@ -0,0 +1,75 @@
+# Installation (Python)
+
+This package only supports python 3. We recommend installing python 3 with **[Anaconda](https://www.anaconda.com/download/)**.
+
+
+### For using pose tracker and svd processing
+Please run
+~~~
+pip install git+https://github.com/mouseland/facemap.git
+~~~
+that will install the latest development version on github.
+
+### For latest released version (from PyPI) using svd processing only
+
+Run the following for command line interface (CLI) i.e. headless version:
+~~~
+pip install facemap
+~~~
+or the following for using GUI:
+~~~~
+pip install facemap[gui]
+~~~~
+
+To upgrade Facemap (package [here](https://pypi.org/project/facemap/)), within the environment run:
+~~~~
+pip install facemap --upgrade
+~~~~
+
+Using the environment.yml file (recommended installation method):
+
+1. Download the `environment.yml` file from the repository or clone the github repository: `git clone https://www.github.com/mouseland/facemap.git`
+2. Open an anaconda prompt / command prompt with `conda` for **python 3** in the path
+3. Change directory to facemap folder `cd facemap`
+4. Run `conda env create -f environment.yml`
+5. To activate this new environment, run `conda activate facemap`
+6. You should see `(facemap)` on the left side of the terminal line. Now run `python -m facemap` and you're all set.
+
+## Common installation issues
+
+If you have pip issues, there might be some interaction between pre-installed dependencies and the ones FaceMap needs. First thing to try is
+~~~~
+python -m pip install --upgrade pip
+~~~~
+
+While running `python -m facemap`, if you receive the error: `No module named PyQt5.sip`, then try uninstalling and reinstalling pyqt5
+~~~
+pip uninstall pyqt5 pyqt5-tools
+pip install pyqt5 pyqt5-tools pyqt5.sip
+~~~
+
+If you are on Yosemite Mac OS, PyQt doesn't work, and you won't be able to install Facemap. More recent versions of Mac OS are fine.
+
+The software has been heavily tested on Ubuntu 18.04, and less well tested on Windows 10 and Mac OS. Please post an issue if you have installation problems.
+
+### Pyhton dependencies
+
+Facemap python relies on these awesome packages:
+- [pyqtgraph](http://pyqtgraph.org/)
+- [PyQt5](http://pyqt.sourceforge.net/Docs/PyQt5/)
+- [numpy](http://www.numpy.org/) (>=1.13.0)
+- [scipy](https://www.scipy.org/)
+- [opencv](https://opencv.org/)
+- [numba](http://numba.pydata.org/numba-doc/latest/user/5minguide.html)
+- [natsort](https://natsort.readthedocs.io/en/master/)
+- [PyTorch](https://pytorch.org)
+- [Matplotlib](https://matplotlib.org)
+- [SciPy](https://scipy.org)
+- [tqdm](https://tqdm.github.io)
+- [pandas](https://pandas.pydata.org)
+- [UMAP](https://umap-learn.readthedocs.io/en/latest/)
+
+
+# Installation (MATLAB)
+
+The matlab version supports SVD processing only and does not include face tracker. The package can be downloaded/cloned from github (no install required). It works in Matlab 2014b and above - please submit issues if it's not working. The Image Processing Toolbox is necessary to use the GUI. For GPU functionality, the Parallel Processing Toolbox is required. If you don't have the Parallel Processing Toolbox, uncheck the box next to "use GPU" in the GUI before processing.
diff --git a/docs/pose_tracking_cli_tutorial.md b/docs/pose_tracking_cli_tutorial.md
new file mode 100644
index 0000000..3de3c74
--- /dev/null
+++ b/docs/pose_tracking_cli_tutorial.md
@@ -0,0 +1 @@
+# Pose tracking **(CLI)**
\ No newline at end of file
diff --git a/docs/pose_tracking_gui_tutorial.md b/docs/pose_tracking_gui_tutorial.md
new file mode 100644
index 0000000..a7de406
--- /dev/null
+++ b/docs/pose_tracking_gui_tutorial.md
@@ -0,0 +1,34 @@
+# Pose tracking **(GUI)** :mouse:
+
+
+
+The latest python version is integrated with Facemap network for tracking 14 distinct keypoints on mouse face and an additional point for tracking paw. The keypoints can be tracked from different camera views (some examples shown below).
+
+
+
+
+
+
+For pose tracking using GUI after following the [installation instructions](installation.md), proceed with the following steps:
+
+1. Load video
+ - Select `File` from the menu bar
+ - For processing single video, select `Load single movie file`
+ - Alternatively, for processing multiple videos, select `Open folder of movies` and then select the files you want to process. Please note multiple videos are processed sequentially.
+2. Select output folder
+ - Use the file menu to `Set output folder`.
+ - The processed keypoints file will be saved in the selected output folder with an extension of `.h5` and corresponding metadata file with extension `.pkl`.
+3. Choose processing options
+ - Check at least one of the following boxes:
+ - `Keypoints` for face pose tracking.
+ - `motSVD` for SVD processing of difference across frames over time.
+ - `movSVD` for SVD processing of raw movie frames.
+ - Click `process` button and monitor progress bar at the bottom of the window to see updates.
+4. Select ROI/bounding box for face
+ - Once you hit `process`, a dialog box will appear for selecting a bounding box for the face. The keypoints will be tracked in the selected bounding box. Please ensure that the bouding box is focused on the face where all the keypoints shown above will be visible. See example frames [here](figs/mouse_views.png). Once the bounding box is focused, click 'Done' to continue.
+ - Alternatively, if you wish to use the entire frame for the mouse then click 'Skip' to continue.
+ - If a 'Face (pose)' ROI has already been selected using the dropdown menu for ROIs the bounding box will be automatically selected and the keypoints will be tracked in the selected ROI.
+
+The videos will be processed in the order they are listed in the file list and output will be saved in the output folder. Following is an example gif demonstrating the above mentioned steps for tracking keypoints in a video.
+
+
diff --git a/docs/svd_matlab_tutorial.md b/docs/svd_matlab_tutorial.md
new file mode 100644
index 0000000..db4b6aa
--- /dev/null
+++ b/docs/svd_matlab_tutorial.md
@@ -0,0 +1,130 @@
+# *HOW TO GUI* (MATLAB)
+
+To start the GUI, run the command `MovieGUI` in this folder. The following window should appear. After you click an ROI button and draw an area, you have to **double-click** inside the drawn box to confirm it. To compute the SVD across multiple simultaneously acquired videos you need to use the "multivideo SVD" options to draw ROI's on each video one at a time.
+
+
+
+
+
+This raw pupil area trace is post-processed (see [smoothPupil.m](pupil/smoothPupil.m))). The trace is median filtered with a window of 30 timeframes. At each timepoint, the difference between the raw trace and the median filtered trace is computed. If the difference at a given point exceeds half the standard deviation of the raw trace, then the raw value is replaced by the median filtered value.
+
+
+
+#### Blink computation
+
+You may want to ignore frames in which the animal is blinking if you are looking at pupil size. The blink area is the number of pixels above the saturation level that you set (all non-white pixels).
+
+#### Motion SVD
+
+The motion SVDs (small ROIs / multivideo) are computed on the movie downsampled in space by the spatial downsampling input box in the GUI (default 4 pixels). Note the saturation set in this window is NOT used for any processing.
+
+The motion *M* is defined as the abs(current_frame - previous_frame), and the average motion energy across frames is computed using a subset of frames (*avgmot*) (at least 1000 frames - set at line 45 in [subsampledMean.m](matlab/subsampledMean.m) or line 183 in [process.py](facemap/process.py)). Then the singular vectors of the motion energy are computed on chunks of data, also from a subset of frames (15 chunks of 1000 frames each). Let *F* be the chunk of frames [pixels x time]. Then
+```
+uMot = [];
+for j = 1:nchunks
+ M = abs(diff(F,1,2));
+ [u,~,~] = svd(M - avgmot);
+ uMot = cat(2, uMot, u);
+end
+[uMot,~,~] = svd(uMot);
+uMotMask = normc(uMot(:, 1:500)); % keep 500 components
+```
+*uMotMask* are the motion masks that are then projected onto the video at all timepoints (done in chunks of size *nt*=500):
+```
+for j = 1:nchunks
+ M = abs(diff(F,1,2));
+ motSVD0 = (M - avgmot)' * uMotMask;
+ motSVD((j-1)*nt + [1:nt],:) = motSVD0;
+end
+```
+Example motion masks *uMotMask* and traces *motSVD*:
+
+
+
+We found that these extracted singular vectors explained up to half of the total explainable variance in neural activity in visual cortex and in other forebrain areas. See our [paper](https://science.sciencemag.org/content/364/6437/eaav7893) for more details.
+
+In the python version, we also compute the average of *M* across all pixels in each motion ROI and that is returned as the **motion**. The first **motion** field is non-empty if "multivideo SVD" is on, and in that case it is the average motion energy across all pixels in all views.
+
+#### Running computation
+
+The phase-correlation between consecutive frames (in running ROI) are computed in the fourier domain (see [running.py](../facemap/running.py) or [processRunning.m](../matlab/running/processRunning.m)). The XY position of maximal correlation gives the amount of shift between the two consecutive frames. Depending on how fast the movement is frame-to-frame you may want at least a 50x50 pixel ROI to compute this.
+
+#### Multivideo SVD ROIs
+
+You can draw areas to be included and excluded in the multivideo SVD (or single video if you only have one view). The buttons are "area to keep" and "area to exclude" and will draw blue and red boxes respectively. The union of all pixels in "areas to include" are used, excluding any pixels that intersect this union from "areas to exclude" (you can toggle between viewing the boxes and viewing the included pixels using the "Show areas" checkbox, see example below).
+
+
+
+The motion energy is then computed from these non-red pixels.
+
+### Proccessed output
+
+The GUIs create one file for all videos (saved in current folder), the processed mat file has name "videofile_proc.mat".
+
+**MATLAB output**:
+- **nX**,**nY**: cell arrays of number of pixels in X and Y in each video taken simultaneously
+- **sc**: spatial downsampling constant used
+- **ROI**: [# of videos x # of areas] - areas to be included for multivideo SVD (in downsampled reference)
+- **eROI**: [# of videos x # of areas] - areas to be excluded from multivideo SVD (in downsampled reference)
+- **locROI**: location of small ROIs (in order running, ROI1, ROI2, ROI3, pupil1, pupil2); in downsampled reference
+- **ROIfile**: in which movie is the small ROI
+- **plotROIs**: which ROIs are being processed (these are the ones shown on the frame in the GUI)
+- **files**: all the files you processed together
+- **npix**: array of number of pixels from each video used for multivideo SVD
+- **tpix**: array of number of pixels in each view that was used for SVD processing
+- **wpix**: cell array of which pixels were used from each video for multivideo SVD
+- **avgframe**: [sum(tpix) x 1] average frame across videos computed on a subset of frames
+- **avgmotion**: [sum(tpix) x 1] average frame across videos computed on a subset of frames
+- **motSVD**: cell array of motion SVDs [components x time] (in order: multivideo, ROI1, ROI2, ROI3)
+- **uMotMask**: cell array of motion masks [pixels x time]
+- **runSpeed**: 2D running speed computed using phase correlation [time x 2]
+- **pupil**: structure of size 2 (pupil1 and pupil2) with 3 fields: area, area_raw, and com
+- **thres**: pupil sigma used
+- **saturation**: saturation levels (array in order running, ROI1, ROI2, ROI3, pupil1, pupil2); only saturation levels for pupil1 and pupil2 are used in the processing, others are just for viewing ROIs
+
+an ROI is [1x4]: [y0 x0 Ly Lx]
+
+#### Motion SVD Masks in MATLAB
+
+Use the script [plotSVDmasks.m](../figs/plotSVDmasks.m) to easily view motion masks from the multivideo SVD. The motion masks from the smaller ROIs have been reshaped to be [xpixels x ypixels x components].
+
diff --git a/docs/svd_python_tutorial.md b/docs/svd_python_tutorial.md
new file mode 100644
index 0000000..376c6be
--- /dev/null
+++ b/docs/svd_python_tutorial.md
@@ -0,0 +1,124 @@
+
+
+## *HOW TO GUI* (Python)
+
+([video](https://www.youtube.com/watch?v=Rq8fEQ-DOm4) with old install instructions)
+
+
+
+Run the following command in a terminal
+```
+python -m facemap
+```
+Default starting folder is set to wherever you run `python -m FaceMap`
+
+The following window should appear. The upper left "file" button loads single files, the upper middle "folder" button loads whole folders (from which you can select movies), and the upper right "folder" button loads processed files ("_proc.npy" files). Load a video or a group of videos (see below for file formats for simultaneous videos). The video(s) will pop up in the left side of the GUI. You can zoom in and out with the mouse wheel, and you can drag by holding down the mouse. Double-click to return to the original, full view.
+
+Choose a type of ROI to add and then click "add ROI" to add it to the view. The pixels in the ROI will show up in the right window (with different processing depending on the ROI type - see below). You can move it and resize the ROI anytime. You can delete the ROI with "right-click" and selecting "remove". You can change the saturation of the ROI with the upper right saturation bar. You can also just click on the ROI at any time to see what it looks like in the right view.
+
+By default, the "Compute multivideo SVD" box is unchecked. If you check it, then the motion SVD is computed across ALL videos - all videos are concatenated at each timepoint, and the SVD of this matrix of ALL_PIXELS x timepoints is computed. If you have just one video acquired at a time, then it is the SVD of this video.
+
+
+
+
+
+
New variables:\n",
+ "- motSv: array containign singular values for motSVD\n",
+ "- movSv: array containign singular values for movSVD"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`process.run()` function call takes the following parameters:\n",
+ "- filenames: A 2D list of names of video(s) to get\n",
+ "- motSVD: default=True\n",
+ "- movSVD: default=False\n",
+ "- GUIobject=None\n",
+ "- parent: default=None, parent is from GUI\n",
+ "- proc: default=None, proc can be a saved ROI file from GUI \n",
+ "- savepath: default=None => set to video folder, specify a folder path in which to save _proc.npy "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Import packages"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from facemap import process\n",
+ "from glob import glob"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Set variables"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Example file list:\n",
+ " - cam1_G7c1_1.avi\n",
+ " - cam1_G7c1_2.avi\n",
+ " - cam2_G7c1_1.avi\n",
+ " - cam2_G7c1_2.avi\n",
+ " - cam3_G7c1_1.avi\n",
+ " - cam3_G7c1_2.avi"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "simultaneous_video_list = [['.../cam1_G7c1_1.avi',\n",
+ " '.../cam2_G7c1_1.avi',\n",
+ " '.../cam3_G7c1_1.avi',\n",
+ " '.../cam4_G7c1_1.avi']]\n",
+ "sequential_video_list = [['.../cam1_G7c1_1.avi', '.../cam1_G7c1_2.avi'],\n",
+ " ['.../cam2_G7c1_1.avi', '.../cam2_G7c1_2.avi'],\n",
+ " ['.../cam3_G7c1_1.avi', '.../cam3_G7c1_2.avi'],\n",
+ " ['.../cam4_G7c1_1.avi', '.../cam4_G7c1_2.avi']]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Process videos recorded simultaneously from different cam/views"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "savename = process.run(simultaneous_video_list)\n",
+ "print(\"Output saved in\", savename)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Process videos recorded sequentially"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "savename = process.run(sequential_video_list)\n",
+ "print(\"Output saved in\", savename)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Process videos from multiple sessions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "session_folders = [‘location1’, ‘location2’, …, ’locationN’]\n",
+ "for indexSession, folder in enumerate(session_folders):\n",
+ " video_files = glob(folder+\"/*.ext\") # replace .ext with one of ['*.mj2','*.mp4','*.mkv','*.avi','*.mpeg','*.mpg','*.asf']\n",
+ " process.run(video_files)\n",
+ " # if SVDs of ROIs is required, use 'save ROIs' from GUI and use the following command\n",
+ " process.run(video_files, proc=\"/path_to_saved_rois\")"
+ ]
+ }
+ ],
+ "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.8.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/tutorial.ipynb b/notebooks/tutorial.ipynb
old mode 100644
new mode 100755
similarity index 99%
rename from tutorial.ipynb
rename to notebooks/tutorial.ipynb
index 55e4ff1..900de3a
--- a/tutorial.ipynb
+++ b/notebooks/tutorial.ipynb
@@ -1138,7 +1138,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.7.6"
+ "version": "3.8.3"
}
},
"nbformat": 4,
diff --git a/setup.py b/setup.py
index 689c877..cf855c3 100644
--- a/setup.py
+++ b/setup.py
@@ -1,10 +1,24 @@
import setuptools
+install_deps = ['numpy>=1.16',
+ 'scipy',
+ 'matplotlib',
+ 'natsort',
+ 'tqdm',
+ 'numba>=0.43.1',
+ 'opencv-python-headless',
+ 'hdbscan',
+ 'torch>=1.9',
+ 'umap-learn',
+ 'pandas',
+ 'scikit-image']
+
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="facemap",
+ license="GPLv3",
version="0.2.0",
author="Carsen Stringer & Atika Syeda & Renee Tung",
author_email="carsen.stringer@gmail.com",
@@ -13,8 +27,15 @@
long_description_content_type="text/markdown",
url="https://github.com/MouseLand/FaceMap",
packages=setuptools.find_packages(),
- install_requires = ['pyqtgraph==0.11.0rc0', 'PyQt5', 'PyQt5.sip',
- 'numpy>=1.13.0', 'scipy', 'numba', 'natsort'],
+ install_requires = install_deps,
+ tests_require = ['pytest', 'tqdm'],
+ extras_require = {
+ 'gui': [
+ 'pyqtgraph==0.12.0',
+ 'pyqt5',
+ 'pyqt5.sip',
+ ]
+ }
include_package_data=True,
classifiers=(
"Programming Language :: Python :: 3",
diff --git a/tests/conftest.py b/tests/conftest.py
index 8f3a781..c769b4b 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,3 +1,4 @@
+from genericpath import exists
import pytest
import os, sys, tempfile, shutil
from tqdm import tqdm
@@ -6,13 +7,12 @@
@pytest.fixture()
def video_names():
- video1_names = ['cam1_test.avi']
- video2_names = ['cam2_test.avi']
- return video1_names, video2_names
+ video1_name = 'cam1_test.avi'
+ video2_name = 'cam2_test.avi'
+ return video1_name, video2_name
@pytest.fixture()
def data_dir(video_names):
- #data_dir = os.path.join(os.getcwd(),'Video_samples/sample_movies/')
fm_dir = Path.home().joinpath('.facemap')
fm_dir.mkdir(exist_ok=True)
data_dir = fm_dir.joinpath('data')
@@ -30,8 +30,22 @@ def data_dir(video_names):
cached_file = str(data_dir_cam2.joinpath(video_name))
if not os.path.exists(cached_file):
download_url_to_file(url, cached_file)
+
return data_dir
+@pytest.fixture()
+def expected_output_dir(data_dir):
+ expected_output_dir = data_dir.joinpath('expected_output')
+ expected_output_dir.mkdir(exist_ok=True)
+ # Download expected output files
+ """
+ download_url_to_file('https://www.facemappy.org/test_data/singlevideo_proc.npy',
+ expected_output_dir.joinpath('singlevideo_proc.npy'))
+ download_url_to_file('https://www.facemappy.org/test_data/multivideo_proc.npy',
+ expected_output_dir.joinpath('multivideo_proc.npy'))
+ """
+ return expected_output_dir
+
def download_url_to_file(url, dst, progress=True):
# Following adapted from https://github.com/MouseLand/cellpose/blob/35c16c94e285a4ec2fa17f148f06bbd414deb5b8/cellpose/utils.py#L45
"""Download object at the given URL to a local path.
diff --git a/tests/test_output.py b/tests/test_output.py
index 9245cbc..ea1faa6 100644
--- a/tests/test_output.py
+++ b/tests/test_output.py
@@ -1,4 +1,5 @@
"Test facemap pipeline by comparing outputs"
+from numpy.lib.npyio import save
from facemap import process
import numpy as np
from pathlib import Path
@@ -6,47 +7,59 @@
r_tol, a_tol = 1e-2, 1e-2
-def test_output_single_video(data_dir, video_names):
+def test_output_single_video(data_dir, video_names, expected_output_dir):
clear_output(data_dir, video_names)
v1, _ = video_names
- test_filenames = [[str(data_dir.joinpath('data').joinpath('cam1').joinpath(v1))]] # [[data_dir+video for video in v1]]
- save_path = str(data_dir.joinpath('data').joinpath('cam1'))
- process.run(test_filenames, movSVD=True, savepath=save_path)
+ test_filenames = [[str(data_dir.joinpath('cam1').joinpath(v1))]] # [[data_dir+video for video in v1]]
+ save_path = str(data_dir.joinpath('cam1'))
+ output_filename, _ = v1.split(".")
+ test_proc_filename = os.path.join(save_path,output_filename+"_proc.npy")
+ # Process video
+ process.run(test_filenames, sbin=7, motSVD=True, movSVD=True, savepath=save_path)
- output_filename, _ = os.path.splitext(v1[0])
- test_proc_filename = save_path.joinpath(output_filename+"_proc.npy")
+ # Compare output
output = np.load(test_proc_filename,allow_pickle=True).item()
- expected_proc_filename = os.getcwd()+"/tests/expected_output/singlevideo_proc.npy"
+ expected_proc_filename = expected_output_dir.joinpath("singlevideo_proc.npy")
expected_output = np.load(expected_proc_filename,allow_pickle=True).item()
clear_output(data_dir, video_names)
assert is_output_correct(output, expected_output)
-def test_output_multivideo(data_dir, video_names):
+def test_output_multivideo(data_dir, video_names, expected_output_dir):
clear_output(data_dir, video_names)
v1, v2 = video_names
- test1 = str(data_dir.joinpath('data').joinpath('cam1').joinpath(v1))#os.path.join(data_dir,v1[0])
- test2 = str(data_dir.joinpath('data').joinpath('cam2').joinpath(v2))#os.path.join(data_dir,v2[0])
+ test1 = str(data_dir.joinpath('cam1').joinpath(v1))
+ test2 = str(data_dir.joinpath('cam2').joinpath(v2))
+
# For videos recorded simultaneously from multiple cams
test_filenames = [[test1, test2]]
- save_path = str(data_dir.joinpath('data').joinpath('cam2'))
- process.run(test_filenames, movSVD=True, savepath=save_path)
+ save_path = str(data_dir.joinpath('cam2'))
+ output_filename, _ = v1.split(".")
+ test_proc_filename = os.path.join(save_path, output_filename+"_proc.npy")
+ print(test_proc_filename)
+ # Process videos
+ process.run(test_filenames, sbin=12, motSVD=True, movSVD=True, savepath=save_path)
- output_filename, _ = os.path.splitext(v2[0])
- test_proc_filename = save_path.joinpath(output_filename+"_proc.npy")
+ # Compare output
output = np.load(test_proc_filename,allow_pickle=True).item()
- expected_proc_filename = os.getcwd()+"/tests/expected_output/multivideo_proc.npy"
+ expected_proc_filename = expected_output_dir.joinpath("multivideo_proc.npy")
expected_output = np.load(expected_proc_filename,allow_pickle=True).item()
clear_output(data_dir, video_names)
-
+
assert is_output_correct(output, expected_output)
+ clear_expected_output(expected_output_dir)
def is_output_correct(test_output, expected_output):
params_match = check_params(test_output, expected_output)
+ print("params match", params_match)
frames_match = check_frames(test_output, expected_output)
+ print("frames_match", frames_match)
motion_match = check_motion(test_output, expected_output)
+ print("motion_match", motion_match)
U_match = check_U(test_output, expected_output)
+ print("U_match", U_match)
V_match = check_V(test_output, expected_output)
+ print("V_match", V_match)
return params_match and frames_match and motion_match and U_match and V_match
def check_params(test_output, expected_output):
@@ -62,7 +75,6 @@ def check_params(test_output, expected_output):
return all_outputs_match
def check_frames(test_output, expected_output):
- print(test_output['avgframe'][0].shape, expected_output['avgframe'][0].shape)
avgframes_match = np.allclose(test_output['avgframe'][0], expected_output['avgframe'][0],
rtol=r_tol, atol=a_tol)
avgmotion_match = np.allclose(test_output['avgmotion'][0], expected_output['avgmotion'][0],
@@ -102,3 +114,9 @@ def clear_output(data_dir, video_names):
output = name + '_proc.npy'
if os.path.exists(output):
os.remove(output)
+
+def clear_expected_output(expected_output_dir):
+ files = ['singlevideo_proc.npy', 'multivideo_proc.npy']
+ for f in files:
+ if os.path.exists(expected_output_dir.joinpath(f)):
+ os.remove(expected_output_dir.joinpath(f))
diff --git a/tox.ini b/tox.ini
index 4d69aa8..b84af20 100644
--- a/tox.ini
+++ b/tox.ini
@@ -26,7 +26,8 @@ passenv =
NUMPY_EXPERIMENTAL_ARRAY_FUNCTION
PYVISTA_OFF_SCREEN
deps =
+ .[all]
pytest # https://docs.pytest.org/en/latest/contents.html
pytest-cov # https://pytest-cov.readthedocs.io/en/latest/
pytest-xvfb ; sys_platform == 'linux'
-commands = pytest -v --color=yes --cov=facemap --cov-report=xml
\ No newline at end of file
+commands = pytest -v --color=yes --cov=facemap --cov-report=xml