Changes in src/sas/sasgui/plottools/PlotPanel.py [9a5097c:463e7ffc] in sasview

File:

• src/sas/sasgui/plottools/PlotPanel.py (modified) (9 diffs)

src/sas/sasgui/plottools/PlotPanel.py

@@ -29 +29 @@
 DEFAULT_CMAP = pylab.cm.jet
 import copy
-import numpy as np
+import numpy
 
 from sas.sasgui.guiframe.events import StatusEvent
 from .toolbar import NavigationToolBar, PlotPrintout, bind
+
+logger = logging.getLogger(__name__)
 
 def show_tree(obj, d=0):
@@ -1452 +1454 @@
                 if  self.zmin_2D <= 0  and len(output[output > 0]) > 0:
                     zmin_temp = self.zmin_2D
-                    output[output > 0] = np.log10(output[output > 0])
+                    output[output > 0] = numpy.log10(output[output > 0])
                     #In log scale Negative values are not correct in general
-                    #output[output<=0] = math.log(np.min(output[output>0]))
+                    #output[output<=0] = math.log(numpy.min(output[output>0]))
                 elif self.zmin_2D <= 0:
                     zmin_temp = self.zmin_2D
-                    output[output > 0] = np.zeros(len(output))
+                    output[output > 0] = numpy.zeros(len(output))
                     output[output <= 0] = -32
                 else:
                     zmin_temp = self.zmin_2D
-                    output[output > 0] = np.log10(output[output > 0])
+                    output[output > 0] = numpy.log10(output[output > 0])
                     #In log scale Negative values are not correct in general
-                    #output[output<=0] = math.log(np.min(output[output>0]))
+                    #output[output<=0] = math.log(numpy.min(output[output>0]))
             except:
                 #Too many problems in 2D plot with scale
@@ -1492 +1494 @@
             X = self.x_bins[0:-1]
             Y = self.y_bins[0:-1]
-            X, Y = np.meshgrid(X, Y)
+            X, Y = numpy.meshgrid(X, Y)
 
             try:
@@ -1506 +1508 @@
                     from mpl_toolkits.mplot3d import Axes3D
                 except:
-                    logging.error("PlotPanel could not import Axes3D")
+                    logger.error("PlotPanel could not import Axes3D")
                 self.subplot.figure.clear()
                 ax = Axes3D(self.subplot.figure)
@@ -1555 +1557 @@
         # 1d array to use for weighting the data point averaging
         #when they fall into a same bin.
-        weights_data = np.ones([self.data.size])
+        weights_data = numpy.ones([self.data.size])
         # get histogram of ones w/len(data); this will provide
         #the weights of data on each bins
-        weights, xedges, yedges = np.histogram2d(x=self.qy_data,
+        weights, xedges, yedges = numpy.histogram2d(x=self.qy_data,
                                                     y=self.qx_data,
                                                     bins=[self.y_bins, self.x_bins],
                                                     weights=weights_data)
         # get histogram of data, all points into a bin in a way of summing
-        image, xedges, yedges = np.histogram2d(x=self.qy_data,
+        image, xedges, yedges = numpy.histogram2d(x=self.qy_data,
                                                   y=self.qx_data,
                                                   bins=[self.y_bins, self.x_bins],
@@ -1581 +1583 @@
         # do while loop until all vacant bins are filled up up
         #to loop = max_loop
-        while not(np.isfinite(image[weights == 0])).all():
+        while not(numpy.isfinite(image[weights == 0])).all():
             if loop >= max_loop:  # this protects never-ending loop
                 break
@@ -1630 +1632 @@
 
         # store x and y bin centers in q space
-        x_bins = np.linspace(xmin, xmax, npix_x)
-        y_bins = np.linspace(ymin, ymax, npix_y)
+        x_bins = numpy.linspace(xmin, xmax, npix_x)
+        y_bins = numpy.linspace(ymin, ymax, npix_y)
 
         #set x_bins and y_bins
@@ -1650 +1652 @@
         """
         # No image matrix given
-        if image == None or np.ndim(image) != 2 \
-                or np.isfinite(image).all() \
+        if image == None or numpy.ndim(image) != 2 \
+                or numpy.isfinite(image).all() \
                 or weights == None:
             return image
@@ -1657 +1659 @@
         len_y = len(image)
         len_x = len(image[1])
-        temp_image = np.zeros([len_y, len_x])
-        weit = np.zeros([len_y, len_x])
+        temp_image = numpy.zeros([len_y, len_x])
+        weit = numpy.zeros([len_y, len_x])
         # do for-loop for all pixels
         for n_y in range(len(image)):
             for n_x in range(len(image[1])):
                 # find only null pixels
-                if weights[n_y][n_x] > 0 or np.isfinite(image[n_y][n_x]):
+                if weights[n_y][n_x] > 0 or numpy.isfinite(image[n_y][n_x]):
                     continue
                 else:
                     # find 4 nearest neighbors
                     # check where or not it is at the corner
-                    if n_y != 0 and np.isfinite(image[n_y - 1][n_x]):
+                    if n_y != 0 and numpy.isfinite(image[n_y - 1][n_x]):
                         temp_image[n_y][n_x] += image[n_y - 1][n_x]
                         weit[n_y][n_x] += 1
-                    if n_x != 0 and np.isfinite(image[n_y][n_x - 1]):
+                    if n_x != 0 and numpy.isfinite(image[n_y][n_x - 1]):
                         temp_image[n_y][n_x] += image[n_y][n_x - 1]
                         weit[n_y][n_x] += 1
-                    if n_y != len_y - 1 and np.isfinite(image[n_y + 1][n_x]):
+                    if n_y != len_y - 1 and numpy.isfinite(image[n_y + 1][n_x]):
                         temp_image[n_y][n_x] += image[n_y + 1][n_x]
                         weit[n_y][n_x] += 1
-                    if n_x != len_x - 1 and np.isfinite(image[n_y][n_x + 1]):
+                    if n_x != len_x - 1 and numpy.isfinite(image[n_y][n_x + 1]):
                         temp_image[n_y][n_x] += image[n_y][n_x + 1]
                         weit[n_y][n_x] += 1
                     # go 4 next nearest neighbors when no non-zero
                     # neighbor exists
-                    if n_y != 0 and n_x != 0 and \
-                            np.isfinite(image[n_y - 1][n_x - 1]):
+                    if n_y != 0 and n_x != 0 and\
+                         numpy.isfinite(image[n_y - 1][n_x - 1]):
                         temp_image[n_y][n_x] += image[n_y - 1][n_x - 1]
                         weit[n_y][n_x] += 1
                     if n_y != len_y - 1 and n_x != 0 and \
-                            np.isfinite(image[n_y + 1][n_x - 1]):
+                        numpy.isfinite(image[n_y + 1][n_x - 1]):
                         temp_image[n_y][n_x] += image[n_y + 1][n_x - 1]
                         weit[n_y][n_x] += 1
                     if n_y != len_y and n_x != len_x - 1 and \
-                            np.isfinite(image[n_y - 1][n_x + 1]):
+                        numpy.isfinite(image[n_y - 1][n_x + 1]):
                         temp_image[n_y][n_x] += image[n_y - 1][n_x + 1]
                         weit[n_y][n_x] += 1
                     if n_y != len_y - 1 and n_x != len_x - 1 and \
-                            np.isfinite(image[n_y + 1][n_x + 1]):
+                        numpy.isfinite(image[n_y + 1][n_x + 1]):
                         temp_image[n_y][n_x] += image[n_y + 1][n_x + 1]
                         weit[n_y][n_x] += 1