Adds Sphere Object to sphere function in viz.actors

README.rst

@@ -23,7 +23,7 @@
 .. image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
   :target: https://github.com/nipy/dipy/blob/master/LICENSE
 
-DIPY is a python toolbox for analysis of MR diffusion imaging.
+DIPY [DIPYREF]_ is a python library for analysis of MR diffusion imaging.
 
 DIPY is for research only; please do not use results from DIPY for
 clinical decisions.
@@ -83,3 +83,11 @@ Contributing
 ============
 
 We welcome contributions from the community. Please read our `Contributing guidelines <https://github.com/nipy/dipy/blob/master/CONTRIBUTING.md>`_.
+
+Reference
+=========
+
+.. [DIPYREF] E. Garyfallidis, M. Brett, B. Amirbekian, A. Rokem,
+    S. Van Der Walt, M. Descoteaux, I. Nimmo-Smith and DIPY contributors,
+    "DIPY, a library for the analysis of diffusion MRI data",
+    Frontiers in Neuroinformatics, vol. 8, p. 8, Frontiers, 2014.

dipy/align/imwarp.py

@@ -1373,9 +1373,9 @@ def _get_energy_derivative(self):
         x = range(self.energy_window)
         y = self.energy_list[(n_iter - self.energy_window):n_iter]
         ss = sum(y)
-        if(ss > 0):
-            ss *= -1
-        y = [v / ss for v in y]
+        if not ss == 0:  # avoid division by zero
+            ss = - ss if ss > 0 else ss
+            y = [v / ss for v in y]
         der = self._approximate_derivative_direct(x, y)
         return der
 

dipy/reconst/mapmri.py

@@ -401,8 +401,8 @@ def fit(self, data):
                 lopt * cvxpy.quad_form(c, laplacian_matrix)
             )
             M0 = M[self.gtab.b0s_mask, :]
-            constraints = [M0[0] * c == 1,
-                           K * c > -.1]
+            constraints = [(M0[0] * c) == 1,
+                           (K * c) >= -0.1]
             prob = cvxpy.Problem(objective, constraints)
             try:
                 prob.solve(solver=self.cvxpy_solver)

dipy/reconst/shore.py

@@ -269,7 +269,7 @@ def fit(self, data):
                     self.cache_set(
                         'shore_matrix_positive_constraint',
                         (self.pos_grid, self.pos_radius), psi)
-                constraints = [M0[0] * c == 1., psi * c > 1e-3]
+                constraints = [(M0[0] * c) == 1., (psi * c) >= 1e-3]
             prob = cvxpy.Problem(objective, constraints)
             try:
                 prob.solve(solver=self.cvxpy_solver)

dipy/reconst/tests/test_forecast.py

@@ -50,11 +50,11 @@ def test_forecast_positive_constrain():
 
     sphere = get_sphere('repulsion100')
     fodf = f_fit.odf(sphere, clip_negative=False)
-    assert_equal(fodf[fodf < 0].sum(), 0)
+    assert_almost_equal(fodf[fodf < 0].sum(), 0, 2)
 
     coeff = f_fit.sh_coeff
     c0 = np.sqrt(1.0/(4*np.pi))
-    assert_almost_equal(coeff[0], c0, 10)
+    assert_almost_equal(coeff[0], c0, 5)
 
 
 def test_forecast_csd():

dipy/reconst/tests/test_shore.py

@@ -53,7 +53,7 @@ def test_shore_positive_constrain():
                      pos_radius=20e-03)
     asmfit = asm.fit(data.S)
     eap = asmfit.pdf_grid(11, 20e-03)
-    assert_equal(eap[eap < 0].sum(), 0)
+    assert_almost_equal(eap[eap < 0].sum(), 0, 3)
 
 
 def test_shore_fitting_no_constrain_e0():

dipy/tracking/streamline.py

@@ -29,16 +29,19 @@
 
     MEGABYTE = 1024 * 1024
 
-
     class _BuildCache(object):
         def __init__(self, arr_seq, common_shape, dtype):
             self.offsets = list(arr_seq._offsets)
             self.lengths = list(arr_seq._lengths)
             self.next_offset = arr_seq._get_next_offset()
             self.bytes_per_buf = arr_seq._buffer_size * MEGABYTE
             # Use the passed dtype only if null data array
-            self.dtype = dtype if arr_seq._data.size == 0 else arr_seq._data.dtype
-            if arr_seq.common_shape != () and common_shape != arr_seq.common_shape:
+            if arr_seq._data.size == 0:
+                self.dtype = dtype
+            else:
+                arr_seq._data.dtype
+            if (arr_seq.common_shape != () and
+                    common_shape != arr_seq.common_shape):
                 raise ValueError(
                     "All dimensions, except the first one, must match exactly")
             self.common_shape = common_shape
@@ -50,34 +53,32 @@ def update_seq(self, arr_seq):
             arr_seq._offsets = np.array(self.offsets)
             arr_seq._lengths = np.array(self.lengths)
 
-
     class Streamlines(ArraySequence):
-
         def __init__(self, *args, **kwargs):
             super(Streamlines, self).__init__(*args, **kwargs)
 
         def append(self, element, cache_build=False):
-            """ Appends `element` to this array sequence.
+            """
+            Appends `element` to this array sequence.
+
             Append can be a lot faster if it knows that it is appending several
-            elements instead of a single element.  In that case it can cache the
-            parameters it uses between append operations, in a "build cache".  To
-            tell append to do this, use ``cache_build=True``.  If you use
-            ``cache_build=True``, you need to finalize the append operations with
-            :meth:`finalize_append`.
+            elements instead of a single element.  In that case it can cache
+            the parameters it uses between append operations, in a "build
+            cache". To tell append to do this, use ``cache_build=True``.  If
+            you use ``cache_build=True``, you need to finalize the append
+            operations with :meth:`finalize_append`.
+
             Parameters
             ----------
-            element : ndarray
-                Element to append. The shape must match already inserted elements
-                shape except for the first dimension.
-            cache_build : {False, True}
-                Whether to save the build cache from this append routine.  If True,
-                append can assume it is the only player updating `self`, and the
-                caller must finalize `self` after all append operations, with
-                ``self.finalize_append()``.
-            Returns
+            element : ndarray Element to append. The shape must match already
+                inserted elements shape except for the first dimension.
+                cache_build : {False, True} Whether to save the build cache
+                from this append routine.  If True, append can assume it is the
+                only player updating `self`, and the caller must finalize
+                `self` after all append operations, with
+                ``self.finalize_append()``. Returns
             -------
-            None
-            Notes
+            None Notes
             -----
             If you need to add multiple elements you should consider
             `ArraySequence.extend`.
@@ -124,19 +125,20 @@ def extend(self, elements):
             """ Appends all `elements` to this array sequence.
             Parameters
             ----------
-            elements : iterable of ndarrays or :class:`ArraySequence` object
-                If iterable of ndarrays, each ndarray will be concatenated along
-                the first dimension then appended to the data of this
+            elements : iterable of ndarrays or :class:`ArraySequence` instance
+
+                If iterable of ndarrays, each ndarray will be concatenated
+                along the first dimension then appended to the data of this
                 ArraySequence.
-                If :class:`ArraySequence` object, its data are simply appended to
-                the data of this ArraySequence.
+                If :class:`ArraySequence` object, its data are simply appended
+                to the data of this ArraySequence.
+
             Returns
             -------
-            None
-            Notes
+            None Notes
             -----
-            The shape of the elements to be added must match the one of the data of
-            this :class:`ArraySequence` except for the first dimension.
+            The shape of the elements to be added must match the one of the
+            data of this :class:`ArraySequence` except for the first dimension.
             """
             # If possible try pre-allocating memory.
             try:
@@ -597,7 +599,8 @@ def _extract_vals(data, streamlines, affine=None, threedvec=False):
     """
     data = data.astype(np.float)
     if (isinstance(streamlines, list) or
-            isinstance(streamlines, types.GeneratorType)):
+       isinstance(streamlines, types.GeneratorType) or
+       isinstance(streamlines, Streamlines)):
         if affine is not None:
             streamlines = ut.move_streamlines(streamlines,
                                               np.linalg.inv(affine))

dipy/tracking/tests/test_streamline.py

@@ -1027,6 +1027,9 @@ def test_values_from_volume():
             vv = values_from_volume(data, np.array(sl1))
             npt.assert_almost_equal(vv, ans1, decimal=decimal)
 
+            vv = values_from_volume(data, Streamlines(sl1))
+            npt.assert_almost_equal(vv, ans1, decimal=decimal)
+
             affine = np.eye(4)
             affine[:, 3] = [-100, 10, 1, 1]
             x_sl1 = ut.move_streamlines(sl1, affine)

dipy/tracking/utils.py

@@ -134,7 +134,7 @@ def connectivity_matrix(streamlines, label_volume, voxel_size=None,
         This argument is deprecated.
     affine : array_like (4, 4)
         The mapping from voxel coordinates to streamline coordinates.
-    symmetric : bool, False by default
+    symmetric : bool, True by default
         Symmetric means we don't distinguish between start and end points. If
         symmetric is True, ``matrix[i, j] == matrix[j, i]``.
     return_mapping : bool, False by default

dipy/viz/actor.py

@@ -7,6 +7,7 @@
 from dipy.viz.utils import lines_to_vtk_polydata
 from dipy.viz.utils import set_input
 from dipy.viz.utils import numpy_to_vtk_points, numpy_to_vtk_colors
+import dipy.viz.utils as ut_vtk
 
 # Conditional import machinery for vtk
 from dipy.utils.optpkg import optional_package
@@ -1339,7 +1340,7 @@ def point(points, colors, opacity=1., point_radius=0.1, theta=8, phi=8):
     return actor
 
 
-def sphere(centers, colors, radii=1., theta=16, phi=16):
+def sphere(centers, colors, radii=1., theta=16, phi=16, vertices=None, faces=None):
     """ Visualize one or many spheres with different colors and radii
 
     Parameters
@@ -1350,6 +1351,8 @@ def sphere(centers, colors, radii=1., theta=16, phi=16):
     radii : float or ndarray, shape (N,)
     theta : int
     phi : int
+    vertices : vertices array
+    faces : faces array
 
     Returns
     -------
@@ -1378,16 +1381,22 @@ def sphere(centers, colors, radii=1., theta=16, phi=16):
     radii_fa = numpy_support.numpy_to_vtk(radii.astype('f8'), deep=0)
     radii_fa.SetName('rad')
 
-    src = vtk.vtkSphereSource()
-    src.SetRadius(0.5)
-    src.SetThetaResolution(theta)
-    src.SetPhiResolution(phi)
-
     polyData = vtk.vtkPolyData()
-    polyData.SetPoints(pts)
-    polyData.GetPointData().AddArray(radii_fa)
-    polyData.GetPointData().SetActiveScalars('rad')
-    polyData.GetPointData().AddArray(cols)
+    if faces is None:
+        src = vtk.vtkSphereSource()
+        src.SetRadius(0.5)
+        src.SetThetaResolution(theta)
+        src.SetPhiResolution(phi)
+
+        polyData.SetPoints(pts)
+        polyData.GetPointData().AddArray(radii_fa)
+        polyData.GetPointData().SetActiveScalars('rad')
+        polyData.GetPointData().AddArray(cols)
+
+    else:
+        for object_ in range(len(sphere_obj)):
+            ut_vtk.set_polydata_vertices(polyData, vertices)
+            ut_vtk.set_polydata_triangles(polyData, faces)
 
     glyph = vtk.vtkGlyph3D()
     glyph.SetSourceConnection(src.GetOutputPort())