zebranoise 0.1.0__tar.gz

zebranoise-0.1.0/LICENSE.txt

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2024 Maxwell Shinn
+Copyright (c) 2024 Sophie Skriabine
+Copyright (c) 2008 Casey Duncan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zebranoise-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.1
+Name: zebranoise
+Version: 0.1.0
+Summary: Zebra noise stimuli for Python
+Home-page: https://github.com/mwshinn/zebra_noise
+Author: Max Shinn
+Author-email: m.shinn@ucl.ac.uk
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+This library will efficiently generate visual stimulus videos using Perlin noise, including zebra noise.  The core algorithm is in optimized C.
+
+[Example zebra noise](http://www.youtube.com/watch?v=-SyjgbNCP4Q)
+
+[![Example zebra noise](http://img.youtube.com/vi/-SyjgbNCP4Q/0.jpg)](http://www.youtube.com/watch?v=-SyjgbNCP4Q "Example zebra noise")
+
+# Installation
+
+## From pypi
+
+Run:
+
+    pip install zebranoise
+
+## From source
+
+Make sure you have a C compiler installed.  The easiest way to do this is by installing Cython.
+
+Then, install using the standard
+
+    python setup.py install
+
+This will compile the sources and install.
+
+I have only tested this on Linux.
+
+# Usage
+
+## Basic usage
+
+If you would like to generate a zebra noise of size 640x480 for 2 minutes, you can run
+    
+    import zebranoise
+    zebranoise.zebra_noise("output.mp4", xsize=640, ysize=480, tdur=60*2, fps=30, seed=0)
+
+Other parameters control the spatial and temporal frequencies.  For instance,
+
+    zebranoise.zebra_noise("output2.mp4", xsize=640, ysize=480, tdur=60*2, levels=10, xyscale=.2, tscale=50, fps=30, xscale=1.0, yscale=1.0, seed=0)
+
+The meaning of these parameters is:
+
+- **xsize** and **ysize**: the x and y dimensions of the output video.  (Sometimes
+  these will be rounded up to multiples of 16.)
+- **tdur**: the duration in seconds
+- **levels**: The number of octaves to use when approximating the 1/f spectrum.
+  The default of 10 should be more than enough.
+- **xyscale**: The spatial scale of the Perlin noise, from 0 to 1.  Low values
+  will make the video smoother and high values choppier.
+- **tscale**: The speed of the video
+- **xscale** and **yscale**: Resize the x and y dimensions of the output.
+- **fps**: Frames per second
+- **seed**: Random seed
+
+## Advanced usage
+
+This package can be used to generate new stimuli based on Perlin noise.
+
+To generate a Perlin noise-based video, follow two steps with the package.  First, generate the Perlin noise.  This is the most time consuming step, and will also use a lot of temporary disk space.  This is accomplished with:
+
+```python
+noise = zebranoise.PerlinStimulus(xsize=400, ysize=100, tdur=60*2, xyscale=.2, tscale=50, seed=0)
+```
+
+See the function documentation for perlstim.Perl for more information about modifying the properties of the noise.
+
+Second, apply "filters" to the Perlin noise and save the resulting video.  Filters include thresholds, sync squares in the corner, etc.  If using a filter with no arguments, just pass a string naming the filter.  If using a filter with arguments, pass a tuple where the first element is the name of the filter as a string, and the remaining elements are the arguments.  For example,
+
+```python
+noise.save_video("noise.mp4", filters=["reverse", ("comb", .05)])
+```
+
+The above example applies the "reverse" filter (with no arguments) and the "comb" filter with the argument 0.1.
+
+## Filters
+
+The following filters are currently defined:
+
+- "threshold" (1 argument): set all values above the threshold argument to white, and all below to black.
+- "softthresh" (1 argument): set values much greater than 0 to white and much less than zero to blac.  Use shades of grey for intermediate values, according to a sigmoid with a temperature given as the argument.
+- "comb" (1 argument): Alternate black and white thresholds at intervals given by the argument.
+- "reverse" (0 arguments): play the video in reverse
+- "invert" (0 arguments): switch white and black
+- "wood" (1 argument): similar to "comb", but use a sawtooth wave
+- "blur" (1 argument): Gaussian blur with the given spatial standard deviation
+- "photodiode" (1 argument): Draw a sync square in the corner, with a size given by the argument.
+- "photodiode_anywhere" (3 arguments): Draw a sync square at the coordinates given by the first two arguments (x and y), and of size given by argument 3.
+- [any function] (0 arguments): If you pass a function, the function will be applied to each chunk of the video.  Chunks consist of the entire x and y but a subset of z, guaranteed to be an even number.
+
+## Example
+
+To get started, try the following:
+
+```python
+import zebranoise
+stim = zebranoise.PerlinStimulus(xsize=480, ysize=128, tdur=60*5, xyscale=.2, tscale=50)
+stim.save_video("perlin_stimulus.mp4", loop=1, filters=[("comb", .08), ("photodiode", 30)])
+```
+# Other information
+
+Much of the C code is based on [Casey Duncan's "noise" package for Python](https://github.com/caseman/noise), under the MIT license.
+
+

zebranoise-0.1.0/README.md

@@ -0,0 +1,100 @@
+This library will efficiently generate visual stimulus videos using Perlin noise, including zebra noise.  The core algorithm is in optimized C.
+
+[Example zebra noise](http://www.youtube.com/watch?v=-SyjgbNCP4Q)
+
+[![Example zebra noise](http://img.youtube.com/vi/-SyjgbNCP4Q/0.jpg)](http://www.youtube.com/watch?v=-SyjgbNCP4Q "Example zebra noise")
+
+# Installation
+
+## From pypi
+
+Run:
+
+    pip install zebranoise
+
+## From source
+
+Make sure you have a C compiler installed.  The easiest way to do this is by installing Cython.
+
+Then, install using the standard
+
+    python setup.py install
+
+This will compile the sources and install.
+
+I have only tested this on Linux.
+
+# Usage
+
+## Basic usage
+
+If you would like to generate a zebra noise of size 640x480 for 2 minutes, you can run
+    
+    import zebranoise
+    zebranoise.zebra_noise("output.mp4", xsize=640, ysize=480, tdur=60*2, fps=30, seed=0)
+
+Other parameters control the spatial and temporal frequencies.  For instance,
+
+    zebranoise.zebra_noise("output2.mp4", xsize=640, ysize=480, tdur=60*2, levels=10, xyscale=.2, tscale=50, fps=30, xscale=1.0, yscale=1.0, seed=0)
+
+The meaning of these parameters is:
+
+- **xsize** and **ysize**: the x and y dimensions of the output video.  (Sometimes
+  these will be rounded up to multiples of 16.)
+- **tdur**: the duration in seconds
+- **levels**: The number of octaves to use when approximating the 1/f spectrum.
+  The default of 10 should be more than enough.
+- **xyscale**: The spatial scale of the Perlin noise, from 0 to 1.  Low values
+  will make the video smoother and high values choppier.
+- **tscale**: The speed of the video
+- **xscale** and **yscale**: Resize the x and y dimensions of the output.
+- **fps**: Frames per second
+- **seed**: Random seed
+
+## Advanced usage
+
+This package can be used to generate new stimuli based on Perlin noise.
+
+To generate a Perlin noise-based video, follow two steps with the package.  First, generate the Perlin noise.  This is the most time consuming step, and will also use a lot of temporary disk space.  This is accomplished with:
+
+```python
+noise = zebranoise.PerlinStimulus(xsize=400, ysize=100, tdur=60*2, xyscale=.2, tscale=50, seed=0)
+```
+
+See the function documentation for perlstim.Perl for more information about modifying the properties of the noise.
+
+Second, apply "filters" to the Perlin noise and save the resulting video.  Filters include thresholds, sync squares in the corner, etc.  If using a filter with no arguments, just pass a string naming the filter.  If using a filter with arguments, pass a tuple where the first element is the name of the filter as a string, and the remaining elements are the arguments.  For example,
+
+```python
+noise.save_video("noise.mp4", filters=["reverse", ("comb", .05)])
+```
+
+The above example applies the "reverse" filter (with no arguments) and the "comb" filter with the argument 0.1.
+
+## Filters
+
+The following filters are currently defined:
+
+- "threshold" (1 argument): set all values above the threshold argument to white, and all below to black.
+- "softthresh" (1 argument): set values much greater than 0 to white and much less than zero to blac.  Use shades of grey for intermediate values, according to a sigmoid with a temperature given as the argument.
+- "comb" (1 argument): Alternate black and white thresholds at intervals given by the argument.
+- "reverse" (0 arguments): play the video in reverse
+- "invert" (0 arguments): switch white and black
+- "wood" (1 argument): similar to "comb", but use a sawtooth wave
+- "blur" (1 argument): Gaussian blur with the given spatial standard deviation
+- "photodiode" (1 argument): Draw a sync square in the corner, with a size given by the argument.
+- "photodiode_anywhere" (3 arguments): Draw a sync square at the coordinates given by the first two arguments (x and y), and of size given by argument 3.
+- [any function] (0 arguments): If you pass a function, the function will be applied to each chunk of the video.  Chunks consist of the entire x and y but a subset of z, guaranteed to be an even number.
+
+## Example
+
+To get started, try the following:
+
+```python
+import zebranoise
+stim = zebranoise.PerlinStimulus(xsize=480, ysize=128, tdur=60*5, xyscale=.2, tscale=50)
+stim.save_video("perlin_stimulus.mp4", loop=1, filters=[("comb", .08), ("photodiode", 30)])
+```
+# Other information
+
+Much of the C code is based on [Casey Duncan's "noise" package for Python](https://github.com/caseman/noise), under the MIT license.

zebranoise-0.1.0/pyproject.toml

@@ -0,0 +1,2 @@
+[build-system]
+requires = ["setuptools", "wheel", "numpy==1.13.3; python_version=='3.6'", "numpy==1.14.5; python_version=='3.7'", "numpy==1.17.3; python_version=='3.8'", "numpy>=2.0; python_version>='3.9'"]

zebranoise-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zebranoise-0.1.0/setup.py

@@ -0,0 +1,46 @@
+import sys
+try:
+    from setuptools import setup, Extension
+except ImportError:
+    from distutils.core import setup, Extension
+
+import numpy as np
+
+if sys.platform != 'win32':
+    compile_args = ['-funroll-loops']
+else:
+    compile_args = []
+
+with open("README.md", "r") as f:
+    long_desc = f.read()
+
+with open("zebranoise/_version.py", "r") as f:
+    exec(f.read())
+
+setup(
+    name='zebranoise',
+    version=__version__,
+    description='Zebra noise stimuli for Python',
+    long_description = long_desc,
+    long_description_content_type='text/markdown',
+    author='Max Shinn',
+    author_email='m.shinn@ucl.ac.uk',
+    url='https://github.com/mwshinn/zebra_noise',
+    classifiers = [
+        'Development Status :: 4 - Beta',
+        'Programming Language :: C',
+        'Programming Language :: Python :: 3',
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: MIT License',
+        'Topic :: Multimedia :: Graphics',
+        'Topic :: Scientific/Engineering',
+    ],
+    install_requires = ['numpy', 'imageio', 'imageio-ffmpeg', 'tqdm'],
+    packages=['zebranoise'],
+    ext_modules=[
+        Extension('zebranoise._perlin', ['zebranoise/_perlin.c'],
+            extra_compile_args=compile_args,
+                  include_dirs=[np.get_include()],
+        )
+    ],
+)

zebranoise-0.1.0/zebranoise/__init__.py

@@ -0,0 +1,5 @@
+from .perlin_stimulus import PerlinStimulus
+from .util import generate_frames
+from .easy import zebra_noise
+
+Perl = PerlinStimulus # Backward compatibility

zebranoise-0.1.0/zebranoise/_perlin.c

@@ -0,0 +1,239 @@
+// Copyright (c) 2008, Casey Duncan (casey dot duncan at gmail dot com)
+// Copyright (c) 2022, Max Shinn
+// see LICENSE.txt for details
+
+#include "Python.h"
+#include <math.h>
+#include <stdio.h>
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+
+#ifdef _MSC_VER
+#define inline __inline
+#endif
+
+#define lerp(t, a, b) ((a) + (t) * ((b) - (a)))
+
+const float GRAD3[][3] = {
+	{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0}, 
+	{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1}, 
+	{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1},
+	{1,0,-1},{-1,0,-1},{0,-1,1},{0,1,1}};
+
+// At the possible cost of unaligned access, we use char instead of
+// int here to try to ensure that this table fits in L1 cache
+const unsigned char PERM[] = {
+  151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140,
+  36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120,
+  234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
+  88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
+  134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
+  230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161,
+  1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130,
+  116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
+  124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227,
+  47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44,
+  154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
+  108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
+  242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14,
+  239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121,
+  50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243,
+  141, 128, 195, 78, 66, 215, 61, 156, 180, 151, 160, 137, 91, 90, 15, 131,
+  13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37,
+  240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252,
+  219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125,
+  136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158,
+  231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245,
+  40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187,
+  208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198,
+  173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126,
+  255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223,
+  183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167,
+  43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185,
+  112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179,
+  162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199,
+  106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236,
+  205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156,
+  180};
+
+
+static inline float
+grad3(const int hash, const float x, const float y, const float z)
+{
+	const int h = hash & 15;
+	return x * GRAD3[h][0] + y * GRAD3[h][1] + z * GRAD3[h][2];
+}
+
+float
+noise3(float x, float y, float z, const int repeatx, const int repeaty, const int repeatz, 
+	const int base)
+{
+	float fx, fy, fz;
+	int A, AA, AB, B, BA, BB;
+	int i = (int)x;
+  int j = (int)y;
+  int k = (int)z;
+	int ii = (i + 1) %  repeatx;
+	int jj = (j + 1) % repeaty;
+	int kk = (k + 1) % repeatz;
+	i = ((i + base) & 255);
+	j = ((j + base) & 255);
+	k = ((k + base) & 255);
+	ii = ((ii + base) & 255);
+	jj = ((jj + base) & 255);
+	kk = ((kk + base) & 255);
+
+	x -= (float)(int)x; y -= (float)(int)y; z -= (float)(int)z;
+	fx = x*x*x * (x * (x * 6 - 15) + 10);
+	fy = y*y*y * (y * (y * 6 - 15) + 10);
+	fz = z*z*z * (z * (z * 6 - 15) + 10);
+
+	A = PERM[i];
+	AA = PERM[A + j];
+	AB = PERM[A + jj];
+	B = PERM[ii];
+	BA = PERM[B + j];
+	BB = PERM[B + jj];
+
+	return lerp(fz, lerp(fy, lerp(fx, grad3(PERM[AA + k], x, y, z),
+									  grad3(PERM[BA + k], x - 1, y, z)),
+							 lerp(fx, grad3(PERM[AB + k], x, y - 1, z),
+									  grad3(PERM[BB + k], x - 1, y - 1, z))),
+					lerp(fy, lerp(fx, grad3(PERM[AA + kk], x, y, z - 1),
+									  grad3(PERM[BA + kk], x - 1, y, z - 1)),
+							 lerp(fx, grad3(PERM[AB + kk], x, y - 1, z - 1),
+									  grad3(PERM[BB + kk], x - 1, y - 1, z - 1))));
+}
+
+static PyObject *
+make_perlin(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+	int octaves = 1;
+	float persistence = 0.5f;
+  float lacunarity = 2.0f;
+	int repeatx = 1024; // arbitrary
+	int repeaty = 1024; // arbitrary
+	int repeatz = 1024; // arbitrary
+	int base = 0;
+
+
+  float *x, *y, *z;
+  PyArrayObject *_x, *_y, *_z;
+  PyObject *__x, *__y, *__z;
+
+	static char *kwlist[] = {"x", "y", "z", "octaves", "persistence", "lacunarity",
+		"repeatx", "repeaty", "repeatz", "base", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|iffiiii:noise3", kwlist,
+		&__x, &__y, &__z, &octaves, &persistence, &lacunarity, &repeatx, &repeaty, &repeatz, &base))
+		return NULL;
+  if (base < 0 || base > 255) {
+    PyErr_SetString(PyExc_ValueError, "Base must be between 0 and 255");
+    return NULL;
+  }
+  _x = (PyArrayObject*)PyArray_FROMANY(__x, NPY_FLOAT, 1, 1, NPY_ARRAY_C_CONTIGUOUS);
+  _y = (PyArrayObject*)PyArray_FROMANY(__y, NPY_FLOAT, 1, 1, NPY_ARRAY_C_CONTIGUOUS);
+  _z = (PyArrayObject*)PyArray_FROMANY(__z, NPY_FLOAT, 1, 1, NPY_ARRAY_C_CONTIGUOUS);
+  if (!_x || !_y || !_z)
+    return NULL;
+  x = (float*)PyArray_DATA(_x);
+  y = (float*)PyArray_DATA(_y);
+  z = (float*)PyArray_DATA(_z);
+  int len_x = PyArray_SIZE(_x);
+  int len_y = PyArray_SIZE(_y);
+  int len_z = PyArray_SIZE(_z);
+  int i,j,k,l;
+  float *ret = (float*)malloc(sizeof(float)*len_x*len_y*len_z);
+  if (x[len_x-1] >= repeatx || y[len_y-1] >= repeaty || z[len_z-1] >= repeatz) {
+		PyErr_SetString(PyExc_ValueError, "Cannot pass values greater than repeatx/y/z");
+    return NULL;
+  }
+
+	if (octaves == 1) {
+		// Single octave, return simple noise
+    for (i=0; i<len_x; i++) {
+      for (j=0; j<len_y; j++) {
+        for (k=0; k<len_z; k++) {
+          ret[i*len_y*len_z+j*len_z+k] = noise3(x[i], y[j], z[k],
+                                                repeatx, repeaty, repeatz, base);
+        }
+      }
+    }
+	} else if (octaves > 1) {
+    for (i=0; i<len_x; i++) {
+      for (j=0; j<len_y; j++) {
+        for (k=0; k<len_z; k++) {
+          float freq = 1.0f;
+          float amp = 1.0f;
+          float max = 0.0f;
+          float total = 0.0f;
+          for (l = 0; l < octaves; l++) {
+            total += noise3(x[i] * freq, y[j] * freq, z[k] * freq,
+              (const int)(repeatx*freq), (const int)(repeaty*freq), (const int)(repeatz*freq), base) * amp;
+            max += amp;
+            freq *= lacunarity;
+            amp *= persistence;
+            if (amp < .004) break; // No chance of influence beyond ~1/256
+          }
+          ret[i*len_y*len_z+j*len_z+k] = (float) (total / max);
+        }
+      }
+    }
+	} else {
+		PyErr_SetString(PyExc_ValueError, "Expected octaves value > 0");
+		return NULL;
+	}
+  npy_intp dims[3] = { len_x, len_y, len_z };
+  PyObject *retarray = PyArray_SimpleNewFromData(3, dims, NPY_FLOAT, ret);
+  PyArray_ENABLEFLAGS((PyArrayObject*)retarray, NPY_ARRAY_OWNDATA);
+  Py_DECREF(_x);
+  Py_DECREF(_y);
+  Py_DECREF(_z);
+  return retarray;
+}
+
+static PyMethodDef perlin_functions[] = {
+	{"make_perlin", (PyCFunction) make_perlin, METH_VARARGS | METH_KEYWORDS,
+    "Generate a perlin noise stimulus\n\
+\n\
+    Parameters\n\
+    ----------\n\
+    x,y,z : 1D ndarray of float32, length > 0\n\
+        Grid of positions on which to compute the noise\n\
+    octaves : int > 0, default: 1\n\
+        Number of spatial scales to include\n\
+    persistence : float > 0, default: 0.5\n\
+        Relative strength of neighbouring octaves\n\
+    repeatx,repeaty,repeatz : int > 0, default: 1024\n\
+        Maximum x, y, or z value before the stimulus repeats\n\
+    base : int ∈ [0,255], default: 0\n\
+        Start position of the permutation, essentially the random seed\n\
+\n\
+    Returns\n\
+    -------\n\
+    3D int ndarray, values ∈ [0,255]\n\
+        Pink noise movie\n\
+"},
+	{NULL}
+};
+
+PyDoc_STRVAR(module_doc, "Efficiently generate Perlin noise, based on the 'noise' package by Casey Duncan");
+
+static struct PyModuleDef moduledef = {
+	PyModuleDef_HEAD_INIT,
+	"_perlin",
+	module_doc,
+	-1,                 /* m_size */
+	perlin_functions,   /* m_methods */
+	NULL,               /* m_reload (unused) */
+	NULL,               /* m_traverse */
+	NULL,               /* m_clear */
+	NULL                /* m_free */
+};
+
+PyObject *
+PyInit__perlin(void)
+{
+  import_array();
+  return PyModule_Create(&moduledef);
+}

zebranoise-0.1.0/zebranoise/_version.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

zebranoise-0.1.0/zebranoise/easy.py

@@ -0,0 +1,51 @@
+import imageio
+from tqdm import tqdm
+import warnings
+from .util import generate_frames, filter_frames_index_function, apply_filters, discretize
+
+def zebra_noise(output_file, xsize, ysize, tdur, levels=10, xyscale=.2, tscale=50, fps=30, xscale=1.0, yscale=1.0, seed=0, filters=[("comb", 0.08)]):
+    """Generate a .mp4 of zebra noise.
+
+    This method is a simplified interface for the PerlinStimulus class, designed to only generate zebra noise
+    as defined in the paper.
+
+    Parameters
+    ----------
+    output_file : string
+        Filename to save the generated .mp4 file
+    xsize, ysize : int
+        The x and y dimensions of the output video. (Sometimes these will be rounded up to multiples of 16.)
+    tdur : float
+        The duration of the video in seconds
+    levels : int
+        The number of octaves to use when approximating the 1/f spectrum. The default of 10 should be more than enough.
+    xyscale : float from (0,1)
+        The spatial scale of the Perlin noise. Values near 0 will make the video smoother and near 1 choppier.
+    tscale : int
+        A scaling factor to set the speed of the video
+    xscale, yscale : float
+        Resize the x and y dimensions of the output
+    fps : int
+        Frames per second
+    seed : int
+        Random seed
+    
+    Returns
+    -------
+    None, but saves the video file to the desired filename
+    """ 
+    tsize = int(tdur*fps)
+    tscale = tscale * (fps/30)
+    textra = (tscale - (tsize % tscale)) % tscale
+    if textra > 0:
+        warnings.warn(f"Adding {textra} extra timepoints to make tscale a multiple of tdur")
+    tsize += round(textra)
+    get_index = filter_frames_index_function(filters, tsize)
+    writer = imageio.get_writer(output_file, fps=fps)
+    for _i in tqdm(range(0, tsize)):
+        i = get_index(_i)
+        frame = generate_frames(xsize, ysize, tsize, [i], levels=levels, xyscale=xyscale, tscale=tscale, xscale=xscale, yscale=yscale, seed=seed)
+        filtered = apply_filters(frame[None], filters)[0] # TODO I don't think this will work with the photodiode filter
+        disc = discretize(filtered[:,:,0])
+        writer.append_data(disc)
+    writer.close()

zebranoise-0.1.0/zebranoise/perlin_stimulus.py

@@ -0,0 +1,267 @@
+import hashlib
+import os
+import warnings
+import tempfile
+from subprocess import call
+from pathlib import Path
+import numpy as np
+import imageio
+from imageio_ffmpeg import get_ffmpeg_exe
+
+from . import _perlin
+from .util import generate_frames, filter_frames, filter_frames_index_function, XYSCALEBASE, discretize
+
+
+class PerlinStimulus:
+    """Class to generate a Perlin noise stimulus.
+
+    This is the "heavy duty" way of generating stimuli, mostly for experimenting
+    with new Perlin-based stimuli.  If you would just like to generate zebra
+    noise, use the "zebra_noise" function instead, which is faster and more
+    memory efficient.
+
+    To generate noise, instantiate this method.  This will automatically
+    generate Perlin noise which you can save, filter, etc.
+
+    """
+    def __init__(self, xsize, ysize, tdur, levels=10, xyscale=.2, tscale=50, fps=30, xscale=1.0, yscale=1.0, seed=0, demean="both", cachedir="perlcache", delay_batch=False):
+        """Initialise Perlin noise stimulus.
+
+        Parameters
+        ----------
+        xsize,ysize : int > 0
+            The number of pixels in the x or y dimension
+        tdur : int > 0
+            The duration of the stimulus, in seconds.  Sometimes will be slightly longer.
+        levels : int > 0, default: 10
+            The number of spatial scales to include.  The default is usually okay.
+        xyscale : float ∈ [0,1], default: 0.5
+            The spatial grain scale of the noise, larger is more granular
+        xscale : float, default: 1.0
+            The spatial scale in x, larger is a bigger scale
+        yscale : float, default: 1.0
+            The spatial scale in y, larger is a bigger scale
+        tscale : int > 0, default: 1
+            The temporal scaling of the noise, larger is slower.
+        fps : int > 0, default: 30
+            Frames per second of the stimulus
+        seed : int ∈ [0, 255], default: 0
+            Random seed for the noise
+        demean : {'both', 'time', 'space', 'none'}, default: 'both'
+            Dimensions across which to fix the mean to zero
+        cachedir : str
+            A file path to the cache directory.  Will contain large files.
+        delay_batch : bool
+            If true, do not immediately generate perlin noise.  Manually call self.generate_batch() instead.
+
+        Notes
+        -----
+        This causes data to be written to the disk and long-running
+        computations to be performed
+
+        """
+        assert demean in ["both", "time", "space", "none"]
+        tsize = int(tdur*fps)
+        tscale = tscale
+        self.ratio = xsize/ysize*XYSCALEBASE
+        assert self.ratio == int(self.ratio), f"Ratio between x and y times {XYSCALEBASE} must be an integer"
+        self.ratio = int(self.ratio)
+        textra = (tscale - (tsize % tscale)) % tscale
+        if textra > 0:
+            warnings.warn(f"Adding {textra} extra timepoints to make tscale a multiple of tdur")
+        tsize += round(textra)
+        self.size = (xsize, ysize, tsize)
+        assert self.size[0] >= self.size[1], "Wrong orientation"
+        self.fps = fps
+        self.seed = seed
+        self.cachedir = Path(cachedir)
+        self.cachedir.mkdir(exist_ok=True)
+        self.tmpdir = Path(tempfile.mkdtemp())
+        self.xyscale = xyscale
+        self.tscale = tscale
+        self.levels = levels
+        self.demean = demean
+        self.xscale = xscale
+        self.yscale = yscale
+        self.batch_size = int(400000000/(self.size[0]*self.size[1]))
+        #self.batch_size = int(400000/(self.size[0]*self.size[1]))
+        if self.batch_size % 2 == 1: # Make sure it is an even number
+            self.batch_size += 1
+        if not delay_batch:
+            self.generate_batch()
+    def cache_filename(self, batch=None):
+        """Return the filename for the cache.
+
+        The cache is split up into different batches, saved in different files
+
+        Parameters
+        ----------
+        batch : int, 'stats', or None
+            The ID of the batch to find.
+
+        Returns
+        -------
+        str
+            The filename of the cache
+        """
+        h = hashlib.md5(str((self.size, self.fps, self.seed, self.xyscale, self.tscale, self.levels, self.demean)).encode()).hexdigest()
+        if batch is None:
+            return str(self.cachedir.joinpath(f"perlcache_{h}.npy"))
+        if batch == "stats":
+            return str(self.cachedir.joinpath(f"perlcache_{h}_stats.npz"))
+        return str(self.cachedir.joinpath(f"perlcache_{h}_{batch}.npy"))
+    def generate_frame(self, t=0, filters=[]):
+        """Generate and return a single image of noise.
+
+
+        Parameters
+        ----------
+        t : float
+            the frame at which to generate the image
+        filters : list of str and/or (str, ...) tuples
+            A list of filters to apply to the stimulus.  If a filter requires
+            parameters, pass a tuple, where the first element is the name of
+            the filter and the subsequent elements are the parameters.
+
+        Returns
+        -------
+        2-dimensional ndarray
+            An image of the noise
+        """
+        arr = generate_frames(self.size[0], self.size[1], self.size[2], timepoints=[t] if not hasattr(t, "__iter__") else t, levels=self.levels,
+                              xyscale=self.xyscale, tscale=self.tscale, xscale=self.xscale,
+                              yscale=self.yscale, fps=self.fps, seed=self.seed)
+        if self.demean in ["both", "time"]:
+            arr -= np.mean(arr, axis=(0,1), keepdims=True)
+        arr = apply_filters(arr, filters)
+        return arr.squeeze()
+
+    def generate_batch(self):
+        """Create the stimulus
+
+        Runs the _perlin C module and saves the output in batches.
+
+        If this function has already been run before and has been cached on the
+        filesytem, automatically load the statistics from it.  Otherwise,
+        generate the stimuli and cache them.
+        """
+        # If the cache already exists, load the statistics (used for
+        # normalisation) and exit immediately.
+        if os.path.isfile(self.cache_filename("stats")):
+            stats = np.load(self.cache_filename("stats"))
+            self.min_ = stats['min_']
+            self.max_ = stats['max_']
+            self.nframes = stats['nframes']
+            return
+        # Generate the stimuli and save the means and mins/maxes.  If we are
+        # demeaning across space, we won't end up using the mins or maxes saved
+        # here.
+        means_t = []
+        means_xy = []
+        weights = []
+        mins = []
+        maxes = []
+        for k in range(0, int(np.ceil(self.size[2]/self.batch_size))):
+            print(f"Generating batch {k}")
+            arr = generate_frames(self.size[0], self.size[1], tsize=self.size[2],
+                                  timepoints=list(range(k*self.batch_size,min(self.size[2],(k+1)*self.batch_size))),
+                                  levels=self.levels, xyscale=self.xyscale, tscale=self.tscale, xscale=self.xscale,
+                                  yscale=self.yscale, fps=self.fps, seed=self.seed)
+            if self.demean in ["both", "time"]:
+                arr -= np.mean(arr, axis=(0,1), keepdims=True)
+            mins.append(np.min(arr))
+            maxes.append(np.max(arr))
+            means_t.append(np.mean(arr, axis=2))
+            weights.append(arr.shape[2])
+            np.save(self.cache_filename(k), arr.astype("float16"))
+            del arr
+        # Compute the spatial mean (across t)
+        mean_t = np.sum(means_t*(np.asarray(weights)[:,None,None]), axis=0)/np.sum(weights)
+        nframes = np.sum(weights)
+        # Optionally remove the spatial mean.  If so, iterate through and
+        # update all of the saved data files to remove the spatial mean.
+        if self.demean in ["both", "space"]:
+            k = 0
+            mins = []
+            maxes = []
+            while os.path.isfile(self.cache_filename(k)):
+                arr = np.load(self.cache_filename(k)).astype("float32")
+                arr -= mean_t[:,:,None]
+                mins.append(np.min(arr))
+                maxes.append(np.max(arr))
+                np.save(self.cache_filename(k), arr.astype("float16"))
+                del arr
+                k += 1
+        min_ = np.min(mins)
+        max_ = np.max(maxes)
+        # Save the mins and maxes.
+        np.savez_compressed(self.cache_filename("stats"), min_=min_, max_=max_, nframes=nframes)
+        self.min_ = min_
+        self.max_ = max_
+        self.nframes = nframes
+    def save_grey_pad(self, fn, dur, bitrate=20):
+        """Create a grey screen video which can be used to pad"""
+        one_frame = np.load(self.cache_filename(0), mmap_mode='r')[:,:,0].astype('uint8') * 0 + 127
+        imageio.imsave(self.tmpdir.joinpath("_grey.tif"), one_frame, format="pillow", compression="tiff_adobe_deflate")
+        n_frames = int(dur * self.fps)
+        for i in range(0, n_frames):
+            os.link(self.tmpdir.joinpath("_grey.tif"), self.tmpdir.joinpath(f"_frame{i:05}.tif"))
+        if fn[-4:] != ".mp4":
+            fn += ".mp4"
+        call([get_ffmpeg_exe(), "-r", str(self.fps), "-i", str(self.tmpdir.joinpath("_frame%5d.tif")), "-c:v", "mpeg2video", "-an", "-b:v", f"{bitrate}M", fn])
+        for p in self.tmpdir.glob("_frame*.tif"):
+            p.unlink()
+        self.tmpdir.joinpath("_grey.tif").unlink()
+    def save_video(self, fn, loop=1, filters=[], bitrate=20):
+        """Save the filtered stimulus.
+
+        Parameters
+        ----------
+        fn : str
+            The file name to save the video
+        loop : int > 0
+            The number of times the stimulus should loop in the saved video
+        filters : list of str and/or (str, ...) tuples
+            A list of filters to apply to the stimulus.  If a filter requires
+            parameters, pass a tuple, where the first element is the name of
+            the filter and the subsequent elements are the parameters.
+        bitrate : int > 0
+            The bitrate in megabits per second.  The default is good for binary
+            videos and pure noise, but a higher value may be necessary if
+            using the "wood" filter.
+        """
+        if Path(fn).exists():
+            raise IOError("Output video file already exists!")
+        i = 0
+        k = 0
+        filtind = filter_frames_index_function(filters, nframes=self.nframes)
+        while os.path.isfile(self.cache_filename(k)):
+            data = np.load(self.cache_filename(k)).astype("float32")
+            # Renormalise using precomputed mins/maxes
+            data -= self.min_
+            data *= 1/(self.max_-self.min_)
+            # Apply filters
+            for f in filters:
+                if isinstance(f, str):
+                    n = f
+                    args = []
+                else:
+                    n = f[0]
+                    args = f[1:]
+                data = filter_frames(data, n, *args)
+            data = discretize(data)
+            assert data.dtype == 'uint8'
+            for j in range(0, data.shape[2]):
+                imageio.imsave(self.tmpdir.joinpath(f"_frame{filtind(i):05}.tif"), data[:,:,j], format="pillow", compression="tiff_adobe_deflate")
+                i += 1
+            k += 1
+            del data
+        n_frames = i
+        for j in range(1, loop):
+            for i in range(0, n_frames):
+                os.link(self.tmpdir.joinpath(f"_frame{i:05}.tif"), self.tmpdir.joinpath(f"_frame{(i+j*n_frames):05}.tif"))
+        if fn[-4:] != ".mp4":
+            fn += ".mp4"
+        call([get_ffmpeg_exe(), "-r", str(self.fps), "-i", str(self.tmpdir.joinpath("_frame%5d.tif")), "-c:v", "mpeg2video", "-an", "-b:v", f"{bitrate}M", fn])
+        for p in self.tmpdir.glob("_frame*.tif"):
+            p.unlink()

zebranoise-0.1.0/zebranoise/util.py

@@ -0,0 +1,152 @@
+import numpy as np
+import scipy.ndimage
+from . import _perlin
+
+XYSCALEBASE = 100
+
+def filter_frames(im, filt, *args):
+    """Apply a filter/transformation to an image batch
+
+    Parameters
+    ----------
+    im : 3D float ndarray, values ∈ [0,1]
+        Frames to filter
+    filt : str
+        The name of the filter
+    *args : tuple
+        Extra arguments are passed to the filter
+
+    Returns
+    -------
+    im : 3D float ndarray, values ∈ [0,1]
+        Filtered noise movie
+    """
+    if filt == "threshold":
+        return (im>args[0]).astype(np.float32)
+    if filt == "softthresh":
+        return 1/(1+np.exp(-args[0]*(im-.5)))
+    if filt == "comb":
+        return (im//args[0] % 2 == 1).astype(np.float32)
+    if filt == "invert":
+        return 1-im
+    if filt == "reverse":
+        return im # We need to use filter_index_function for this
+    if filt == "blur":
+        return np.asarray([scipy.ndimage.filters.gaussian_filter(im.astype(np.float32)[:,:,i], args[0], mode='wrap') for i in range(0, im.shape[2])]).transpose([1,2,0])
+    if filt == "wood":
+        return (im % args[0]) / args[0]
+    if filt == "center":
+        return 1-(np.abs(im-.5)*2)
+    if filt == "photodiode":
+        im = im.copy()
+        s = args[0]
+        im[:s,-s:,::2] = 0
+        im[:s,-s:,1::2] = 1
+        return im
+    if filt == "photodiode_anywhere":
+        im = im.copy()
+        x = args[0]
+        y = args[1]
+        s = args[2]
+        im[y:(y+s),x:(x+s),::2] = 0
+        im[y:(y+s),x:(x+s),1::2] = 1
+        return im
+    if filt == "photodiode_b2":
+        im = im.copy()
+        s = 125
+        im[:s,-s:,::2] = 0
+        im[:s,-s:,1::2] = 1
+        return im
+    if filt == "photodiode_fusi":
+        im = im.copy()
+        s = 75
+        im[:s,-s:,::2] = 0
+        im[:s,-s:,1::2] = 1
+        return im
+    if filt == "photodiode_bscope":
+        im = im.copy()
+        s = 100
+        im[-s:,:s,::2] = 0
+        im[-s:,:s,1::2] = 1
+        return im
+    if callable(filt):
+        return filt(im)
+    raise ValueError("Invalid filter specified")
+
+def apply_filters(arr, filters):
+    for f in filters:
+        if isinstance(f, str):
+            n = f
+            args = []
+        else:
+            n = f[0]
+            args = f[1:]
+        arr = filter_frames(arr, n, *args)
+    return arr
+
+
+def filter_frames_index_function(filters, nframes):
+    """Reordering frames in the video based on the filter.
+
+
+    Parameters
+    ----------
+    filters : list of strings or tuples
+        the list of filters passed to save_video
+
+    Returns
+    -------
+    function mapping int -> int
+        Reindexing function
+
+    Notes
+    -----
+    Some filters may need to operate on the global video instead of in
+    batches.  However, for large videos, batches are necessary due to
+    limited amounts of RAM.  Thus, this function should return another
+    function which takes an index as input and outputs a new index,
+    remapping the initial noise frame to the output video frame.  This
+    was primarily designed to support reversing the video, but it might be
+    useful for other things too.
+
+    """
+    if "reverse" in filters:
+        return lambda x : nframes - x - 1
+    return lambda x : x
+
+def discretize(im):
+    """Convert movie to an unsigned 8-bit integer
+
+    Parameters
+    ----------
+    im : 3D float ndarray, values ∈ [0,1]
+        Noise movie
+
+    Returns
+    -------
+    3D int ndarray, values ∈ [0,255]
+        Noise movie
+    """
+    im *= 255
+    ret = im.astype(np.uint8)
+    return ret
+
+def generate_frames(xsize, ysize, tsize, timepoints, levels=10, xyscale=.5, tscale=1, xscale=1.0, yscale=1.0, fps=30, seed=0):
+    """Preprocess arguments before passing to the C implementation of Perlin noise.
+    """
+    # Use the temporal scale and number of timepoints to compute how many
+    # units to make the stimulus across the temporal dimension
+    tunits = int(tsize/(tscale*(fps/30)))
+    ts_all = np.arange(0, tsize, dtype="float32")/(tscale*(fps/30))
+    ratio = int(xsize/ysize*XYSCALEBASE)
+    arr = _perlin.make_perlin(np.arange(0, xsize, dtype="float32")/ysize/xscale, # Yes, divide by y size
+                              np.arange(0, ysize, dtype="float32")/ysize/yscale,
+                              ts_all[timepoints],
+                              octaves=levels,
+                              persistence=xyscale,
+                              repeatx=ratio,
+                              repeaty=XYSCALEBASE,
+                              repeatz=tunits,
+                              base=seed)
+    arr = arr.swapaxes(0,1)
+    return arr

zebranoise-0.1.0/zebranoise.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.1
+Name: zebranoise
+Version: 0.1.0
+Summary: Zebra noise stimuli for Python
+Home-page: https://github.com/mwshinn/zebra_noise
+Author: Max Shinn
+Author-email: m.shinn@ucl.ac.uk
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+This library will efficiently generate visual stimulus videos using Perlin noise, including zebra noise.  The core algorithm is in optimized C.
+
+[Example zebra noise](http://www.youtube.com/watch?v=-SyjgbNCP4Q)
+
+[![Example zebra noise](http://img.youtube.com/vi/-SyjgbNCP4Q/0.jpg)](http://www.youtube.com/watch?v=-SyjgbNCP4Q "Example zebra noise")
+
+# Installation
+
+## From pypi
+
+Run:
+
+    pip install zebranoise
+
+## From source
+
+Make sure you have a C compiler installed.  The easiest way to do this is by installing Cython.
+
+Then, install using the standard
+
+    python setup.py install
+
+This will compile the sources and install.
+
+I have only tested this on Linux.
+
+# Usage
+
+## Basic usage
+
+If you would like to generate a zebra noise of size 640x480 for 2 minutes, you can run
+    
+    import zebranoise
+    zebranoise.zebra_noise("output.mp4", xsize=640, ysize=480, tdur=60*2, fps=30, seed=0)
+
+Other parameters control the spatial and temporal frequencies.  For instance,
+
+    zebranoise.zebra_noise("output2.mp4", xsize=640, ysize=480, tdur=60*2, levels=10, xyscale=.2, tscale=50, fps=30, xscale=1.0, yscale=1.0, seed=0)
+
+The meaning of these parameters is:
+
+- **xsize** and **ysize**: the x and y dimensions of the output video.  (Sometimes
+  these will be rounded up to multiples of 16.)
+- **tdur**: the duration in seconds
+- **levels**: The number of octaves to use when approximating the 1/f spectrum.
+  The default of 10 should be more than enough.
+- **xyscale**: The spatial scale of the Perlin noise, from 0 to 1.  Low values
+  will make the video smoother and high values choppier.
+- **tscale**: The speed of the video
+- **xscale** and **yscale**: Resize the x and y dimensions of the output.
+- **fps**: Frames per second
+- **seed**: Random seed
+
+## Advanced usage
+
+This package can be used to generate new stimuli based on Perlin noise.
+
+To generate a Perlin noise-based video, follow two steps with the package.  First, generate the Perlin noise.  This is the most time consuming step, and will also use a lot of temporary disk space.  This is accomplished with:
+
+```python
+noise = zebranoise.PerlinStimulus(xsize=400, ysize=100, tdur=60*2, xyscale=.2, tscale=50, seed=0)
+```
+
+See the function documentation for perlstim.Perl for more information about modifying the properties of the noise.
+
+Second, apply "filters" to the Perlin noise and save the resulting video.  Filters include thresholds, sync squares in the corner, etc.  If using a filter with no arguments, just pass a string naming the filter.  If using a filter with arguments, pass a tuple where the first element is the name of the filter as a string, and the remaining elements are the arguments.  For example,
+
+```python
+noise.save_video("noise.mp4", filters=["reverse", ("comb", .05)])
+```
+
+The above example applies the "reverse" filter (with no arguments) and the "comb" filter with the argument 0.1.
+
+## Filters
+
+The following filters are currently defined:
+
+- "threshold" (1 argument): set all values above the threshold argument to white, and all below to black.
+- "softthresh" (1 argument): set values much greater than 0 to white and much less than zero to blac.  Use shades of grey for intermediate values, according to a sigmoid with a temperature given as the argument.
+- "comb" (1 argument): Alternate black and white thresholds at intervals given by the argument.
+- "reverse" (0 arguments): play the video in reverse
+- "invert" (0 arguments): switch white and black
+- "wood" (1 argument): similar to "comb", but use a sawtooth wave
+- "blur" (1 argument): Gaussian blur with the given spatial standard deviation
+- "photodiode" (1 argument): Draw a sync square in the corner, with a size given by the argument.
+- "photodiode_anywhere" (3 arguments): Draw a sync square at the coordinates given by the first two arguments (x and y), and of size given by argument 3.
+- [any function] (0 arguments): If you pass a function, the function will be applied to each chunk of the video.  Chunks consist of the entire x and y but a subset of z, guaranteed to be an even number.
+
+## Example
+
+To get started, try the following:
+
+```python
+import zebranoise
+stim = zebranoise.PerlinStimulus(xsize=480, ysize=128, tdur=60*5, xyscale=.2, tscale=50)
+stim.save_video("perlin_stimulus.mp4", loop=1, filters=[("comb", .08), ("photodiode", 30)])
+```
+# Other information
+
+Much of the C code is based on [Casey Duncan's "noise" package for Python](https://github.com/caseman/noise), under the MIT license.
+
+

zebranoise-0.1.0/zebranoise.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.txt
+README.md
+pyproject.toml
+setup.py
+zebranoise/__init__.py
+zebranoise/_perlin.c
+zebranoise/_version.py
+zebranoise/easy.py
+zebranoise/perlin_stimulus.py
+zebranoise/util.py
+zebranoise.egg-info/PKG-INFO
+zebranoise.egg-info/SOURCES.txt
+zebranoise.egg-info/dependency_links.txt
+zebranoise.egg-info/requires.txt
+zebranoise.egg-info/top_level.txt

zebranoise-0.1.0/zebranoise.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zebranoise-0.1.0/zebranoise.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+imageio
+imageio-ffmpeg
+tqdm

zebranoise-0.1.0/zebranoise.egg-info/top_level.txt

@@ -0,0 +1 @@
+zebranoise