Neuroinflab
diff --git a/‎.gitignore‎
Lines changed: 13 additions & 0 deletions b/‎.gitignore‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎corelib/KCSD.py‎
Lines changed: 15 additions & 7 deletions b/‎corelib/KCSD.py‎
Lines changed: 15 additions & 7 deletions
diff --git a/‎corelib/basis_functions.py‎
Lines changed: 4 additions & 5 deletions b/‎corelib/basis_functions.py‎
Lines changed: 4 additions & 5 deletions
diff --git a/‎corelib/bresenhamline.py‎
Lines changed: 117 additions & 0 deletions b/‎corelib/bresenhamline.py‎
Lines changed: 117 additions & 0 deletions
@@ -62,3 +62,16 @@ target/
 
 #Ipython Notebook
 .ipynb_checkpoints
+#testing files
+testing/
+
+#data
+examples/
+.idea/
+preprocessed_data/
+raw_data/
+*~
+/#*
+*png
+Data/gang_min/
+simulation
@@ -9,14 +9,18 @@
 KCSD1D[1][2], KCSD2D[1], KCSD3D[1], MoIKCSD[1]
 
 """
-from __future__ import division
+from __future__ import division, print_function, absolute_import
 
 import numpy as np
 from scipy import special, integrate, interpolate
 from scipy.spatial import distance
 from numpy.linalg import LinAlgError
-import utility_functions as utils
-import basis_functions as basis
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+import corelib.utility_functions as utils
+import corelib.basis_functions as basis
 
 # from . import utility_functions as utils
 # from . import basis_functions as basis
@@ -112,6 +116,7 @@ def parameters(self, **kwargs):
         self.xmin = kwargs.pop('xmin', np.min(self.ele_pos[:, 0]))
         self.xmax = kwargs.pop('xmax', np.max(self.ele_pos[:, 0]))
         self.gdx = kwargs.pop('gdx', 0.01*(self.xmax - self.xmin))
+        self.dist_table_density = kwargs.pop('dist_table_density',20)
         if self.dim >= 2:
             self.ext_y = kwargs.pop('ext_y', 0.0)
             self.ymin = kwargs.pop('ymin', np.min(self.ele_pos[:, 1]))
@@ -139,7 +144,7 @@ def method(self):
         self.update_b_src()                                 # update crskernel
         self.update_b_interp_pot()                          # update pot interp
 
-    def create_lookup(self, dist_table_density=20):
+    def create_lookup(self):
         """Creates a table for easy potential estimation from CSD.
         Updates and Returns the potentials due to a
         given basis source like a lookup
@@ -148,10 +153,10 @@ def create_lookup(self, dist_table_density=20):
         Parameters
         ----------
         dist_table_density : int
-            number of distance values at which potentials are computed.
+            number of distance points at which potentials are computed.
             Default 100
         """
-        xs = np.logspace(0., np.log10(self.dist_max+1.), dist_table_density)
+        xs = np.logspace(0., np.log10(self.dist_max+1.), self.dist_table_density)
         xs = xs - 1.0  # starting from 0
         dist_table = np.zeros(len(xs))
         for i, pos in enumerate(xs):
@@ -162,7 +167,6 @@ def create_lookup(self, dist_table_density=20):
                                                self.basis)
         self.interpolate_pot_at = interpolate.interp1d(xs, dist_table,
                                                        kind='cubic')
-
     def update_b_pot(self):
         """Updates the b_pot  - array is (#_basis_sources, #_electrodes)
         Updates the  k_pot - array is (#_electrodes, #_electrodes) K(x,x')
@@ -190,6 +194,7 @@ def update_b_src(self):
         ----------
         None
         """
+        #Tu jest basis!
         self.b_src = self.basis(self.src_estm_dists, self.R).T
         self.k_interp_cross = np.dot(self.b_src, self.b_pot)  # K_t(x,y) Eq17
         self.k_interp_cross /= self.n_src
@@ -407,6 +412,9 @@ def __init__(self, ele_pos, pots, **kwargs):
             lambd : float
                 regularization parameter for ridge regression
                 Defaults to 0.
+            dist_table_density : int
+                size of the potential interpolation table
+                Defaults to 20
 
         Raises
         ------
 
@@ -10,8 +10,7 @@
 Laboratory of Neuroinformatics,
 Nencki Institute of Experimental Biology, Warsaw.
 """
-from __future__ import division
-
+from __future__ import division, print_function, absolute_import
 import numpy as np
 
 def gauss(d, stdev, dim):
@@ -66,7 +65,7 @@ def gauss_1D(d, three_stdev):
     -------
     Z : (three_std/3)*(1/2*pi)*(exp(-0.5)*stddev**(-2) *(d**2))
     """
-    stdev = three_stdev/3.0
+    stdev = three_stdev/3
     Z = gauss(d, stdev, 1)
     return Z
 
@@ -121,7 +120,7 @@ def gauss_2D(d, three_stdev):
     Z : function
         Normalized gaussian 2D function
     """
-    stdev = three_stdev/3.0
+    stdev = three_stdev/3
     Z = gauss(d, stdev, 2)
     return Z
 
@@ -158,7 +157,7 @@ def gauss_3D(d, three_stdev):
     Z : funtion
         Normalized gaussian 3D function
     """
-    stdev = three_stdev/3.0
+    stdev = three_stdev/3
     Z = gauss(d, stdev, 3)
     return Z
 
 
@@ -0,0 +1,117 @@
+"""
+N-D Bresenham line algo
+
+
+Copyright 2012 Vikas Dhiman
+
+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.
+
+"""
+import numpy as np
+
+def _bresenhamline_nslope(slope):
+    """
+    Normalize slope for Bresenham's line algorithm.
+    >>> s = np.array([[-2, -2, -2, 0]])
+    >>> _bresenhamline_nslope(s)
+    array([[-1., -1., -1.,  0.]])
+    >>> s = np.array([[0, 0, 0, 0]])
+    >>> _bresenhamline_nslope(s)
+    array([[ 0.,  0.,  0.,  0.]])
+    >>> s = np.array([[0, 0, 9, 0]])
+    >>> _bresenhamline_nslope(s)
+    array([[ 0.,  0.,  1.,  0.]])
+    """
+    scale = np.amax(np.abs(slope), axis=1).reshape(-1, 1)
+    zeroslope = (scale == 0).all(1)
+    scale[zeroslope] = np.ones(1)
+    normalizedslope = np.array(slope, dtype=np.double) / scale
+    normalizedslope[zeroslope] = np.zeros(slope[0].shape)
+    return normalizedslope
+
+def _bresenhamlines(start, end, max_iter):
+    """
+    Returns npts lines of length max_iter each. (npts x max_iter x dimension) 
+    >>> s = np.array([[3, 1, 9, 0],[0, 0, 3, 0]])
+    >>> _bresenhamlines(s, np.zeros(s.shape[1]), max_iter=-1)
+    array([[[ 3,  1,  8,  0],
+            [ 2,  1,  7,  0],
+            [ 2,  1,  6,  0],
+            [ 2,  1,  5,  0],
+            [ 1,  0,  4,  0],
+            [ 1,  0,  3,  0],
+            [ 1,  0,  2,  0],
+            [ 0,  0,  1,  0],
+            [ 0,  0,  0,  0]],
+    <BLANKLINE>
+           [[ 0,  0,  2,  0],
+            [ 0,  0,  1,  0],
+            [ 0,  0,  0,  0],
+            [ 0,  0, -1,  0],
+            [ 0,  0, -2,  0],
+            [ 0,  0, -3,  0],
+            [ 0,  0, -4,  0],
+            [ 0,  0, -5,  0],
+            [ 0,  0, -6,  0]]])
+    """
+    if max_iter == -1:
+        max_iter = np.amax(np.amax(np.abs(end - start), axis=1))
+    npts, dim = start.shape
+    nslope = _bresenhamline_nslope(end - start)
+
+    # steps to iterate on
+    stepseq = np.arange(1, max_iter + 1)
+    stepmat = np.tile(stepseq, (dim, 1)).T
+
+    # some hacks for broadcasting properly
+    bline = start[:, np.newaxis, :] + nslope[:, np.newaxis, :] * stepmat
+
+    # Approximate to nearest int
+    return np.array(np.rint(bline), dtype=start.dtype)
+
+def bresenhamline(start, end, max_iter=5):
+    """
+    Returns a list of points from (start, end] by ray tracing a line b/w the
+    points.
+    Parameters:
+        start: An array of start points (number of points x dimension)
+        end:   An end points (1 x dimension)
+            or An array of end point corresponding to each start point
+                (number of points x dimension)
+        max_iter: Max points to traverse. if -1, maximum number of required
+                  points are traversed
+    Returns:
+        linevox (n x dimension) A cumulative array of all points traversed by
+        all the lines so far.
+    >>> s = np.array([[3, 1, 9, 0],[0, 0, 3, 0]])
+    >>> bresenhamline(s, np.zeros(s.shape[1]), max_iter=-1)
+    array([[ 3,  1,  8,  0],
+           [ 2,  1,  7,  0],
+           [ 2,  1,  6,  0],
+           [ 2,  1,  5,  0],
+           [ 1,  0,  4,  0],
+           [ 1,  0,  3,  0],
+           [ 1,  0,  2,  0],
+           [ 0,  0,  1,  0],
+           [ 0,  0,  0,  0],
+           [ 0,  0,  2,  0],
+           [ 0,  0,  1,  0],
+           [ 0,  0,  0,  0],
+           [ 0,  0, -1,  0],
+           [ 0,  0, -2,  0],
+           [ 0,  0, -3,  0],
+           [ 0,  0, -4,  0],
+           [ 0,  0, -5,  0],
+           [ 0,  0, -6,  0]])
+    """
+    # Return the points as a single array
+    return _bresenhamlines(start, end, max_iter).reshape(-1, start.shape[-1])
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()