ediff 0.2__tar.gz → 0.2.2__tar.gz

{ediff-0.2/src/ediff.egg-info → ediff-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ediff
-Version: 0.2
+Version: 0.2.2
 Summary: Processing of powder electron diffraction patterns
 Home-page: https://github.com/mirekslouf/ediff/
 Author: Mirek Slouf
@@ -18,24 +18,28 @@ EDIFF :: processing of powder electron diffraction patterns
 -----------------------------------------------------------
 * EDIFF is under development, but key modules do work:
     - io = input/output data treatment
-	- bkgr = background subtraction
+	- background = background subtraction
 	- center = find center of 2D powder diffraction pattern
-	- radial = calculate radial distribution (2D-pattern to 1D-pattern) 
+	- radial = calculate radial distribution (2D-pattern ⇒ 1D-pattern) 
 	- pxrd = calculation of theoretical powder X-ray diffraction patterns
 
 Installation
 ------------
-* `pip install bground` = interactive background subtraction
-* `pip install ediff`   = EDIFF program itself (uses bground internally)
+* Requirement: Python with sci-modules: numpy, matplotlib, scipy, pandas
+* `pip install scikit-image` = 3rd party package for advanced image processing 
+* `pip install pymatgen` = 3rd party package employed in PXRD calculation
+* `pip install bground`= our package, interactive background subtraction
+* `pip install ediff` = EDIFF package itself (uses all packages above)
 
 Quick start
 -----------
 * See how it works:
-	- Look at [worked example](https://mirekslouf.github.io/ediff/docs/examples/ex1_ediff.nb.html)
+	- Look at [worked example](https://www.dropbox.com/scl/fi/3hb78voxd17wb3fzh9n1p/01_ediff_au.nb.pdf?rlkey=qmbvwaw80o1gbe262hwgjvmgx&dl=0)
       in Jupyter.
 * Try it yourself:
-	- Download and unzip the [complete example with data](https://www.dropbox.com/scl/fo/nmsvdtef7xtmb7r2ku5aa/h?dl=0&rlkey=2evadkk009wp248rp2c3ij2nj).
-	- Look at `00readme.txt` and run the example in Jupyter.
+	- Download [complete examples with data](https://www.dropbox.com/scl/fo/td6rkdgp2usxosj1vqeku/h?rlkey=41carfdej5h2f8f4yscbuvagm&dl=0)
+	  and scripts and basic instructions.
+	- After downloading, unzip it and follow the instructions in *readme* file.
 
 Documentation, help and examples
 --------------------------------
@@ -51,7 +55,8 @@ Versions of EDIFF
 * Version 0.0.2 = pxrd module works
 * Version 0.0.3 = pxrd module works including profiles
 * Version 0.0.4 = bground module incorporated + slightly improved docstrings
-* Version 0.1.0 = 1st semi-complete version with basic documentation
-* Version 0.1.1 = v.0.1.0 + improved/simplified outputs
-* Version 0.1.2 = v.0.1.1 + small improvements of code and documentation
+* Version 0.1   = 1st semi-complete version with basic documentation
+* Version 0.1.1 = improved/simplified outputs
+* Version 0.1.2 = small improvements of code and documentation
 * Version 0.2   = important improvements of center.py
+* Version 0.2.2 = consolidation, update of docs and examples on www

ediff-0.2.2/README.md

@@ -0,0 +1,46 @@
+EDIFF :: processing of powder electron diffraction patterns
+-----------------------------------------------------------
+* EDIFF is under development, but key modules do work:
+    - io = input/output data treatment
+	- background = background subtraction
+	- center = find center of 2D powder diffraction pattern
+	- radial = calculate radial distribution (2D-pattern ⇒ 1D-pattern) 
+	- pxrd = calculation of theoretical powder X-ray diffraction patterns
+
+Installation
+------------
+* Requirement: Python with sci-modules: numpy, matplotlib, scipy, pandas
+* `pip install scikit-image` = 3rd party package for advanced image processing 
+* `pip install pymatgen` = 3rd party package employed in PXRD calculation
+* `pip install bground`= our package, interactive background subtraction
+* `pip install ediff` = EDIFF package itself (uses all packages above)
+
+Quick start
+-----------
+* See how it works:
+	- Look at [worked example](https://www.dropbox.com/scl/fi/3hb78voxd17wb3fzh9n1p/01_ediff_au.nb.pdf?rlkey=qmbvwaw80o1gbe262hwgjvmgx&dl=0)
+      in Jupyter.
+* Try it yourself:
+	- Download [complete examples with data](https://www.dropbox.com/scl/fo/td6rkdgp2usxosj1vqeku/h?rlkey=41carfdej5h2f8f4yscbuvagm&dl=0)
+	  and scripts and basic instructions.
+	- After downloading, unzip it and follow the instructions in *readme* file.
+
+Documentation, help and examples
+--------------------------------
+* [PyPI](https://pypi.org/project/ediff) repository.
+* [GitHub](https://github.com/mirekslouf/ediff) repository.
+* [GitHub Pages](https://mirekslouf.github.io/ediff/)
+  with [documentation](https://mirekslouf.github.io/ediff/docs).
+
+Versions of EDIFF
+-----------------
+
+* Version 0.0.1 = just draft
+* Version 0.0.2 = pxrd module works
+* Version 0.0.3 = pxrd module works including profiles
+* Version 0.0.4 = bground module incorporated + slightly improved docstrings
+* Version 0.1   = 1st semi-complete version with basic documentation
+* Version 0.1.1 = improved/simplified outputs
+* Version 0.1.2 = small improvements of code and documentation
+* Version 0.2   = important improvements of center.py
+* Version 0.2.2 = consolidation, update of docs and examples on www

ediff-0.2.2/src/ediff/__init__.py

@@ -0,0 +1,45 @@
+'''
+Package: EDIFF
+--------------
+Utilities for processing of electron diffraction patterns.
+
+* Input:
+    - 2D powder electron diffraction pattern
+* Output:
+    - 1D powder electron diffraction pattern
+    - the 1D pattern/profile is obtained by radial averaging of 2D pattern
+    - the final 1D profile can be calibrated and compared with calculated PXRD
+
+EDIFF modules:
+
+* ediff.background = background correction (employs auxilliary package BGROUND)    
+* ediff.center = find center of 2D-diffraction pattern
+* ediff.io = input/output operations (read diffractogram, set plot params...)
+* ediff.pxrd = calculate 1D-PXRD pattern for a known structure
+* ediff.radial = calculate 1D-radial profile from 2D-diffraction pattern
+
+Auxiliary package BGROUND:
+
+* the package enables simple, semi-automated, interactive background correction
+* it is imported during ediff initialization and accessible as ediff.background
+'''
+
+__version__ = "0.2.2"
+
+# Import of modules so that we could use the package as follows:
+# >>> import ediff as ed
+# >>> ed.io.read_image ...
+import ediff.center
+import ediff.io
+import ediff.pxrd
+import ediff.radial
+
+# This is a slightly special import:
+# * ediff (1) imports ediff.background, which (2) imports bground package
+# * see additional imports in ediff.background module to see what is done 
+# * this "two-step import" enables us to use the ediff module as follows:
+# >>> import ediff as ed
+# >>> DATA  = ed.background.InputData ...
+# >>> PPAR  = ed.background.PlotParams ...
+# >>> IPLOT = ed.background.InteractivePlot ...
+import ediff.background

ediff-0.2.2/src/ediff/background.py

@@ -0,0 +1,35 @@
+'''
+Module: ediff.background
+------------------------
+Semi-automated background correction.    
+
+* This module just imports key objects from external bground package.
+* Therefore, it is just a formal incorporation of bground package to ediff.
+
+The source code is the whole module is rather brief,
+but it contains a detailed explanation of how it works.
+
+* See the source code of ediff.background
+  if you are interested in technical details concerning the import.
+* See documentation of bground package at https://pypi.org/project/bground
+  to find out how the background correction works.
+'''
+
+# Explanation of the following two import commands
+# 
+# The 1st import command = all modules from bground.ui to THIS module
+#  - now ediff.background knows the same modules as bground.ui
+#   - but NOT yet the classes within bground.ui - these are imported next
+# The 2nd import command = three key classes from bground.ui to THIS module
+#   - now ediff.bacground contains the three objects from bground.ui
+#   - THIS module now contains InputData, PlotParams, InteractivePlot
+#
+# Final conclusion => the users can do:
+#
+# >>> import ediff.background
+# >>> DATA  = ediff.background.InputData ...
+# >>> PPAR  = ediff.background.PlotParams ...
+# >>> IPLOT = ediff.background.InteractivePlot ...
+
+import bground.ui
+from bground.ui import InputData, PlotParams, InteractivePlot

{ediff-0.2 → ediff-0.2.2}/src/ediff/center.py

@@ -1,11 +1,14 @@
 '''
-Module ediff.center
--------------------
+Module: ediff.center
+--------------------
 Find center of 2D diffraction pattern. 
-
-CenterDet, aktualizace 06-10-23 CentDet update, methods compatibility
 '''
 
+# CenterDet
+# PS 2023-10-06: CentDet update, methods compatibility
+# MS 2023-11-26: Improved code formatting and docs + TODO notes for PS  
+    
+
 import numpy as np
 import skimage as sk
 import matplotlib.pyplot as plt
@@ -17,9 +20,8 @@ import ediff.io
 from skimage.measure import moments
 from skimage.transform import hough_circle, hough_circle_peaks
 
-
-import warnings
 import sys
+import warnings
 warnings.filterwarnings("ignore")
 
 
@@ -27,13 +29,17 @@ class CenterEstimator:
     '''
     Detection of the center of diffraction patterns.
     
-    - Perform Hough transform to detect circles in image
-    - Manually selected 3 points defining a circular diffraction pattern 
-      to calculate center coordinates
-    - Visualize results
+    The center can be estimated in one of the following ways:
     
-    SUBCLASS : CenterAdjustment
-    - adjust position of the detected center 
+    * Center of the intensity/mass in selected area.
+    * Center from three points (defined interactivelly)
+      which define one ring in a powder electron diffraction pattern.
+    * Center estimated from Hough transform,
+      which detects circles in the diffraction pattern.
+    
+    SUBCLASS : CenterLocator
+    
+    * the subclass refines the position of the estimated center 
         
     Parameters
     ----------
@@ -63,14 +69,13 @@ class CenterEstimator:
         Print to terminal additional messages about program run.
     
     Returns
-    -------    
-    self.x : float64
+    -------
+    self.x : float
         x-coordinate of the detected center
-    self.y : float64
+    self.y : float
         y-coordinate of the detected center
-    self.r : float64
-        radius of the detected center (if available, othervise returns None)
-                    
+    self.r : float
+        radius of the detected center (if available, othervise returns None)        
     '''
     
     def __init__(self, input_image, 
@@ -79,6 +84,8 @@ class CenterEstimator:
                        heq = False, 
                        icut = None,
                        cmap = 'gray',
+                       csquare=50,
+                       cintensity=0.8,
                        messages = False):
         
         # Initialize attributes
@@ -108,15 +115,91 @@ class CenterEstimator:
             self.x, self.y, self.r = self.detection_3points()
             
         elif detection_method == 'intensity':
-            self.x, self.y, self.r = self.detection_intensity()
+            self.x, self.y, self.r = self.detection_intensity(csquare, cintensity)
 
         elif detection_method == 'hough':
             self.x, self.y, self.r = self.detection_Hough()  
         else:
             print("Incorrect method for detection selected")
             sys.exit()
+
             
+    def detection_intensity(self, csquare, cintensity, plot_results=0):
+        '''
+        Find center of intensity/mass of an array.
+        
+        Parameters
+        ----------
+        arr : 2D-numpy array
+            The array, whose intensity center will be determined.
+        csquare : int, optional, default is 20
+            The size/edge of the square in the (geometrical) center.
+            The intensity center will be searched only within the central square.
+            Reasons: To avoid other spots/diffractions and
+            to minimize the effect of possible intensity assymetry around center. 
+        cintensity : float, optional, default is 0.8
+            The intensity fraction.
+            When searching the intensity center, we will consider only
+            pixels with intensity > max.intensity.
+            
+        Returns
+        -------
+        xc,yc : float,float
+            XY-coordinates of the intensity/mass center of the array.
+            Round XY-coordinates if you use them for image/array calculations.
+        '''  
+        
+        # (1) Get image/array size
+        image = np.copy(self.to_refine)
+        arr = np.copy(image)
+        xsize,ysize = arr.shape
+        
+        # (2) Calculate borders around the central square
+        xborder = (xsize - csquare) // 2
+        yborder = (ysize - csquare) // 2
+        
+        # (3) Create the central square,
+        # from which the intensity center will be detected
+        arr2 = arr[xborder:-xborder,yborder:-yborder].copy()
+        
+        # (4) In the central square,
+        # set all values below cintenstity to zero
+        arr2 = np.where(arr2>np.max(arr2)*cintensity, arr2, 0)
+        
+        # (5) Determine the intensity center from image moments
+        # see image moments in...
+        # skimage: https://scikit-image.org/docs/dev/api/skimage.measure.html
+        # wikipedia: https://en.wikipedia.org/wiki/Image_moment -> Centroid
+        # ---
+        # (a) Calculate 1st central moments of the image
+        M = moments(arr2,1)
+        # (b) Calculate the intensity center = centroid according to www-help
+        (self.x, self.y) = (M[1,0]/M[0,0], M[0,1]/M[0,0])
+        # (c) We have centroid of the central square
+        # but we have to recalculate it to the whole image
+        (self.x, self.y) = (self.x + xborder, self.y + yborder)
+        # (d) Radius of a diffraction ring is hardcoded to 100 here
+        # TODO: consider improving/correcting/removing in the future
+        self.r = 100
+        
+        # (6) User information (if required)
+        if self.messages:
+            print("--- IntensityCenter = center of intensity/mass ---")
+            print(f"Center coordinates [x, y]: [{self.x:.3f}, {self.y:.3f}]")
+            print("---")
+
+        # (7) Plot results (if required)
+        if plot_results == 1:
+           self.visualize_center(self.x, self.y, self.r) 
                 
+        # (8) Return the results:
+        # a) XY-coordinates of the center
+        # b) radius of the circle/diff.ring,
+        #    from which the center was determined
+        # ! radius of the circle is just hardcoded here - see TODO note above
+        return(self.x, self.y, self.r)
+
+            
     def detection_3points(self, plot_results=1):
         '''         
         In the input image, select manually 3 points defining a circle using
@@ -171,10 +254,9 @@ class CenterEstimator:
         ax.imshow(im, cmap = self.cmap)
         ax.axis('off')
 
- 
         # User information:
         if self.messages:
-            print("--- Manual diffraction pattern detection ---")
+            print("--- ThreePoints = semi-automated center detection ---")
             print()
             print("Select 3 points to define a circle in the diffractogram:")
             print("Use these keys for the selection:")
@@ -184,8 +266,11 @@ class CenterEstimator:
             print("  - 'd' : done = finished = go to the next step")
             print()
             print("Close the figure to terminate. No center will be detected.")
+            print("---")
        
         # Enable interactive mode
+        # (figure is updated after every plotting command
+        # (so that calling figure.show() is not necessary
         plt.ion()
  
         # Initialize the list of coordinates
@@ -227,11 +312,10 @@ class CenterEstimator:
                     closest_index = np.argmin(distances)
                     del self.coords[closest_index]
     
-                    # Redraw the image without the deleted point
+                    ## Redraw the image without the deleted point
                     ax.clear()
                     ax.imshow(self.to_refine, cmap = self.cmap)
                     for x, y in self.coords:
-
                         ax.scatter(x, y, 
                                    c='r', marker='x', 
                                    s=self.marker_size)
@@ -245,13 +329,12 @@ class CenterEstimator:
                     ax.set_xlim(current_xlim)
                     ax.set_ylim(current_ylim)
                     ax.axis('off')
-
- 
+                    
                     fig.canvas.draw()
                 else:
                     print("No points to delete.")
     
-            ## Delete recent point (last added) -- independent on the cursor
+            # Delete recent point (last added) -- independent on the cursor
             if event.key == '2':
                 # Check if there are points to delete
                 if point_counter > 0:  
@@ -304,7 +387,7 @@ class CenterEstimator:
                                    c='r', marker='x', 
                                    s=self.marker_size)
 
-                        # Retore the previous zoom level
+                        # Restore the previous zoom level
                         ax.set_xlim(current_xlim)
                         ax.set_ylim(current_ylim)
                         ax.axis('off')
@@ -340,8 +423,7 @@ class CenterEstimator:
         ax.axis('off')
 
         plt.show(block=False)
-
-        
+      
         # Wait for 'd' key event or close the figure if no points are selected
         while not calculate_circle_flag and not termination_flag:
  
@@ -361,8 +443,7 @@ class CenterEstimator:
                     # Retore the previous zoom level
                     ax.set_xlim(current_xlim)
                     ax.set_ylim(current_ylim)
-                
- 
+                 
                     circle = plt.Circle(
                         (self.x, self.y), self.r, color='r', fill=False)
                     ax.add_artist(circle)
@@ -383,8 +464,7 @@ class CenterEstimator:
             except ValueError as e:
                 print("ValueError:", e)
                 break
-
-            
+           
         # If the termination_flag is True, stop the code
         if termination_flag: 
              print("No points selected. Returned None values.")
@@ -397,12 +477,15 @@ class CenterEstimator:
         # local variables save
         self.center = center
         
-        
+        self.backip = [self.x, self.y, self.r]
         # Manually adjust the calculated center coordinates
         self.x, self.y, self.r = self.adjustment_3points(fig, circle, center)
 
- 
-        return self.x, self.y, self.r
+        # Return the results:
+        # a) XY-coordinates of the center
+        # b) radius of the circle/diff.ring,
+        #    from which the center was determined
+        return(self.x, self.y, self.r)
 
     
     def adjustment_3points(self, fig, circle, center, plot_results=0):
@@ -539,7 +622,7 @@ class CenterEstimator:
             except KeyboardInterrupt:
                 # If the user manually closes the figure, terminate the loop
                 termination_flag = True
-         
+                
         # Turn off interactive mode
         plt.ioff()
         
@@ -559,74 +642,8 @@ class CenterEstimator:
         
     
         return xy[0], xy[1], r
-        
-        
-    def detection_intensity(self, csquare=20, cintensity=0.5, plot_results=0):
-        '''
-        Find center of intensity/mass of an array.
-        
-        Parameters
-        ----------
-        arr : 2D-numpy array
-            The array, whose intensity center will be determined.
-        csquare : int, optional, default is 20
-            The size/edge of the square in the (geometrical) center.
-            The intensity center will be searched only within the central square.
-            Reasons: To avoid other spots/diffractions and
-            to minimize the effect of possible intensity assymetry around center. 
-        cintensity : float, optional, default is 0.8
-            The intensity fraction.
-            When searching the intensity center, we will consider only
-            pixels with intensity > max.intensity.
-            
-        Returns
-        -------
-        xc,yc : float,float
-            XY-coordinates of the intensity/mass center of the array.
-            Round XY-coordinates if you use them for image/array calculations.
-        '''  
-        
-        # Get image/array size
-        image = np.copy(self.to_refine)
-        arr = np.copy(image)
-        xsize,ysize = arr.shape
-        
-        # Calculate borders around the central square
-        xborder = (xsize - csquare) // 2
-        yborder = (ysize - csquare) // 2
-        
-        # Create central square = cut off the borders
-        arr2 = arr[xborder:-xborder,yborder:-yborder].copy()
-        
-        # In the central square, set all values below cintenstity to zero
-        arr2 = np.where(arr2>np.max(arr2)*cintensity, arr2, 0)
-        
-        # Calculate 1st central moments of the image
-        M = moments(arr2,1)
-        
-        # Calculate the intensity center = centroid according to www-help
-        (self.x, self.y) = (M[1,0]/M[0,0], M[0,1]/M[0,0])
-        
-        # We have centroid of the central square => recalculate to whole image
-        (self.x, self.y) = (self.x + xborder, self.y + yborder)
-        self.r = 100
-        
-        # User information:
-        if self.messages:
-            print("--------- Diffraction pattern detection via intensity detection ----------")
-            print("Central coordinate [ x, y ]: [{:.3f}, {:.3f}]".format(float(self.x), 
-                                                                         float(self.y)))
-            print("--------------------------------------------------------------------------")
-
-        # Plot result of the Hough transform
-        if plot_results == 1:
-           self.visualize_center(self.x, self.y, self.r) 
-        
-        
-        # Return results
-        return self.x, self.y, self.r
-
     
+        
     def detection_Hough(self, plot_results=0):
         '''        
         Perform Hough transform to detect center of diffraction patterns.
@@ -812,9 +829,7 @@ class CenterEstimator:
             plt.axis('off')
             plt.tight_layout()
             plt.show(block=False)
-        else:
-            pass
-            #plt.close('all')
+
         
         self.center = (self.x, self.y)
         self.circle = plt.Circle((self.x,self.y),self.r)
@@ -935,7 +950,7 @@ class CenterLocator(CenterEstimator):
        Selection of a method for center position correction. Default is None.
        String codes are:
            - 'manual' : manual corection 
-           - 'variance' : correction via variance minimization 
+           - 'var' : correction via variance minimization 
            - 'sum' : correction via sum maximization
     heq : boolean
         Allow histogram equalization. The default is 0 (no enhancement)
@@ -953,6 +968,7 @@ class CenterLocator(CenterEstimator):
         radius of the detected center
     '''
     
+
     def __init__(self, image_path,
                  detection_method, correction_method=None, 
                  heq=False, icut=None, cmap='gray',
@@ -965,7 +981,6 @@ class CenterLocator(CenterEstimator):
         
 
         # (2) Define additional parameter
-        self.final_replot = final_replot
         self.messages = messages
         self.image_path = image_path
 
@@ -975,25 +990,41 @@ class CenterLocator(CenterEstimator):
             self.ret = 1
             if correction_method == 'manual':
                 if detection_method == 'manual':
-                    self.xx, self.yy, self.rr = self.x, self.y, self.r
-                    self.x, self.y, self.r = self.backip[0], self.backip[1], self.r
-                    if self.final_replot:
-                        self.visualize_refinement(
-                            self.backip[0], self.backip[1], self.r, 
-                            (self.xx, self.yy), self.r)
+                    self.yy, self.xx, self.rr = self.x, self.y, self.r
+                    self.y, self.x, self.r = self.backip[0], self.backip[1], self.r
+                elif detection_method == 'intensity':
+                    self.yy, self.xx, self.rr = \
+                        self.ref_interactive(self.y, self.x, self.r)
                 else:
-                    self.xx, self.yy, self.rr = \
+                    self.yy, self.xx, self.rr = \
                         self.ref_interactive(self.x, self.y, self.r)
-            elif correction_method == 'variance':
+                        
+            elif correction_method == 'var':
                 self.xx, self.yy, self.rr = \
-                    self.ref_minimize_var(self.x, self.y, self.r)
+                    self.ref_var(self.x, self.y, self.r)
+                if detection_method == 'manual':
+                    self.xx, self.yy = self.yy, self.xx
+                    self.x, self.y = self.y, self.x
+                    
             elif correction_method == 'sum':
                 self.xx, self.yy, self.rr = \
-                    self.ref_maximize_sum(self.x, self.y, self.r)
+                    self.ref_sum(self.x, self.y, self.r)
+                if detection_method == 'manual':
+                    self.xx, self.yy = self.yy, self.xx
+                    self.x, self.y = self.y, self.x
+
             else:
                 print("Incorrect method for correction selected")
                 sys.exit()
+            
+            if detection_method == 'hough':
+                self.x, self.y = self.y, self.x
+                self.xx, self.yy = self.yy, self.xx
 
+            if final_replot:
+                self.visualize_refinement(
+                    self.y, self.x, self.r, 
+                    (self.yy, self.xx), self.rr)
         else:
             self.ret = 2
 
@@ -1220,10 +1251,9 @@ class CenterLocator(CenterEstimator):
         y : float
             y-coordinate of the center detected via detection_method
         xx : float
-            x-coordinate of the center detected via correction_method
+            x-coordinate of the center detected via refinement_method
         yy : float
-           y-coordinate of the center detected via detection_method
-           
+            y-coordinate of the center detected via refinement_method
         """
         
         if self.ret == 1:
@@ -1285,6 +1315,7 @@ class CenterLocator(CenterEstimator):
         r : float64
             new radius of the circular diffraction pattern
         '''
+        
         # Load original image
         im = np.copy(self.to_refine)
         
@@ -1321,7 +1352,7 @@ class CenterLocator(CenterEstimator):
         ax.add_artist(circle)
 
         # Plot center point
-        center, = ax.plot(self.x, self.y, 'rx', markersize=12)
+        center, = ax.plot(px, py, 'rx', markersize=12)
                     
 
         plt.title('Manually adjust the center position.', 
@@ -1426,15 +1457,11 @@ class CenterLocator(CenterEstimator):
         if self.messages:
             print("CenterEstimator :: manual detection + adjustment")
             print(f"Center coordinates: {xy[0]:.2f} {xy[1]:.2f}")
-        
-        # Plot results
-        if self.final_replot:
-            self.visualize_refinement(px, py, pr, xy, r)
-                
+                       
         return xy[0], xy[1], r
 
         
-    def ref_minimize_var(self, px, py, pr, plot_results = 0):
+    def ref_var(self, px, py, pr, plot_results = 0):
         '''         
         Adjust center coordinates of a detected circular diffraction pattern.
         The center adjustment is based on variance minimization.
@@ -1587,11 +1614,6 @@ class CenterLocator(CenterEstimator):
         if np.round(init_var,-2) < np.round(min_intensity_var,-2):
             print("Refinement redundant.")
             best_center = np.copy(bckup)
-
-        # Refinement visualization
-        if self.final_replot:
-            self.visualize_refinement(
-                   bckup[0], bckup[1], bckup[2], (best_center), best_radius)
     
         # Print results
         if self.messages:
@@ -1601,7 +1623,7 @@ class CenterLocator(CenterEstimator):
         return best_center[0], best_center[1], best_radius
     
     
-    def ref_maximize_sum(self, px, py, pr, plot_results=1):
+    def ref_sum(self, px, py, pr, plot_results=1):
         ''' 
         Adjust center position based on gradient optimization method
         via maximization of intensity sum.
@@ -1754,12 +1776,6 @@ class CenterLocator(CenterEstimator):
         if np.round(init_sum,-2) > np.round(max_intensity_sum,-2):
             print("Refinement redundant.")
             best_center = np.copy(bckup)
-
-        # Refinement visualization
-        if plot_results == 1:
-            if self.final_replot:
-                self.visualize_refinement(
-                    bckup[0], bckup[1], bckup[2], (best_center), best_radius)
     
         # Print results
         if self.messages:
@@ -1950,7 +1966,6 @@ class HandlerCircle(HandlerBase):
         return [marker]
         
 
-        
 class IntensityCenter: 
     '''
     Simple center determination for a symmetric diffractogram.
@@ -1977,7 +1992,7 @@ class IntensityCenter:
     >>>     arr, detection_method='intensity', csquare=30, cintensity=0.8)
     '''
     
-    
+    @staticmethod
     def center_of_intensity(arr, csquare=20, cintensity=0.8):
         '''
         Find center of intensity/mass of an array.
@@ -2017,6 +2032,7 @@ class IntensityCenter:
         (xc,yc) = (M[1,0]/M[0,0], M[0,1]/M[0,0])
         # We have centroid of the central square => recalculate to whole image
         (xc,yc) = (xc+xborder,yc+yborder)
+        
         ## Return the final center
         return(xc,yc)
 

{ediff-0.2 → ediff-0.2.2}/src/ediff/io.py

@@ -1,6 +1,6 @@
 '''
-Module ediff.io
----------------
+Module: ediff.io
+----------------
 Input/output functions for package ediff.    
 '''
 
@@ -68,13 +68,14 @@ def set_plot_parameters(
     if fontsize:  # Global font size
         plt.rcParams.update({'font.size' : fontsize})
     # (2) Additional default parameters ---------------------------------------
-    plt.rcParams.update({
-        'lines.linewidth'    : 0.8,
-        'axes.linewidth'     : 0.6,
-        'xtick.major.width'  : 0.6,
-        'ytick.major.width'  : 0.6,
-        'grid.linewidth'     : 0.6,
-        'grid.linestyle'     : ':'})
+    if my_defaults:  # Default rcParams if not forbidden by my_defaults=False
+        plt.rcParams.update({
+            'lines.linewidth'    : 0.8,
+            'axes.linewidth'     : 0.6,
+            'xtick.major.width'  : 0.6,
+            'ytick.major.width'  : 0.6,
+            'grid.linewidth'     : 0.6,
+            'grid.linestyle'     : ':'})
     # (3) Further user-defined parameter in rcParams format -------------------
     if my_rcParams:  # Other possible rcParams in the form of dictionary
         plt.rcParams.update(my_rcParams)
@@ -114,13 +115,17 @@ def plot_radial_distributions(
         The output is the plot on screen
         (and in *output file* if the *output* argument was given).
     
-    Technical note
-    --------------
-    This function is quite flexible.
-    It can plot one radial distribution or more.
-    It can take data from PNG-files, TXT-files, 2D-arrays and 1D-arrays.
-    This makes the code a bit more complex, but it is convenient for the user.
-    A fast comparison of three 1D-distributions from three 2D-diffractograms:
+    Technical notes
+    ---------------
+    * This function is quite flexible.
+    * It can plot one radial distribution or more.
+    * It can take data from PNG-files, TXT-files, 2D-arrays and 1D-arrays.
+    * If the input is a PNG-file or2D-array,
+      the center is just *estimated* as as the center of intensity;
+      therefore, this works only for good diffractograms with a central spot.
+    * This makes the code a more complex, but it is convenient for the user.
+    * An example of fast comparison of three 1D-distributions
+      taken from three 2D-diffractograms in the form of 16-bit PNG images:
     
     >>> ediff.io.plot_radial_distributions(
     >>>     data_to_plot = [

{ediff-0.2 → ediff-0.2.2}/src/ediff/pxrd.py

@@ -1,6 +1,6 @@
 '''
-Module ediff.pxrd
------------------
+Module: ediff.pxrd
+------------------
 Calculation of powder X-ray diffraction patterns.    
 '''
 
@@ -12,6 +12,7 @@ from scipy.signal import convolve as spConvolve
 from pymatgen.core.structure import Structure as pmStructure
 from pymatgen.analysis.diffraction.xrd import XRDCalculator as pmXRDCalculator
 
+
 class Crystal:
     '''
     Define crystal structure.
@@ -38,6 +39,7 @@ class Crystal:
           the elements have the values defined in the dictionary;
           a sample input dictionary: `temp_factors = {'Na':1.2, 'Cl':1.1}`.
     '''
+
     
     def __init__(self, structure, temp_factors=0.8):
         '''
@@ -60,6 +62,7 @@ class Crystal:
             # (the number is a universal temperature factor for all atoms
             self.temp_factors = self.get_elements_with_temp_factors(
                 self.structure, temp_factors)
+
     
     @staticmethod
     def read_structure_from_CIF(CIF):
@@ -86,6 +89,7 @@ class Crystal:
         structure = pmStructure.from_file(CIF)
         return(structure)
 
+
     def get_elements(self, structure):
         '''
         Get a list of all elements, which are contained in given structure.
@@ -122,6 +126,7 @@ class Crystal:
         list_of_elements = np.unique(list_of_atoms)
         return(list_of_elements)
 
+
     def get_elements_with_temp_factors(self, structure, B=0.8):
         '''
         Get a dictionary, which contains symbols and temperature factors
@@ -154,6 +159,8 @@ class Crystal:
         elements_with_temp_factors = dict.fromkeys(elements, B)
         return(elements_with_temp_factors)
 
+
+
 class Experiment:
     '''
     Define experimental parameters.
@@ -167,6 +174,8 @@ class Experiment:
         Minimal and maximal diffraction angle;
         both values are TwoTheta angle in [deg] (for given *wavelength*).
     '''
+
+
     def __init__(self, wavelength, two_theta_range):
         '''
         * Initialize Experimental object.
@@ -175,6 +184,8 @@ class Experiment:
         self.wavelength = wavelength
         self.two_theta_range = two_theta_range
 
+
+
 class PlotParameters:
     '''
     Define local+global parameters for plotting.
@@ -191,6 +202,7 @@ class PlotParameters:
         This enables to override current rcParams, if necessary.
     '''
     
+
     def __init__(self, title=None, x_axis='q', xlim=None, rcParams={}):
         '''
         * Initialize PlotParameters object.
@@ -203,6 +215,8 @@ class PlotParameters:
         self.xlim = xlim
         if rcParams: plt.rcParams.update(rcParams)
        
+
+
 class PeakProfiles:
     '''
     Define profile of diffraction peaks.
@@ -211,6 +225,7 @@ class PeakProfiles:
     * It contains three functions/definitions of diffratction peak profiles.
     '''
 
+
     def gaussian(X,m,s):
         '''
         Gaussian function (~ profile for PXRD calculation).
@@ -231,6 +246,7 @@ class PeakProfiles:
         '''
         return( 1/(s*np.sqrt(2*np.pi)) * np.exp(-(X-m)**2/(2*s**2)) )
     
+
     def lorentzian(X,m,s):
         '''
         Lorentzian function (~ profile for PXRD calculation).
@@ -251,6 +267,7 @@ class PeakProfiles:
         '''
         return( 1/np.pi * s/((X-m)**2 + s**2) )
     
+
     def pseudo_voigt(X,m,s,n=0.5):
         '''
         Pseudo-Voigt function (~ profile for PXRD calculation).
@@ -296,6 +313,8 @@ class PeakProfiles:
         # (3) Return calculated function    
         return(pseudo_voigt)
 
+
+
 class PXRDcalculation:
     '''
     Define calculation of PXRD = powder X-ray diffraction pattern.
@@ -323,7 +342,8 @@ class PXRDcalculation:
         This default is suitable for common calculations
         and does not have to be changed (in great majority of cases).
     '''
-  
+
+    
     def __init__(self, crystal, experiment, plot_parameters,      
                  peak_profile_sigma = 0.03,
                  peak_profile_type = PeakProfiles.pseudo_voigt):
@@ -339,6 +359,7 @@ class PXRDcalculation:
         self.diffractions = self.calculate_diffractions()
         self.diffractogram = self.calculate_diffractogram()
 
+
     def calculate_diffractions(self):
         # (1) Calculate intensities
         calculation = pmXRDCalculator(
@@ -353,6 +374,7 @@ class PXRDcalculation:
         # (pandas.DataFrame with cols: TwoTheta, h,k,l, dhkl, S, q, Intensity
         return(diffractions_df)
         
+
     def calculate_diffractogram(self):
         # (1) Base diffraction profile
         # = diffractogram with zero intensities
@@ -402,6 +424,7 @@ class PXRDcalculation:
         # (5) Return diffractogram
         return(df)
         
+
     def print_diffractions(self):
         '''
         Print the calculated diffractions to stdout.
@@ -409,6 +432,7 @@ class PXRDcalculation:
         table = PXRDcalculation.dframe_to_table(self.diffractions)
         print(table)
             
+
     def save_diffractions(self, output_file):
         '''
         Save the calculated diffractions to *output_file*.
@@ -429,6 +453,7 @@ class PXRDcalculation:
         except:
             print(f'Error saving diffractions to {output_file}!')
     
+
     def plot_diffractions(self, outfile=None):
         '''
         Plot the calculated diffractions.
@@ -441,18 +466,25 @@ class PXRDcalculation:
 
         Returns
         -------
-        * None; the output is the plot on the screen (and outfile).
-        * Note that the plot shows just diffraction intensities, not profiles.
-        * Use *plot_diffractogram* for diffractogram with intensity profiles.
+        None
+            The output is the plot on the screen (and outfile).
+            This function plots just diffraction intensities,
+            not profiles.
+            Use ediff.pxrd.plot_diffractions
+            for diffractogram with intensity profiles.
         '''
+        
         # (1) Make local copies of pre-defined parameters (just convenience)
         df      = self.diffractions
         x_axis  = self.plot_parameters.x_axis
+        
         # (2) Prepare the plot
         plt.vlines(df[x_axis],0,df.Ihkl, lw=2)
+        
         # (3) Set plot details
         # (external function, common to diffractions and diffractogram plots
         self.set_plot_details(x_axis)
+        
         # (4) Save/show the plot...
         # In Spyder: plot is always shown
         # In CLI: plot is saved (if outfile is defined) or it is just shown
@@ -461,6 +493,7 @@ class PXRDcalculation:
         else:
             plt.show()
         
+
     def plot_diffractions_with_indexes(self):
         '''
         Plot indexed diffractions.
@@ -533,6 +566,7 @@ class PXRDcalculation:
         # (6) Revert to original rcParams.
         plt.rcParams.update(original_rcParams)
         
+
     def print_diffractogram(self):
         self.print_diffractions()
         print('-----')
@@ -540,6 +574,7 @@ class PXRDcalculation:
         print('* Reason: the whole diffraction pattern is too long.')
         print('* Note: save_diffractogram save the pattern to TXT-file.')
     
+
     def save_diffractogram(self, outfile):
         my_title = 'Calculated PXRD diffractogram\n'
         np.savetxt(
@@ -549,22 +584,28 @@ class PXRDcalculation:
             header = my_title + 
                 'Columns: TwoTheta[deg], S[1/A], q[1/A], Intensity')
     
-    def plot_diffractogram(self, outfile, x_axis='q'):
+
+    def plot_diffractogram(self, outfile, x_axis='q', dpi=300):
+        
         # (1) Make local copies of pre-defined parameters (just convenience)
         df     = self.diffractogram
         x_axis = self.plot_parameters.x_axis
+        
         # (2) Prepare the plot
         plt.plot(df[x_axis],df.Intensity)
+        
         # (3) Set plot details
         # (external function, common to diffractions and diffractogram plots
         self.set_plot_details(x_axis)
+        
         # (4) Save/show the plot...
         # In Spyder: plot is always shown
         # In CLI: plot is saved (if outfile is defined) or it is just shown
         if outfile != None: 
-            plt.savefig(outfile) 
+            plt.savefig(outfile, dpi=dpi) 
         else:
             plt.show()
+
         
     @staticmethod    
     def diffractions_to_dframe(intensities):
@@ -602,6 +643,7 @@ class PXRDcalculation:
             df.insert(loc=6, column='S', value=1/df.dhkl)
             df.insert(loc=7, column='q', value=2*np.pi*df.S)
         return(df)
+
     
     @staticmethod
     def dframe_to_table(dframe):
@@ -649,6 +691,7 @@ class PXRDcalculation:
                     'Ihkl'     : '{:9.3f}'.format})
         return(table)
 
+
     def add_diffraction_vectors_to_diffractogram(self, df):
         # Prepare wavelenght (just shortcut for convenience)
         wavelength = self.experiment.wavelength
@@ -663,6 +706,7 @@ class PXRDcalculation:
         # Return the modified/extended DataFrame
         return(df)
 
+
     def set_plot_details(self, x_axis):
         # (1) Make local copies of pre-defined parameters (just convenience)
         title   = self.plot_parameters.title

{ediff-0.2 → ediff-0.2.2}/src/ediff/radial.py

@@ -1,6 +1,6 @@
 '''
-Module ediff.radial
--------------------
+Module: ediff.radial
+--------------------
 The conversion of a 2D powder diffraction pattern
 to a 1D powder diffraction pattern = radially averaged intensity distribution.
 '''

{ediff-0.2 → ediff-0.2.2/src/ediff.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ediff
-Version: 0.2
+Version: 0.2.2
 Summary: Processing of powder electron diffraction patterns
 Home-page: https://github.com/mirekslouf/ediff/
 Author: Mirek Slouf
@@ -18,24 +18,28 @@ EDIFF :: processing of powder electron diffraction patterns
 -----------------------------------------------------------
 * EDIFF is under development, but key modules do work:
     - io = input/output data treatment
-	- bkgr = background subtraction
+	- background = background subtraction
 	- center = find center of 2D powder diffraction pattern
-	- radial = calculate radial distribution (2D-pattern to 1D-pattern) 
+	- radial = calculate radial distribution (2D-pattern ⇒ 1D-pattern) 
 	- pxrd = calculation of theoretical powder X-ray diffraction patterns
 
 Installation
 ------------
-* `pip install bground` = interactive background subtraction
-* `pip install ediff`   = EDIFF program itself (uses bground internally)
+* Requirement: Python with sci-modules: numpy, matplotlib, scipy, pandas
+* `pip install scikit-image` = 3rd party package for advanced image processing 
+* `pip install pymatgen` = 3rd party package employed in PXRD calculation
+* `pip install bground`= our package, interactive background subtraction
+* `pip install ediff` = EDIFF package itself (uses all packages above)
 
 Quick start
 -----------
 * See how it works:
-	- Look at [worked example](https://mirekslouf.github.io/ediff/docs/examples/ex1_ediff.nb.html)
+	- Look at [worked example](https://www.dropbox.com/scl/fi/3hb78voxd17wb3fzh9n1p/01_ediff_au.nb.pdf?rlkey=qmbvwaw80o1gbe262hwgjvmgx&dl=0)
       in Jupyter.
 * Try it yourself:
-	- Download and unzip the [complete example with data](https://www.dropbox.com/scl/fo/nmsvdtef7xtmb7r2ku5aa/h?dl=0&rlkey=2evadkk009wp248rp2c3ij2nj).
-	- Look at `00readme.txt` and run the example in Jupyter.
+	- Download [complete examples with data](https://www.dropbox.com/scl/fo/td6rkdgp2usxosj1vqeku/h?rlkey=41carfdej5h2f8f4yscbuvagm&dl=0)
+	  and scripts and basic instructions.
+	- After downloading, unzip it and follow the instructions in *readme* file.
 
 Documentation, help and examples
 --------------------------------
@@ -51,7 +55,8 @@ Versions of EDIFF
 * Version 0.0.2 = pxrd module works
 * Version 0.0.3 = pxrd module works including profiles
 * Version 0.0.4 = bground module incorporated + slightly improved docstrings
-* Version 0.1.0 = 1st semi-complete version with basic documentation
-* Version 0.1.1 = v.0.1.0 + improved/simplified outputs
-* Version 0.1.2 = v.0.1.1 + small improvements of code and documentation
+* Version 0.1   = 1st semi-complete version with basic documentation
+* Version 0.1.1 = improved/simplified outputs
+* Version 0.1.2 = small improvements of code and documentation
 * Version 0.2   = important improvements of center.py
+* Version 0.2.2 = consolidation, update of docs and examples on www

ediff-0.2/README.md

@@ -1,41 +0,0 @@
-EDIFF :: processing of powder electron diffraction patterns
------------------------------------------------------------
-* EDIFF is under development, but key modules do work:
-    - io = input/output data treatment
-	- bkgr = background subtraction
-	- center = find center of 2D powder diffraction pattern
-	- radial = calculate radial distribution (2D-pattern to 1D-pattern) 
-	- pxrd = calculation of theoretical powder X-ray diffraction patterns
-
-Installation
-------------
-* `pip install bground` = interactive background subtraction
-* `pip install ediff`   = EDIFF program itself (uses bground internally)
-
-Quick start
------------
-* See how it works:
-	- Look at [worked example](https://mirekslouf.github.io/ediff/docs/examples/ex1_ediff.nb.html)
-      in Jupyter.
-* Try it yourself:
-	- Download and unzip the [complete example with data](https://www.dropbox.com/scl/fo/nmsvdtef7xtmb7r2ku5aa/h?dl=0&rlkey=2evadkk009wp248rp2c3ij2nj).
-	- Look at `00readme.txt` and run the example in Jupyter.
-
-Documentation, help and examples
---------------------------------
-* [PyPI](https://pypi.org/project/ediff) repository.
-* [GitHub](https://github.com/mirekslouf/ediff) repository.
-* [GitHub Pages](https://mirekslouf.github.io/ediff/)
-  with [documentation](https://mirekslouf.github.io/ediff/docs).
-
-Versions of EDIFF
------------------
-
-* Version 0.0.1 = just draft
-* Version 0.0.2 = pxrd module works
-* Version 0.0.3 = pxrd module works including profiles
-* Version 0.0.4 = bground module incorporated + slightly improved docstrings
-* Version 0.1.0 = 1st semi-complete version with basic documentation
-* Version 0.1.1 = v.0.1.0 + improved/simplified outputs
-* Version 0.1.2 = v.0.1.1 + small improvements of code and documentation
-* Version 0.2   = important improvements of center.py

ediff-0.2/src/ediff/__init__.py

@@ -1,7 +0,0 @@
-'''
-Package: EDIFF
---------------
-Utilities for simple processing of electron diffraction patterns.
-'''
-
-__version__ = "0.2"

ediff-0.2/src/ediff/background.py

@@ -1,24 +0,0 @@
-'''
-Module ediff.background
------------------------
-Interactive background definition.    
-'''
-
-# The module just imports key objects from external bground module.
-# This is a formal incorporation of bground module to ediff.background module.
-
-# How it works? = comment to the next two import commands:
-# The 1st import command = all modules from bground.ui to THIS module
-#  => now ediff.background knows the same modules as bground.ui
-#  => but NOT yet the classes within bground.ui - these are imported next
-# The 2nd import command = three key classes from bground.ui to THIS module
-#  => now ediff.bacground contains the three objects from bground.ui
-#  => THIS module now contains InputData, PlotParams, InteractivePlot
-# Now the users of this module can do:
-#  >>> import ediff.background
-#  >>> DATA  = ediff.background.InputData ...
-#  >>> PPAR  = ediff.background.PlotParams ...
-#  >>> IPLOT = ediff.background.InteractivePlot ...
-
-import bground.ui
-from bground.ui import InputData, PlotParams, InteractivePlot