replaced import * statements in images.py and test_persim_update.py with from persim import <module>

Author: Francis Motta

docs/notebooks/PersImage_update.ipynb

@@ -168,7 +168,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -178,7 +178,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [

docs/notebooks/Persistence Images.ipynb

@@ -12,8 +12,8 @@
 import scipy.spatial as spatial
 import matplotlib.pyplot as plt
 from matplotlib.collections import LineCollection
-from persim.images_weights import *
-from persim.images_kernels import *
+from persim import images_kernels
+from persim import images_weights
 
 from sklearn.base import TransformerMixin, BaseEstimator
 
@@ -309,9 +309,9 @@ def __init__(self, birth_range=None, pers_range=None, pixel_size=None,
         if pixel_size is None:
             pixel_size = np.min([pers_range[1] - pers_range[0], birth_range[1] - birth_range[0]]) * 0.2
         if weight is None:
-            weight = persistence
+            weight = images_weights.persistence
         if kernel is None:
-            kernel = gaussian
+            kernel = images_kernels.gaussian
         if weight_params is None:
             weight_params = {'n': 1.0}
         if kernel_params is None:
@@ -604,7 +604,7 @@ def _transform(pers_dgm, skew=True, resolution=None, weight=None, weight_params=
         wts = weight(pers_dgm[:, 0], pers_dgm[:, 1], **weight_params)
 
         # handle the special case of a standard, isotropic Gaussian kernel
-        if kernel == gaussian:
+        if kernel == images_kernels.gaussian:
             general_flag = False
             sigma = kernel_params['sigma']
 
@@ -615,8 +615,8 @@ def _transform(pers_dgm, skew=True, resolution=None, weight=None, weight_params=
             if (sigma[0][0] == sigma[1][1] and sigma[0][1] == 0.0):
                 sigma = np.sqrt(sigma[0][0])
                 for i in range(n):
-                    ncdf_b = norm_cdf((_bpnts - pers_dgm[i, 0]) / sigma)
-                    ncdf_p = norm_cdf((_ppnts - pers_dgm[i, 1]) / sigma)
+                    ncdf_b = images_kernels.norm_cdf((_bpnts - pers_dgm[i, 0]) / sigma)
+                    ncdf_p = images_kernels.norm_cdf((_ppnts - pers_dgm[i, 1]) / sigma)
                     curr_img = ncdf_p[None, :] * ncdf_b[:, None]
                     pers_img += wts[i]*(curr_img[1:, 1:] - curr_img[:-1, 1:] - curr_img[1:, :-1] + curr_img[:-1, :-1])
             else:

persim/images.py

@@ -2,8 +2,8 @@
 
 import numpy as np
 from persim import PersistenceImager
-from persim.images_weights import *
-from persim.images_kernels import *
+from persim import images_kernels
+from persim import images_weights
 
 # ----------------------------------------
 # New PersistenceImager Tests
@@ -155,18 +155,18 @@ def test_mixed_pairs():
 
 class TestWeightFunctions:
     def test_zero_on_birthaxis(self):
-        persimgr = PersistenceImager(weight=linear_ramp, weight_params={'low':0.0, 'high':1.0, 'start':0.0, 'end':1.0})
+        persimgr = PersistenceImager(weight=images_weights.linear_ramp, weight_params={'low':0.0, 'high':1.0, 'start':0.0, 'end':1.0})
         wf = persimgr.weight
         wf_params = persimgr.weight_params
         np.testing.assert_equal(wf(1, 0, **wf_params), 0)
 
-        persimgr = PersistenceImager(weight=persistence, weight_params={'n': 2})
+        persimgr = PersistenceImager(weight=images_weights.persistence, weight_params={'n': 2})
         wf = persimgr.weight
         wf_params = persimgr.weight_params
         np.testing.assert_equal(wf(1, 0, **wf_params), 0)
 
     def test_linear_ramp(self):
-        persimgr = PersistenceImager(weight=linear_ramp, weight_params={'low':0.0, 'high':5.0, 'start':0.0, 'end':1.0})
+        persimgr = PersistenceImager(weight=images_weights.linear_ramp, weight_params={'low':0.0, 'high':5.0, 'start':0.0, 'end':1.0})
 
         wf = persimgr.weight
         wf_params = persimgr.weight_params
@@ -198,7 +198,7 @@ def test_linear_ramp(self):
         np.testing.assert_equal(wf(1, 2, **wf_params), 2)
 
     def test_persistence(self):
-        persimgr = PersistenceImager(weight=persistence, weight_params={'n':1.0})
+        persimgr = PersistenceImager(weight=images_weights.persistence, weight_params={'n':1.0})
 
         wf = persimgr.weight
         wf_params = persimgr.weight_params
@@ -213,11 +213,11 @@ def test_persistence(self):
 
 class TestKernelFunctions:
     def test_gaussian(self):
-        kernel = gaussian
+        kernel = images_kernels.gaussian
         kernel_params = {'mu':[1, 1], 'sigma':np.array([[1,0],[0,1]])}
         np.testing.assert_almost_equal(kernel(np.array([1]), np.array([1]), **kernel_params), 1/4, 8)
 
-        kernel = bvn_cdf
+        kernel = images_kernels.bvn_cdf
         kernel_params = {'mu_x':1.0, 'mu_y':1.0, 'sigma_xx':1.0, 'sigma_yy':1.0, 'sigma_xy':0.0}
         np.testing.assert_almost_equal(kernel(np.array([1]), np.array([1]), **kernel_params), 1/4, 8)
 
@@ -231,19 +231,19 @@ def test_gaussian(self):
         np.testing.assert_equal(kernel(np.array([1]), np.array([1]), **kernel_params), .375)
 
     def test_norm_cdf(self):
-        np.testing.assert_equal(norm_cdf(0), .5)
-        np.testing.assert_almost_equal(norm_cdf(1), 0.8413447460685429, 8)
+        np.testing.assert_equal(images_kernels.norm_cdf(0), .5)
+        np.testing.assert_almost_equal(images_kernels.norm_cdf(1), 0.8413447460685429, 8)
 
     def test_uniform(self):
-        kernel = uniform
+        kernel = images_kernels.uniform
         kernel_params={'width': 3, 'height': 1}
 
         np.testing.assert_equal(kernel(np.array([-1]), np.array([-1]), mu=(0,0), **kernel_params), 0)
         np.testing.assert_equal(kernel(np.array([3]), np.array([1]), mu=(0,0), **kernel_params), 1)
         np.testing.assert_equal(kernel(np.array([5]), np.array([5]), mu=(0,0), **kernel_params), 1)
 
     def test_sigma(self):
-        kernel = gaussian
+        kernel = images_kernels.gaussian
         kernel_params1 = {'sigma':np.array([[1,0],[0,1]])}
         kernel_params2 = {'sigma': [[1,0],[0,1]]}
         np.testing.assert_equal(kernel(np.array([1]), np.array([1]), **kernel_params1), kernel(np.array([1]), np.array([1]), **kernel_params2))