NSFopen 2.2.2__tar.gz → 2.2.4__tar.gz

{nsfopen-2.2.2 → nsfopen-2.2.4}/NSFopen/__init__.py

@@ -4,22 +4,26 @@ License - MIT"""
 
 import os
 import pathlib
-from . _version import __version__
+from ._version import __version__
+
+from .read import read
+
+# from . process import process
 
-from . read import read
-from . process import process
 
 def package_path() -> pathlib.Path:
     return pathlib.Path(os.path.dirname(os.path.abspath(__file__)))
 
+
 def example_path() -> pathlib.Path:
     return package_path() / "example"
 
-def help(): 
+
+def help():
     print("Nanosurf NID and NHF file reader:")
     print("-------------------------------")
     print(f"Installed version: {__version__}")
     print("\nExamples are stored here:")
     print(example_path())
     for example in os.listdir(example_path()):
-        print(f"  {example}")
+        print(f"  {example}")

nsfopen-2.2.4/NSFopen/_version.py

@@ -0,0 +1 @@
+__version__ = "2.2.4"

{nsfopen-2.2.2 → nsfopen-2.2.4}/NSFopen/example/Force_Spectroscopy/Force_Spectroscopy.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # coding: utf-8
 
-# ## This script demonstrates how to open a Nanosurf Force Spectroscopy map and analyze the data using the DMT contact mechanics model 
+# ## This script demonstrates how to open a Nanosurf Force Spectroscopy map and analyze the data using the DMT contact mechanics model
 
 # In[1]:
 
@@ -16,23 +16,27 @@ from scipy.optimize import curve_fit
 
 from glob import glob
 
-filename = 'spectroscopy.nid'
-filename_large = 'spectroscopy_large.nid'
+filename = "spectroscopy.nid"
+filename_large = "spectroscopy_large.nid"
 
 
 # In[2]:
 
 
-# If USE_LARGE_MAP is True, then it will use the larger force-curve map, downloading if not already locally available 
+# If USE_LARGE_MAP is True, then it will use the larger force-curve map, downloading if not already locally available
 USE_LARGE_MAP = False
 
 
 # In[3]:
 
 
-if USE_LARGE_MAP and filename_large not in glob('*nid'):
+if USE_LARGE_MAP and filename_large not in glob("*nid"):
     import urllib.request
-    urllib.request.urlretrieve("https://www.dropbox.com/s/knzuh588g0uvjfi/spectroscopy_large.nid?dl=1", filename_large)
+
+    urllib.request.urlretrieve(
+        "https://www.dropbox.com/s/knzuh588g0uvjfi/spectroscopy_large.nid?dl=1",
+        filename_large,
+    )
     filename = filename_large
 elif USE_LARGE_MAP:
     filename = filename_large
@@ -47,20 +51,28 @@ data = afm.data
 param = afm.param
 
 # probe
-k = param.Tip.Prop0['Value']  # spring constant
-sens = param.Tip.Sensitivity['Value']  # deflection sensitivity (if needed)
+k = param.Tip.Prop0["Value"]  # spring constant
+sens = param.Tip.Sensitivity["Value"]  # deflection sensitivity (if needed)
 
 radius = 10e-9  # tip radius
 nu = 0.35  # Poisson ratio (between 0.35 and 0.5)
 
-spec_backward = data['Spec']['Backward']  # for DMT model we will use backward modulation
-d = spec_backward['Deflection']  # force channel
+direction = "Backward"  # Forward or Backward modulation
+
+spec_backward = data["Spec"][
+    direction
+]  # for DMT model we will use backward modulation
+d = spec_backward["Deflection"]  # force channel
 
 z_signal = list(spec_backward.index)
-z_chans = ['Z-Axis Sensor', 'Z-AxisSensor', 'Z-Axis']  # depending on system, Z-Axis channel may be labeled differently
+z_chans = [
+    "Z-Axis Sensor",
+    "Z-AxisSensor",
+    "Z-Axis",
+]  # depending on system, Z-Axis channel may be labeled differently
 available_chan = [i for i in z_signal if i in z_chans][0]
 
-z = data['Spec']['Backward'][available_chan]  # Z-axis data
+z = data["Spec"][direction][available_chan]  # Z-axis data
 
 sz = int(param.Spec.maps[4])  # Map size
 
@@ -72,6 +84,7 @@ extent = param.Spec.maps[:4]  # X and Y physical dimensions of map
 
 ## Functions
 
+
 # corrects for any baseline tilt
 def baseline_correct(x, y, degree=1, start=0, end=0.5):
     i0 = int(np.floor(len(x) * start))
@@ -90,14 +103,15 @@ def baseline_correct(x, y, degree=1, start=0, end=0.5):
 def DMT(x, *param):
     elast, depth, wadh = param
 
-    scale = 4./3. * elast * np.sqrt(radius) / (1 - nu**2)
+    scale = 4.0 / 3.0 * elast * np.sqrt(radius) / (1 - nu**2)
     x = x - depth
-    y = scale * np.sign(x) * np.abs(x)**(3./2.) - wadh
+    y = scale * np.sign(x) * np.abs(x) ** (3.0 / 2.0) - wadh
     return y
 
 
 def DMTfit(*args, maxForce=np.Inf):
     import time
+
     t = time.time()
     # args are: [separation, load (force)]
     if not isinstance(args[0], list):
@@ -108,7 +122,7 @@ def DMTfit(*args, maxForce=np.Inf):
         # x = x - y / spring_constant  # separation
         lenY = int(np.floor(len(y) * 0.8))
         a = min(y[lenY:])  # adhesion
-    
+
         i0 = np.where(y == a)[0][0]  # contact point estimator index
         i1 = np.where(y > maxForce)[0]  # max force index
 
@@ -118,13 +132,15 @@ def DMTfit(*args, maxForce=np.Inf):
             i1 = i1[0]
 
         try:
-            coeff, var_matrix = curve_fit(DMT, x[i0:i1], y[i0:i1], p0=[1e9, x[i0], -a])
+            coeff, var_matrix = curve_fit(
+                DMT, x[i0:i1], y[i0:i1], p0=[1e9, x[i0], -a]
+            )
         except RuntimeError:
             E.append(np.nan)
         else:
             E.append(max(coeff[0], 0))
 
-    print('Elapsed Time: %3.2f sec\n' % (time.time() - t))
+    print("Elapsed Time: %3.2f sec\n" % (time.time() - t))
     return np.array(E), (coeff, i0, i1)
 
 
@@ -135,7 +151,7 @@ def DMTfit(*args, maxForce=np.Inf):
 dd = [baseline_correct(z_, d_, start=0.5, end=0.8) for z_, d_ in zip(z, d)]
 
 # separation
-zz = [zz - dd/k for dd, zz in zip(dd, z)]
+zz = [zz - dd / k for dd, zz in zip(dd, z)]
 
 # elastic modulus
 Eb, _ = DMTfit(zz, dd)
@@ -159,14 +175,16 @@ Adh = toMap(adh, sz)
 # In[7]:
 
 
-fig, ax = plt.subplots(2, 2, figsize=(10, 8), gridspec_kw={'height_ratios': [2, 1]}, dpi=300)
+fig, ax = plt.subplots(
+    2, 2, figsize=(10, 8), gridspec_kw={"height_ratios": [2, 1]}, dpi=300
+)
 fig.tight_layout(w_pad=8.0, h_pad=1.0)
 
 im = ax.copy()
 
 cmap = "afmhot"  # colormap
-xlbl = 'X [$\mu$m]'
-ylbl = 'Y [$\mu$m]'
+xlbl = "X [$\mu$m]"
+ylbl = "Y [$\mu$m]"
 zlbl = ["Young's Modulus [GPa]", "Adhesion [nN]"]
 
 im[0, 0] = ax[0, 0].imshow(Ebim)
@@ -182,8 +200,7 @@ for i in range(2):
     cb.set_label(zlbl[i])
 
     ax[0, i].set(xlabel=xlbl, ylabel=ylbl)
-    ax[1, i].set(xlabel=zlbl[i], ylabel='Counts')
+    ax[1, i].set(xlabel=zlbl[i], ylabel="Counts")
 
 
 plt.show()
-

{nsfopen-2.2.2 → nsfopen-2.2.4}/NSFopen/process/__init__.py

@@ -5,4 +5,5 @@ Created on Sat Oct 12 12:43:59 2019
 @author: Edward
 """
 
-from . process import process
+from . process import process
+from . colormaps import colors

nsfopen-2.2.4/NSFopen/process/colormaps.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May 23 13:04:53 2024
+
+@author: nelson
+"""
+
+import numpy as np
+import pandas as pd
+import os
+
+from matplotlib.colors import LinearSegmentedColormap
+
+
+class colors:
+    def __init__(self, name=None, gwy_dir=None, **kwargs):
+        self.name = name
+        self.gwy_dir = gwy_dir
+        if not gwy_dir:
+            self.gwy_dir = (
+                "C:\\Program Files\\Gwyddion\\share\\gwyddion\\gradients\\"
+            )
+        custom = ["BlueBlackRed"]
+        gwy_list = os.listdir(self.gwy_dir)
+
+        cmaps = {}
+        cmaps["Custom"] = custom
+        cmaps["Gwyddion"] = gwy_list
+
+        if name in gwy_list:
+            cmap = self.gwy_cmap()
+        elif name in custom:
+            cmap = self.custom()
+        else:
+            print("Name Not Found\n")
+            print("Use one of the following choices:\n")
+            print({x for v in cmaps.values() for x in v})
+            cmap = []
+        self.cmap = cmap
+        self.cmap_list = cmaps
+
+    def gwy_cmap(self):
+        cmap = pd.read_csv(
+            self.gwy_dir + self.name,
+            sep=" ",
+            header=None,
+            skiprows=1,
+            index_col=0,
+        )
+        nodes = cmap.index.values
+        colors = cmap.values
+
+        return LinearSegmentedColormap.from_list(
+            self.name, list(zip(nodes, colors))
+        )
+
+    def custom(self):
+        if self.name == "BlueBlackRed":
+            # Blue-Black-Red
+            start = np.array(
+                [0.6196078431372549, 0.792156862745098, 0.8823529411764706]
+            )
+            mid = np.array([0, 0, 0])
+            end = np.array(
+                [0.9882352941176471, 0.5725490196078431, 0.4470588235294118]
+            )
+            nodes = [0, 0.5, 1]
+
+        return LinearSegmentedColormap.from_list(
+            self.name, list(zip(nodes, [start, mid, end]))
+        )

{nsfopen-2.2.2 → nsfopen-2.2.4}/NSFopen/process/process.py

@@ -11,7 +11,7 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
 from matplotlib.ticker import LinearLocator, FormatStrFormatter
 from matplotlib import cm
-from scipy.ndimage import gaussian_filter,median_filter
+from scipy.ndimage import gaussian_filter, median_filter
 from sklearn.impute import KNNImputer
 from scipy import stats
 
@@ -20,24 +20,26 @@ import scipy.stats as ss
 import os, sys
 
 
-class process():
+class process:
     def __init__(self, filename):
-    
+
         afm = read(filename)
         self.data = afm.data
         self.param = afm.param
 
-    def flatten(self,
-                order=1,
-                direction='Forward',
-                channel='Z-Axis',
-                mask=[],
-                inplace=True):
-        """ Flattens an image using a nth-order polynomial
-        
+    def flatten(
+        self,
+        order=1,
+        direction="Forward",
+        channel="Z-Axis",
+        mask=[],
+        inplace=True,
+    ):
+        """Flattens an image using a nth-order polynomial
+
         Parameters
         ----------
-        
+
             order : int, default 1
                 Order of the polynomial
             direction : {'Forward','Backward'}, defulat 'Forward'
@@ -47,14 +49,14 @@ class process():
             mask : boolean array
                 Mask where True values are ignored in the input array
             inplace : boolean, default True
-        
+
         Return
         ------
             array or None
                 Flattened image or None if inplace=True
-        
+
         """
-        data_out = self.data['Image'][direction][channel]
+        data_out = self.data["Image"][direction][channel]
         data_in = data_out.copy()
         data_in = np.array(data_in, dtype=float)
         x = np.arange(data_in.shape[1])
@@ -67,83 +69,83 @@ class process():
             y = np.polyval(p, x)
             data_out[idx] = out - y
         if inplace:
-            self.data['Image'].loc[direction,channel] = data_out
+            self.data["Image"].loc[direction, channel] = data_out
             return None
         else:
             return data_out
-    
-    def plane_level(self,
-                    direction='Forward',
-                    channel='Z-Axis',
-                    inplace=True):
-        data_out = self.data['Image'][direction][channel]
+
+    def plane_level(self, direction="Forward", channel="Z-Axis", inplace=True):
+        data_out = self.data["Image"][direction][channel]
         data_in = data_out.copy()
         data_in = np.array(data_in, dtype=float)
-        
+
         # x_size = self.param.X.range[0] * 1e6
         # y_size = self.param.Y.range[0] * 1e6
 
         # xs = np.linspace(0,x_size,data_in.shape[0])
         # ys = np.linspace(0,y_size,data_in.shape[1])
-        
-        xs = np.arange(0,data_in.shape[0])
-        ys = np.arange(0,data_in.shape[1])
-        xs,ys = np.meshgrid(xs,ys)
+
+        xs = np.arange(0, data_in.shape[0])
+        ys = np.arange(0, data_in.shape[1])
+        xs, ys = np.meshgrid(xs, ys)
         ones = np.ones(xs.shape)
 
-        reshape = (lambda x: np.reshape(x,(len(x)**2,1)))
+        reshape = lambda x: np.reshape(x, (len(x) ** 2, 1))
 
-        A = np.matrix(np.hstack([reshape(xs),reshape(ys),reshape(ones)]))
+        A = np.matrix(np.hstack([reshape(xs), reshape(ys), reshape(ones)]))
         b = np.matrix(reshape(data_in))
 
         fit = (A.T * A).I * A.T * b
-        plane = np.reshape(A*fit,data_in.shape)
-        data_out-=plane
+        plane = np.reshape(A * fit, data_in.shape)
+        data_out -= plane
         if inplace:
-            self.data['Image'].loc[direction,channel] = data_out
+            self.data["Image"].loc[direction, channel] = data_out
             return None
         else:
             return data_out
-    
-    def remove_outliers(self,
-                        direction='Forward',
-                        channel='Z-Axis',
-                        q=0.01,
-                        neighbors=5,
-                        inplace=True):
-        data_out = self.data['Image'][direction][channel]
+
+    def remove_outliers(
+        self,
+        direction="Forward",
+        channel="Z-Axis",
+        q=0.01,
+        neighbors=5,
+        inplace=True,
+    ):
+        data_out = self.data["Image"][direction][channel]
         data_in = data_out.copy()
         data_in = np.array(data_in, dtype=float)
-        
-        if isinstance(q,list):
-            q0,q1=q
+
+        if isinstance(q, list):
+            q0, q1 = q
         else:
-            q0=q1=q
-        
-        value = np.quantile(data_in,q=[q0,1-q1])
-        mask = (data_in<value[0]) | (data_in>value[1])
-        data_in[mask]=np.nan
+            q0 = q1 = q
+
+        value = np.quantile(data_in, q=[q0, 1 - q1])
+        mask = (data_in < value[0]) | (data_in > value[1])
+        data_in[mask] = np.nan
 
-        data_out=KNNImputer(n_neighbors=neighbors).fit_transform(data_in)
+        data_out = KNNImputer(n_neighbors=neighbors).fit_transform(data_in)
         if inplace:
-            self.data['Image'].loc[direction,channel] = data_out
+            self.data["Image"].loc[direction, channel] = data_out
             return None
         else:
             return data_out
-        
-        
-    def denoise(self,
-             direction='Forward',
-             channel='Z-Axis',
-             function='gaussian',
-             size=5,
-             inplace=True,
-             **kwargs):
-        """ Applies a 2D filter to an image.
-        
+
+    def denoise(
+        self,
+        direction="Forward",
+        channel="Z-Axis",
+        function="gaussian",
+        size=5,
+        inplace=True,
+        **kwargs,
+    ):
+        """Applies a 2D filter to an image.
+
         Parameters
         ----------
-        
+
             direction: {'Forward','Backward'}, default 'Forward'
                 Scan direction to use
             channel: string, default 'Z-Axis'
@@ -156,41 +158,42 @@ class process():
                 Whether to modify the input array or create new one
             **kwargs:
                 Passed to filters
-        
+
         Return
         ------
             array or None
                 Filtered image or None if inplace=True
-        
+
         """
-        data_in = self.data['Image'][direction][channel]
-        if function == 'median':
+        data_in = self.data["Image"][direction][channel]
+        if function == "median":
             data_out = median_filter(data_in, size=size, **kwargs)
         else:
             data_out = gaussian_filter(data_in, sigma=size, **kwargs)
         if inplace:
-            self.data['Image'].loc[direction,channel] = data_out
+            self.data["Image"].loc[direction, channel] = data_out
             return None
         else:
             return data_out
-        
-
-    def image(self,
-              direction='Forward',
-              channel='Z-Axis',
-              scale=1e9,
-              cmap=cm.afmhot,
-              cbar=None,
-              fontsize=10,
-              scalebar=None,
-              theme='light',
-              title='XXX',
-              **kwargs):
-        """ Plots an AFM image
-        
+
+    def image(
+        self,
+        direction="Forward",
+        channel="Z-Axis",
+        scale=1e9,
+        cmap=cm.afmhot,
+        cbar=None,
+        fontsize=10,
+        scalebar=None,
+        theme="light",
+        title="XXX",
+        **kwargs,
+    ):
+        """Plots an AFM image
+
         Parameters
         ----------
-        
+
             direction: {'Forward','Backward'}, default 'Forward'
                 Scan direction to use
             channel: string, default 'Z-Axis'
@@ -211,126 +214,142 @@ class process():
                 Use either 'light' or 'dark' theme
             **kwargs:
                 Passed to matplotlib imshow
-        
+
         Return
         ------
             figure
                 matplotlib figure object
-                
+
         """
-        d = np.array(self.data['Image'][direction][channel]*scale,dtype=float)
-        if hasattr(self.param, 'X'):
+        d = np.array(
+            self.data["Image"][direction][channel] * scale, dtype=float
+        )
+        if hasattr(self.param, "X"):
             x = self.param.X.range[0] * 1e6
             y = self.param.Y.range[0] * 1e6
-        else:
+        elif hasattr(self.param, "image_size_x"):
             x = self.param.image_size_x * 1e6
             y = self.param.image_size_y * 1e6
-            
+        else:
+            x, y = self.param.rect_axis_range
+            x *= 1e6
+            y *= 1e6
+
         fig = plt.figure(dpi=300)
 
-        if theme=='light':
-            color = 'k'
+        if theme == "light":
+            color = "k"
         else:
-            color= 'w'
-            fig.patch.set_facecolor('k')
+            color = "w"
+            fig.patch.set_facecolor("k")
 
-        im = plt.imshow(d, extent=(0, x, 0, y), cmap=cmap, origin='lower', **kwargs)
+        im = plt.imshow(
+            d, extent=(0, x, 0, y), cmap=cmap, origin="lower", **kwargs
+        )
 
         for spine in im.axes.spines.values():
-            spine.set_edgecolor(color)   
+            spine.set_edgecolor(color)
 
         if scalebar:
-            if isinstance(scalebar,dict):
-                dx = scalebar['length']
-                c = scalebar['color']
+            if isinstance(scalebar, dict):
+                dx = scalebar["length"]
+                c = scalebar["color"]
             else:
                 dx = np.round(x / 5)
-                c = 'k'
+                c = "k"
 
             pad = y * 0.05
             plt.plot([x - dx - pad, x - pad], [pad, pad], linewidth=5, color=c)
-            txt = plt.text(x - pad - dx / 2, pad + x * 0.03, f'%i $\mu$m' % dx,
-                     horizontalalignment='center',
-                     fontsize=fontsize,
-                     color=c)
-            if dx<1:
-                txt.set_text(f'%i nm' % (dx*1e3))
+            txt = plt.text(
+                x - pad - dx / 2,
+                pad + x * 0.03,
+                f"%i $\mu$m" % dx,
+                horizontalalignment="center",
+                fontsize=fontsize,
+                color=c,
+            )
+            if dx < 1:
+                txt.set_text(f"%i nm" % (dx * 1e3))
             plt.xticks([])
             plt.yticks([])
         else:
-            plt.xlabel('X $[\mu{}$m]', fontsize=fontsize, color=color)
-            plt.ylabel('Y $[\mu{}$m]', fontsize=fontsize, color=color)
+            plt.xlabel("X $[\mu{}$m]", fontsize=fontsize, color=color)
+            plt.ylabel("Y $[\mu{}$m]", fontsize=fontsize, color=color)
             plt.xticks(fontsize=fontsize, color=color)
             plt.yticks(fontsize=fontsize, color=color)
             im.axes.tick_params(color=color, labelcolor=color)
-        if title=='XXX':
-            title = f'{channel} - {direction}'
-        plt.title(title,fontsize=fontsize, color=color)
+        if title == "XXX":
+            title = f"{channel} - {direction}"
+        plt.title(title, fontsize=fontsize, color=color)
         if cbar:
             cb = plt.colorbar(pad=0.02)
-            cb.set_label(label=cbar,size=fontsize, color=color)
+            cb.set_label(label=cbar, size=fontsize, color=color)
             cb.ax.tick_params(labelsize=fontsize, color=color)
             cb.ax.yaxis.set_tick_params(color=color)
             cb.outline.set_edgecolor(color)
-            plt.setp(plt.getp(cb.ax.axes, 'yticklabels'), color=color)
-        
+            plt.setp(plt.getp(cb.ax.axes, "yticklabels"), color=color)
+
         return fig
-    
-    def hist(self,
-             direction='Forward',
-             channel='Z-Axis',
-             bins='sqrt',
-             scale=1e9,
-             cmap=cm.afmhot,
-             xlabel='Z-Axis [nm]',
-             fontsize=10,
-             density=False,
-             theme='light',
-             **kwargs):
-        
-        data = np.array(self.data['Image'][direction][channel]*scale,dtype=float).reshape(-1)
-        if isinstance(bins,str):
-            bins = n_bins(data,method=bins)
-        
+
+    def hist(
+        self,
+        direction="Forward",
+        channel="Z-Axis",
+        bins="sqrt",
+        scale=1e9,
+        cmap=cm.afmhot,
+        xlabel="Z-Axis [nm]",
+        fontsize=10,
+        density=False,
+        theme="light",
+        **kwargs,
+    ):
+
+        data = np.array(
+            self.data["Image"][direction][channel] * scale, dtype=float
+        ).reshape(-1)
+        if isinstance(bins, str):
+            bins = n_bins(data, method=bins)
+
         fig = plt.figure(dpi=300)
-        
-        if theme=='light':
-            color = 'k'
-            c_bg = 'w'
+
+        if theme == "light":
+            color = "k"
+            c_bg = "w"
         else:
-            color= 'w'
-            c_bg = 'k'
+            color = "w"
+            c_bg = "k"
             fig.patch.set_facecolor(c_bg)
-            
-            
-        n, edge, patches = plt.hist(data, bins=bins, density=density, color='green', **kwargs)
+
+        n, edge, patches = plt.hist(
+            data, bins=bins, density=density, color="green", **kwargs
+        )
         bin_centers = 0.5 * (edge[:-1] + edge[1:])
-        
+
         col = bin_centers - min(bin_centers)
         col /= max(col)
-        
+
         for c, p in zip(col, patches):
-            plt.setp(p, 'facecolor', cmap(c))
-                
+            plt.setp(p, "facecolor", cmap(c))
+
         im = plt.gca()
         for spine in im.axes.spines.values():
-            spine.set_edgecolor(color)       
-            
-        plt.xlabel(xlabel,fontsize=fontsize, color=color)
+            spine.set_edgecolor(color)
+
+        plt.xlabel(xlabel, fontsize=fontsize, color=color)
         if density:
-            ylabel='$\\rho$'
+            ylabel = "$\\rho$"
         else:
-            ylabel='Counts'
-        plt.ylabel(ylabel,fontsize=fontsize, color=color)
+            ylabel = "Counts"
+        plt.ylabel(ylabel, fontsize=fontsize, color=color)
         plt.xticks(fontsize=fontsize, color=color)
         plt.yticks(fontsize=fontsize, color=color)
         im.axes.tick_params(color=color, labelcolor=color)
-        
+
         im.get_children()[-1].set_facecolor(c_bg)
-        
+
         return fig
-        
-    
+
     # def surf(self,
     #          direction='Forward',
     #          channel='Z-Axis',
@@ -374,11 +393,11 @@ class process():
     def stats(self):
         # definition of central moment
         def Mu(x, i):
-            return np.mean((x-x.mean())**i)
+            return np.mean((x - x.mean()) ** i)
 
         # mean deviation
         def Sa_(x):
-            return np.mean(np.abs(x-x.mean()))
+            return np.mean(np.abs(x - x.mean()))
 
         # RMS deviation
         def Sq_(x):
@@ -386,74 +405,88 @@ class process():
 
         # Skew
         def skew_(x):
-            return Mu(x, 3)/Mu(x, 2)**(3./2.)
+            return Mu(x, 3) / Mu(x, 2) ** (3.0 / 2.0)
 
         # Kurtosis
         def kurt_(x):
-            return Mu(x, 4)/Mu(x, 2)**2 - 3
-
+            return Mu(x, 4) / Mu(x, 2) ** 2 - 3
 
         # stat=[]
         func = [Sa_, Sq_, skew_, kurt_, np.min, np.max]
-        fname = ['Sa', 'Sq', 'Ssk', 'Sku', 'Min', 'Max']
+        fname = ["Sa", "Sq", "Ssk", "Sku", "Min", "Max"]
         stats = {}
         # cnames = []
-        for d0, _ in self.data['Image'].groupby(level=0):
+        for d0, _ in self.data["Image"].groupby(level=0):
             s = {}
-            for d1, df in self.data['Image'].groupby(level=1):
+            for d1, df in self.data["Image"].groupby(level=1):
                 # cnames.append([d0, d1])
                 s[d1] = {s: f(df[d0][d1]) for s, f in zip(fname, func)}
             stats[d0] = s
 
         return toPandaDF(stats).unstack(level=0)
-  
+
 
 def toPandaDF(user_dict):
-    df = pd.DataFrame.from_dict({(i, j): user_dict[i][j]
-                                 for i in user_dict.keys()
-                                 for j in user_dict[i].keys()}, orient='index').transpose()
+    df = pd.DataFrame.from_dict(
+        {
+            (i, j): user_dict[i][j]
+            for i in user_dict.keys()
+            for j in user_dict[i].keys()
+        },
+        orient="index",
+    ).transpose()
     return df
 
 
-def n_bins(x,method='sqrt'):
+def n_bins(x, method="sqrt"):
     n = len(x)
-    if method=='freedman':     # freedman-diaconis rule
-        h = 2*stats.iqr(x)/np.cbrt(n)
-        k = int(np.ceil((max(x)-min(x))/h))
-    elif method=='rice':
+    if method == "freedman":  # freedman-diaconis rule
+        h = 2 * stats.iqr(x) / np.cbrt(n)
+        k = int(np.ceil((max(x) - min(x)) / h))
+    elif method == "rice":
         k = int(np.ceil(2 * np.cbrt(n)))
-    elif method=='sturges':
-        k = int(np.ceil(np.log2(n))+1)
-    elif method=='doane':
+    elif method == "sturges":
+        k = int(np.ceil(np.log2(n)) + 1)
+    elif method == "doane":
         g = stats.skew(x)
-        sigma = np.sqrt(6*(n-2)/((n+1)*(n+3)))
-        k = int(1 + np.log2(n)+np.log2(1+np.abs(g)/sigma))
-    elif method=='quantile':
-        k = np.quantile(x,np.arange(0,1.01,0.025))
+        sigma = np.sqrt(6 * (n - 2) / ((n + 1) * (n + 3)))
+        k = int(1 + np.log2(n) + np.log2(1 + np.abs(g) / sigma))
+    elif method == "quantile":
+        k = np.quantile(x, np.arange(0, 1.01, 0.025))
     else:
         k = int(np.ceil(np.sqrt(n)))
     return k
 
 
 if __name__ == "__main__":
-    file='..\\example\\Calculate_Roughness\\sapphire.nid'
-    
+    file = "..\\example\\Calculate_Roughness\\sapphire.nid"
+    from colormaps import colors
+
+    cmap = colors("Sky").cmap
+
     # fig = plt.figure(dpi=300)
     afm = process(file)
 
-    chan = 'Z-Axis'
-    
+    chan = "Z-Axis"
+
     afm.flatten(channel=chan)
 
     rms_roughness = afm.stats().Forward[chan].Sq
     z = afm.data.Image.Forward[chan]
-    mask = z > 2*rms_roughness
+    mask = z > 2 * rms_roughness
     afm.plane_level()
     afm.flatten(channel=chan, mask=mask)
-    fig = afm.image(cbar='Z [nm]', title='', channel=chan, scalebar={'color':'w','length':0.25}, scale=1e9, theme='dark')
+    fig = afm.image(
+        cbar="Z [nm]",
+        title="",
+        channel=chan,
+        scalebar={"color": "w", "length": 0.25},
+        scale=1e9,
+        theme="dark",
+        cmap=cmap,
+    )
     plt.show()
-    
-    afm.hist(scale=1e12,xlabel='Height [pm]',theme='dark')
-    
 
-    print('Average Roughness: %3.2f pm' % (rms_roughness*1e12))
+    afm.hist(scale=1e12, xlabel="Height [pm]", theme="dark", cmap=cmap)
+
+    print("Average Roughness: %3.2f pm" % (rms_roughness * 1e12))

{nsfopen-2.2.2 → nsfopen-2.2.4}/NSFopen/read/read.py

@@ -224,7 +224,8 @@ class nid_read:
         key = "DataSet\\Calibration\\Scanhead"
         if key in header:
             sens = from_array(key, "In5")
-            cantilever["Sensitivity"] = {"Value": sens / 10, "Unit": "m"}
+            max_defl = from_array(key, "In0")
+            cantilever["Sensitivity"] = {"Value": sens / max_defl, "Unit": "m"}
 
         mapTable = {}
         key = "DataSet\\SpecInfos"
@@ -641,10 +642,6 @@ def checkFileType(filename, cla):
 
 if __name__ == "__main__":
     # filename='..//example//Plane_Removal//circles.nid'
-    filename = "image_test.nhf"
-    afm = read(filename, verbose=True)
-    print(afm.param)
-
-    filename = "new.nhf"
+    filename = "atomic_lattice.nid"
     afm = read(filename, verbose=True)
     print(afm.param)

{nsfopen-2.2.2 → nsfopen-2.2.4/NSFopen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NSFopen
-Version: 2.2.2
+Version: 2.2.4
 Summary: Python module to open Nanosurf NID and NHF files
 Author: Nanosurf AG
 Author-email: scripting@nanosurf.com

{nsfopen-2.2.2 → nsfopen-2.2.4}/NSFopen.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ NSFopen/example/Spring_Constant/thermal.png
 NSFopen/example/Spring_Constant/__pycache__/Spring_Constant.cpython-310.pyc
 NSFopen/example/Spring_Constant/__pycache__/__init__.cpython-310.pyc
 NSFopen/process/__init__.py
+NSFopen/process/colormaps.py
 NSFopen/process/process.py
 NSFopen/read/__init__.py
 NSFopen/read/read.py

{nsfopen-2.2.2/NSFopen.egg-info → nsfopen-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NSFopen
-Version: 2.2.2
+Version: 2.2.4
 Summary: Python module to open Nanosurf NID and NHF files
 Author: Nanosurf AG
 Author-email: scripting@nanosurf.com

nsfopen-2.2.2/NSFopen/_version.py

@@ -1 +0,0 @@
-__version__ = "2.2.2"