From 15581965a0e295c9ba9cdec1b652eb846ba122f7 Mon Sep 17 00:00:00 2001 From: Chaoyi Zhu Date: Mon, 30 Sep 2019 23:50:01 -0400 Subject: [PATCH 1/3] pyEMsoft typo correction, contents added, and started to work on image filter example notebook --- Source/pyEMsoft/docs/pyEMsoft.rst | 149 +++++------- .../examples/Example5_image_filters.ipynb | 213 ++++++++++++++++++ 2 files changed, 268 insertions(+), 94 deletions(-) create mode 100644 Source/pyEMsoft/examples/Example5_image_filters.ipynb diff --git a/Source/pyEMsoft/docs/pyEMsoft.rst b/Source/pyEMsoft/docs/pyEMsoft.rst index 8c0a3233..8dd79ecd 100644 --- a/Source/pyEMsoft/docs/pyEMsoft.rst +++ b/Source/pyEMsoft/docs/pyEMsoft.rst @@ -6,7 +6,8 @@ Executing EMsoft program in Python .. role:: bash(code) :language: bash -This is directly calling the built EMsoft functions from within Python. First, the .../EMsoftBuild/Release/Bin folder needs to be added to the path. +This is directly calling the built EMsoft functions from within Python. First, the :bash:`.../EMsoftBuild/Release/Bin` folder needs to be added to the path. +This is directly calling the built EMsoft functions from within Python. First, the :bash:`.../EMsoftBuild/Release/Bin` folder needs to be added to the path. Second, complete the EMsoft package configuration following the `EMsoft Wiki Package Configuration `_. Then, create a Ni.xtal file as defined in `Crystal Data Entry Example `_. This crystal file will later be read into some of the unittests files. @@ -26,13 +27,7 @@ How to use the pyEMsoft module? .. role:: python(code) :language: python -In a terminal, cd into the folder containing the shared library (mac: .so file and pyEMsoft.py). -Run Python interpreter and then :python:`import pyEMsoft`. For Python scripts saved in a different folder -to the generated shared library and pyEMsofy.py (e.g. unittests folder). The directory must be set first -to the point to the correct folder.In an example below, the shared libray and the pyEMsoft.py are -saved in a different folder (one folder level up).In addition, some simple tools dedicated to pyEMsoft -have also been created and are saved inside a separate module named pyEMsoftTools. Depending on the need, -some other popular modules will also be imported such as the numpy, math, unittest, random, etc. +In a terminal, cd into the folder containing the shared library (mac: .so file and pyEMsoft.py). Run Python interpreter and then :python:`import pyEMsoft`. For Python scripts saved in a different folder to the generated shared library and pyEMsoft.py (e.g. unittests folder). The directory must be set first to the point to the correct folder.In an example below, the shared library and the pyEMsoft.py are saved in a different folder (one folder level up).In addition, some simple tools dedicated to :python:`pyEMsoft` have also been created and are saved inside a separate module named :python:`pyEMsoftTools`. Depending on the need, some other popular modules will also be imported such as the :python:`numpy`, :python:`math`, :python:`unittest`, :python:`random`, etc. .. code-block:: python @@ -49,10 +44,9 @@ Constants (constants.f90) ------------------------------------------------- This module contains physical and mathematical constants used by various programs -such as periodic table information, atomic weights, etc. For a complete list of constants, -please refer to the the original fortran file. +such as periodic table information, atomic weights, etc. -Some types have already been tested in the unittest file. For instance, +A few examples have been tested in the unittest file. For instance, several examples of basic constants (in SI units) can be found in this module: .. code-block:: python @@ -63,25 +57,23 @@ several examples of basic constants (in SI units) can be found in this module: print('Planck constant (h) is %e (Js)' % (pyEMsoft.constants.cplanck), '\n') print('Boltzmann Constant (k) is %e (mˆ2kgsˆ(-1)Kˆ(-1))' % (pyEMsoft.constants.cboltzmann), '\n') - +For a complete list of constants, please refer to the original fortran file (constants.f90). Typedefs (typedefs.f90) ------------------------------------------------- -It contains definition of all variables and types for crystallographic computations in EMsoft. More specifically, it defines the unitcell type (python class) -and the orientation type, as well as the main cell variable used by all crystallographic computations. +It contains definition of all variables and types for crystallographic computations in EMsoft. More specifically, it defines the unitcell type and the orientation type (class type objects in python) , as well as the main cell variable used by all crystallographic computations. -For instance, one important variable that is used extensively within EMsoft is the unitcell type (python class). +For instance, one important variable that is used extensively within EMsoft is the :python:`unitcell type`. .. code-block:: python # use the unitcell class defined in the typedefs module LatCell=pyEMsoft.typedefs.unitcell() -This can now be used as input/output in other associated routines. +This :python:`unitcell` can now be used as input/output variable in other associated routines. -Another special case of variable is the character array such as a list of space group name. -The output numpy.array is in ASCII encoded format. To retrieve the characters, get_character_array function from the pyEMsoftTools can be used. +Another special case of variable is the character array such as a list of space group name. The output numpy.array is in ASCII encoded format. To retrieve the characters, get_character_array function from the pyEMsoftTools can be used. .. code-block:: python @@ -91,10 +83,9 @@ The output numpy.array is in ASCII encoded format. To retrieve the characters, g Quaternions (quaternions.f90) ------------------------------------------------- -Quaternions module contains basic quaternion functions such as quaternion normalization/complex conjugate/multiplication/division/inner product/rotation, -interquaternion angle, random quaternion and interpolation between quaternions. +Quaternions module contains basic quaternion functions such as quaternion normalization/complex conjugate/multiplication/division/inner product/rotation, interquaternion angle, random quaternion and interpolation between quaternions. -One functions defined in the Quaternions module is to determine the norm of a given quaternion. +One function defined in the Quaternions module is to determine the norm of a given quaternion. .. code-block:: python @@ -105,10 +96,7 @@ One functions defined in the Quaternions module is to determine the norm of a gi # check the precision print(q.dtype) -Note that the interface function e.g. 'cabs' have both single precision (_quat_norm) and double precision -(_quat_norm_d) routines 'glued together' in the Fortran script. Passing either single precision array (float32) or -double precision array (float64) will default into the first single precision output routine _quat_norm unless -the _quat_norm_d is explicitly defined. +Note that the interface function e.g. :python:`cabs` have both single precision (:python:`_quat_norm`) and double precision (:python:`_quat_norm_d`) routines 'glued together' in the Fortran script. Passing either single precision array (float32) or double precision array (float64) will default into the first single precision routine :python:`_quat_norm` (at the moment)unless the :python:`_quat_norm_d` is explicitly defined. .. code-block:: python @@ -122,10 +110,9 @@ the _quat_norm_d is explicitly defined. Rotations (rotations.f90) --------------------------------------------- -This Rotations module contains everything that has to do with rotations and conversions between rotations. -Details regarding this can be referred to the book [1]_ or a more recent tutorial paper [2]_ +This Rotations module contains everything that has to do with rotations and conversions between rotations. Details regarding this can be referred to the book [1]_ or a more recent tutorial paper [2]_ -For conversion from quaternion to orientation matrix, the qu2eu function can be called: +For conversion from quaternion to orientation matrix, the :python:`qu2eu` function can be called: .. code-block:: python @@ -136,13 +123,9 @@ For conversion from quaternion to orientation matrix, the qu2eu function can be # determining the corresponding orientation matrix of the arbitrary quaternion om = pyEMsoft.Rotations.qu2om(q) -To see if the lapack library is correctly linked, you can check if the om2ax routine outputs the correct value -because it uses lapack to calculate the eigenvalue of a given matrix. A specific unittest is added in the test_rotations.py file to for the verification of the lapack library. +To see if the lapack library is correctly linked, you can check if the :python:`om2ax` routine outputs the correct value because it uses lapack to calculate the eigenvalue of a given matrix. A specific unittest is added in the test_rotations.py file to for the verification of the lapack library. -In the rotations module, the init_orientation and init_orientaiton_om functions can be used to communicate with -all the rotation conversion functions in the rotations module. By providing a random quaterion and looping over -the rotation methods, all the rotation conversion functions can be tested. A double precision quaternion is defined -first for the following example (see unittest script test_rotations.py): +In the rotations module, the :python:`init_orientation` and :python:`init_orientaiton_om` functions can be used to communicate with all the rotation conversion functions in the rotations module. By providing a random quaterion and looping over the rotation methods, all the rotation conversion functions can be tested. A double precision quaternion is defined first for the following example (see unittest script test_rotations.py): .. code-block:: python @@ -170,18 +153,17 @@ first for the following example (see unittest script test_rotations.py): res = pyEMsoft.rotations._init_orientation_d(inputtype, i, rotcheck=False) print(i, 'to other types\n', res, '\n') -In addition, functions in the rotations module involving checking the bound and norm of a given type of rotation, coordinate -transformation of tensor and vectors (in both passive and active transformation), and a way of computing the geometrical mean +In addition, functions in the rotations module involving checking the bound and norm of a given type of rotation, coordinate transformation of tensor and vectors (passive or active transformation), and a way of computing the geometrical mean of a list of quaternions (including its standard deviation quaternion). Math (math.f90) ------------------------------------ -Math module is a collection of mathematical/numerical routines. +Math module is a collection of mathematical/numerical routines. For instance, mathematical operations to obtain matrix inverse, cross-product, matrix determinant, cubic roots, etc. Polar decomposition of a `deformation gradient tensor `_ can be carried out using the getpolardecomposition function in the math module. -Polar decomposition is one of the special cases (also the minvert function) where a matrix needs to be allocated in python but the results are filled in the fortran code. +Polar decomposition is one of the special cases (also the minvert function) where a matrix needs to be preallocated in python but the results are filled in the fortran code. The preallocation essentially defines an empty numpy array in Fortran order in memory. .. code-block:: python @@ -221,22 +203,22 @@ the Rmatrix or the Smatrix. In this case, Rmatrix is in a single, Fortran-style WRITEBACKIFCOPY : False UPDATEIFCOPY : False +Whenever the output variable is preallocated in python, the interface function such as :python:`minvert` can now switch between the single precision (:python:`_minvert`) and double precision routines (:python:`_minvert_d`), depending on the precision of the preallocated out variable. The try and except python function is wrapped around these routines of different precisions such that the prompted :python:`ValueError` is used as a switch. HDFsupport (HDFsupport.f90) ----------------------------------------- -This module contains some of the HDF5 helper routines that can be used to export or import HDF5 data set. The routines within HDFsupport -can already read/write EMsoft specific format data. +This module contains some of the HDF5 helper routines that can be used to export or import HDF5 data set. The routines within HDFsupport can already read/write EMsoft specific format data. This is probably more convenient than writing hdf5 specific module (see Example4_read_crystal_data) -One example routine from this module is able to save crystal data unitcell (Example 1 below shows how to create a crystal unitcell in python) -to a .xtal file in the default XtalFolder (EMsoft package configuration is required). +One example routine from this module is able to save crystal data unitcell (Example 1 below shows how to create a crystal unitcell in python) to a .xtal file in the default XtalFolder (EMsoft package configuration is required). .. code-block:: python # use routine from HDFsupport to save crystal data pyEMsoft.hdfsupport.savedatahdf(LatCell) -In addition, it is also possible to read crystal data from a .xtal file from the XtalFolder. +In addition, it is also possible to read crystal data from a .xtal file from the XtalFolder using :python:`crystaldata` funciton, written based on the :python:`readdatahdf` function from the same HDFsupport module. Within this :python:`crystaldata` function, addtional function :python:`calcmatrices` (from crystal.f90) is called to +computes the direct/reciprocal lattice/structure matrices for a given crystal. .. code-block:: python @@ -245,7 +227,7 @@ In addition, it is also possible to read crystal data from a .xtal file from the EBSDmod (EBSDmod.f90) ----------------------------------------- -This module contains several functions to work with EBSD related data. For instance, we can use it to read in a list of Euler angles, Monte Carlo data and master pattern data. +This module contains several functions to work with EBSD input and output data. For instance, we can use it to read in a list of Euler angles, Monte Carlo data and master pattern data. A list of Euler angles (.txt) needs to be first created in the EMsoft data folder (EMdatapathname). In the unittests file, the euler.txt is created, which contains two sets of Euler angles. @@ -264,7 +246,7 @@ A list of Euler angles (.txt) needs to be first created in the EMsoft data folde print(angles,'\n') -It is required to first open the hdf5 interface through the h5open_emsoft (hdfsupport module) before we can use these functions such as readebsdmasterpatternfile. +It is required to first open the hdf5 interface through the :python:`h5open_emsoft` (HDFsupport module) before we can use these functions such as :python:`readebsdmasterpatternfile`. .. code-block:: python @@ -296,10 +278,9 @@ It is required to first open the hdf5 interface through the h5open_emsoft (hdfsu Crystal (crystal.f90) ----------------------------------------- -The Crystal module includes distance and angle computations, coordinate transformations,normalizations, dot and cross products, generation of asymmetric positions; -also some routines that deal with reading lattice parameters and atom coordinates and such. +The Crystal module includes distance and angle computations, coordinate transformations, normalizations, dot and cross products, generation of asymmetric positions; also some routines that deal with reading lattice parameters and atom coordinates and such. -Given the space group of a crystal, we can find out the corresponding crystal system: +Given the space group of a crystal, we can find out the corresponding crystal system using the :python:`getemsoftxtalsystem`: .. code-block:: python @@ -308,24 +289,23 @@ Given the space group of a crystal, we can find out the corresponding crystal sy 1 -To display the periodic table, a displayelements function can be called from the crystal module. This routine simply uses message routine defined in io.f90 -to direclty print out strings to the terminal. +To display the periodic table, a :python:`displayelements` function can be called from the crystal module. This routine simply uses message routine defined in io.f90 +to directly print out strings to the terminal. .. code-block:: python # display the elements in the periodic table pyEMsoft.crystal.displayelements() -A more complicated scenario involves use of unitcell defined in the Typedefs module. The following example uses the unitcell as an input/output [(]intent(inout)] in the -getlatparm function to define crystal structure and lattice parameters/angles. +A more complicated scenario involves use of :python:`unitcell` defined in the Typedefs module. The following example uses the unitcell as an input/output [intent(inout)] in the +:python:`getlatparm` function to define crystal structure and lattice parameters/angles. .. code-block:: python LatCell=pyEMsoft.typedefs.unitcell() pyEMsoft.crystal.getlatparm(LatCell) -The calculatematrices routine computes the direct/reciprocal lattice/structure matrices for a given crystal. The crystal structure information -can be obtained in two ways: 1) either read from an exiting .xtal file (as in the unittest file), 2) or go through the steps in Example 1. + The crystal structure information can be obtained in two ways: 1) either read from an existing .xtal file (as in the unittest file), 2) or go through the steps in Example1_make_crystal.py. .. code-block:: python @@ -338,9 +318,7 @@ can be obtained in two ways: 1) either read from an exiting .xtal file (as in th # this function also uses readDataHDF (HDFsupport.f90) and CalcMatrices (crystal.f90) pyEMsoft.hdfsupport.crystaldata(LatCell) -In some cases, the direct lattice vectors may need to be transformed to reciprocal space or cartesian reference frame. The -transspace routine can be used to convert a vector between the three spaces with a single character as a switch -: direct space ('d'), reciprocal space ('r'), cartesian reference frame ('c'). +In some cases, the direct lattice vectors may need to be transformed to reciprocal space or cartesian reference frame. The :python:`transspace` routine can be used to convert a vector between the three spaces with a single character as a switch: direct space ('d'), reciprocal space ('r'), cartesian reference frame ('c'). .. code-block:: python @@ -356,7 +334,7 @@ transspace routine can be used to convert a vector between the three spaces with pyEMsoft.crystal.transspace(self.LatCell, input_vector, output_vector, inspace, outspace) print('The', input_vector, 'in the ', Tools.get_space_string(inspace), 'has been converted to', output_vector,'in', Tools.get_space_string(outspace), '\n') -If coordinate transformation is needed in a given space ('d','c' or 'r'), the trnascoor function can be called to defined a coordinate transformed +If coordinate transformation is needed in a given space ('d', 'c' or 'r'), the :python:`trnascoor` function can be called to defined a coordinate transformed vector from old to new ('on') or new to old ('no'). .. code-block:: python @@ -371,7 +349,7 @@ vector from old to new ('on') or new to old ('no'). pyEMsoft.crystal.transcoor(self.LatCell, output_vector, output_vector_t, trans_m, 'c', 'on') print('The output vector is', output_vector_t, 'under the transformation matrix\n', trans_m, '\n') -Furthermore, there is a module called milbrav to help with conversion between Miller indices and Miller-Bravais indices ('34' or '43' is the switch). +Furthermore, there is a module called :python:`milbrav` to help with conversion between Miller indices and Miller-Bravais indices ('34' or '43' is the switch). .. code-block:: python @@ -386,7 +364,7 @@ Furthermore, there is a module called milbrav to help with conversion between Mi print('Miller-Bravais indices', Miller_Bravais_index, 'is converted to Miller indices:', Miller_index,'\n') To obtain density of a crystal structure (and average atomic weight), we can first find all the atom positions in a unit cell (symmetry.calcpositions) and then use -calcdensity from the crystal module. +:python:`calcdensity` from the crystal module. .. code-block:: python @@ -399,31 +377,16 @@ calcdensity from the crystal module. print('unit cell volume', self.LatCell.vol) Moreover, the Crystal module contains many other useful tools to work with crystallography such vector normalization, length of vector, angle between -vectors, cross product of two vectors, etc for any given space. An example is given below in Example 2 to solve some of the problems in the textbook written by Marc De Graef [3]_ - - +vectors, cross product of two vectors, etc for any given space. An example is given below in Example2_basic_crystallography to solve some of the problems in the textbook written by Marc De Graef [3]_ Symmetry (symmetry.f90) ----------------------------------------- -The Symmetry module deals with all symmetry-related routines. This includes routines to generate -a space group based on the generator string; computation of orbits and families; computation of all -atoms in a single or multiple unit cells. +The Symmetry module deals with all symmetry-related routines. This includes routines to generate a space group based on the generator string; computation of orbits and families; computation of all atoms in a single or multiple unit cells. -In the corresponding unittest file (test_symmetry.py), the crystal structure information is directly read from an -exiting Ni.xtal file. +In the corresponding unittest file (test_symmetry.py), the crystal structure information is directly read from an existing Ni.xtal file (if this does not exist, you need to create one). -The Laue group number of a given space group can be determined with the following method: - -.. code-block:: python - - # see the test_symmetry.py script for how the LatCell is defined in this symmetry unittest class - # use the getlauegroupnumber function and predefined self.LatCell.sym_sgnum - LG_N = pyEMsoft.symmetry.getlauegroupnumber(self.LatCell.sym_sgnum) - print('The Laue group number of space group', self.LatCell.sym_sgnum, 'is', LG_N, '\n') - -For certain type of centering in atoms, some reflections become forbidden. The isgallowed function helps to determine whether -an input (integer array) reciprocal lattice vector is forbidden. +The :python:`isgallowed` function helps to determine whether an input (integer array) reciprocal lattice vector is forbidden due to precense of a certain type of atom centering. .. code-block:: python @@ -446,14 +409,18 @@ an input (integer array) reciprocal lattice vector is forbidden. print('Answer:', bool(pyEMsoft.symmetry.isgallowed(self.LatCell, g3)), '\n') +With the :python:`getpatternsymmetry` function, diffraction group, crystal point group, Laune group, projection diffraction group, and many 2D symmetry point groups (for bright field, dark field, whole pattern diffraction) can be accessed through some input variable e.g. crystal structure data (unitcell), crystal point group number, and zone axis ([uvw]). + +Another useful routine is the :python:`calcpositions`, which is used to calculate a list of atom positions for every atom type in the crystal. For example, this is used in :python:`calcdensity`. + Lambert (lambert.f90) ----------------------------------------- This module contains a number of projection functions for the modified Lambert projection between square lattice and 3D hemisphere [4]_, hexagonal lattice and 3D hemisphere, as well as the more complex mapping between a 3D cubic grid -and the unit quaternion hemisphere with positive scalar comoonent. In addition, there -are some other projections, such as the stereographic one. Each function is named +and the unit quaternion hemisphere with positive scalar component. In addition, there +are some other projections, such as the stereographic ones. Each function is named by the projection, the dimensionality of the starting grid, and the forward or inverse character. For each function, there is also a single precision and a double precision version, but we use the interface formalism to have only a single call. The Forward @@ -476,20 +443,15 @@ operations on those grids. print('3D coordinates', xyz, 'is transformed into 2D square coordinates', xy, '\n') -An example that involves use of the lambertsquaretosphere is given in the jupyter notebook file -to plot Kikuchi sphere. First, master lamber projection patterns (weighted by atom occupancy) -are weighted average based on Monte Carlo yield. 2D square coordinates are prescaled into the bounds -and are then converted into 3D hemispherical coordiantes for the southern and northern +An example that involves use of the :python:`lambertsquaretosphere` is given in the jupyter notebook file to plot Kikuchi sphere Example3_plot_Kikuchi_Sphere. First, master lamber projection patterns (weighted by atom occupancy) are weighted average based on Monte Carlo yield. 2D square coordinates are prescaled into the bounds and are then converted into 3D hemispherical coordiantes for the southern and northern hemispheress respectively. Diffraction (diffraction.f90) ----------------------------------------- -This modules contains many routines used in the dynamical diffraction. In the unittests script, two classes of -derived are used: unitcell (crystal) and gnode (diffraction related quantaties). Moreover, a crystal data -file is read from the XtalFolder. +This module contains many routines used in the dynamical diffraction. In the unittests script, two classes of derived are used: :python:`unitcell` (crystal) and :python:`gnode` (diffraction related quantaties). Moreover, an example crystal data file (Ni.xtal) is read from the XtalFolder. -Most of the physical quantaties related to dyanmical diffraction can be obtained through the following function: +Most of the physical quantaties related to dyanmical diffraction can be obtained through the following :python:`getvoltage` function, which communates to many other routines in the diffraction module. .. code-block:: python @@ -499,10 +461,10 @@ Most of the physical quantaties related to dyanmical diffraction can be obtained # this routine uses many other rountines such as getscatfac, CalcUcg, Calcwavelength pyEMsoft.diffraction.getvoltage(self.LatCell, self.rlp, True) -From the kinematical diffraction theory, the 2theta diffraction angle can be calculated for any diffracting plane: +From the kinematical diffraction theory, the 2 theta diffraction angle can be calculated for any diffracting plane: -.. code-block:: python +.. code-block:: python # calculate 2theta diffraction angle for a plane (hkl) Angle = pyEMsoft.diffraction.calcdiffangle(self.LatCell, 1, 1, 1) print('\nDiffraction angle for (111) is:', Angle, '(rad)\n') @@ -511,8 +473,7 @@ Examples ----------------------------------------- The Symmetry module in combination with some functions in the Crystal module. -A unitcell containing all the crystllographic information can be generated. User can either interact with the terminal -to populate the unitcell with crystallographic information or define the values in the unicell manually e.g. LatCell.xtal_system=1. +A :python:`unitcell` containing all the crystllographic information can be generated. User can either interact with the terminal to populate the unitcell with crystallographic information or define the values in the :python:`unicell` manually e.g. LatCell.xtal_system=1. Example 1: Make a crystal @@ -570,7 +531,7 @@ In the following example, several routines in the Crystal module are utilized to import numpy as np import math - # Examples here are taken from A text book written by Professor Marc De Graef: + # Examples here are taken from A textbook written by Professor Marc De Graef: # De Graef, M., 2003. Introduction to conventional transmission electron microscopy. # Cambridge University Press. diff --git a/Source/pyEMsoft/examples/Example5_image_filters.ipynb b/Source/pyEMsoft/examples/Example5_image_filters.ipynb new file mode 100644 index 00000000..3152965f --- /dev/null +++ b/Source/pyEMsoft/examples/Example5_image_filters.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "from skimage import data\n", + "import matplotlib.pyplot as plt \n", + "import sys\n", + "sys.path.append('../')\n", + "import pyEMsoft" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# original image\n", + "image = data.camera()\n", + "# apply poisson noise on the image\n", + "poisson_image=pyEMsoft.filters.applypoissonnoise(image, image.shape[0], image.shape[1], 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variable Type Data/Info\n", + "------------------------------------\n", + "data module kimage/data/__init__.py'>\n", + "image ndarray 512x512: 262144 elems, type `uint8`, 262144 bytes (256.0 kb)\n", + "np module kages/numpy/__init__.py'>\n", + "plt module es/matplotlib/pyplot.py'>\n", + "poisson_image ndarray 512x512: 262144 elems, type `float32`, 1048576 bytes (1.0 Mb)\n", + "pyEMsoft module \n", + "sys module \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the original image and the image with poisson noise\n", + "plt.figure\n", + "plt.subplots_adjust(wspace=0.2,hspace=0.3,top=0.85,left=0.08,right=0.92,bottom=0.08) \n", + "ax = plt.subplot(121)\n", + "plt.imshow(image,cmap='gray')\n", + "ax.set_aspect('equal')\n", + "ax.set_axis_off()\n", + "ax.set_title('Original',fontsize=8,y=1.02)\n", + "\n", + "ax = plt.subplot(122)\n", + "plt.imshow(poisson_image,cmap='gray')\n", + "ax.set_aspect('equal')\n", + "ax.set_axis_off()\n", + "ax.set_title('Poisson Noise',fontsize=8,y=1.02)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Entropy of original image: 4.883726119995117 Entropy of Poisson image: 5.165998935699463\n" + ] + } + ], + "source": [ + "# calculate the histograms of the two images above\n", + "image_histogram = pyEMsoft.filters.image_histogram(image.shape[0], image.shape[1], image)\n", + "poisson_image_histogram = pyEMsoft.filters.image_histogram(image.shape[0], image.shape[1], poisson_image)\n", + "# compute the Shannon entropy of the two images \n", + "image_entropy = pyEMsoft.filters.image_entropy(image_histogram)\n", + "poisson_image_entropy = pyEMsoft.filters.image_entropy(poisson_image_histogram)\n", + "print('Entropy of original image:', image_entropy, 'Entropy of Poisson image:', poisson_image_entropy)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the histograms\n", + "x=np.linspace(1,256,256)\n", + "plt.figure\n", + "ax = plt.subplot(121)\n", + "plt.bar(x,image_histogram)\n", + "ax.set_title('Original')\n", + "ax = plt.subplot(122)\n", + "plt.bar(x, poisson_image_histogram)\n", + "ax.set_title('Poisson Noise')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Joint image entropy: 8.832399368286133\n" + ] + } + ], + "source": [ + "# joint image histogram\n", + "joint_histogram = pyEMsoft.filters.image_jointhistogram(image.shape[0], image.shape[1], image, poisson_image)\n", + "# joint image entropy\n", + "joint_image_entropy = pyEMsoft.filters.image_jointentropy(joint_histogram)\n", + "print('Joint image entropy:', joint_image_entropy)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Joint Histogram')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the joint histogram (2D)\n", + "plt.figure\n", + "plt.imshow(joint_histogram, cmap='jet')\n", + "plt.title('Joint Histogram')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From b889604815dde29a574150b988c9b64d28f89853 Mon Sep 17 00:00:00 2001 From: Chaoyi Zhu Date: Mon, 30 Sep 2019 23:59:41 -0400 Subject: [PATCH 2/3] typo --- Source/pyEMsoft/docs/pyEMsoft.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/pyEMsoft/docs/pyEMsoft.rst b/Source/pyEMsoft/docs/pyEMsoft.rst index 8dd79ecd..fd8fc0ad 100644 --- a/Source/pyEMsoft/docs/pyEMsoft.rst +++ b/Source/pyEMsoft/docs/pyEMsoft.rst @@ -64,7 +64,7 @@ Typedefs (typedefs.f90) It contains definition of all variables and types for crystallographic computations in EMsoft. More specifically, it defines the unitcell type and the orientation type (class type objects in python) , as well as the main cell variable used by all crystallographic computations. -For instance, one important variable that is used extensively within EMsoft is the :python:`unitcell type`. +For instance, one important variable that is used extensively within EMsoft is the :python:`unitcell` type. .. code-block:: python From 2e22e0a666c3a2be5bd829824ca3141c20c41b34 Mon Sep 17 00:00:00 2001 From: Chaoyi Zhu Date: Tue, 1 Oct 2019 00:05:20 -0400 Subject: [PATCH 3/3] another typo --- Source/pyEMsoft/docs/pyEMsoft.rst | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Source/pyEMsoft/docs/pyEMsoft.rst b/Source/pyEMsoft/docs/pyEMsoft.rst index fd8fc0ad..3a833146 100644 --- a/Source/pyEMsoft/docs/pyEMsoft.rst +++ b/Source/pyEMsoft/docs/pyEMsoft.rst @@ -6,9 +6,7 @@ Executing EMsoft program in Python .. role:: bash(code) :language: bash -This is directly calling the built EMsoft functions from within Python. First, the :bash:`.../EMsoftBuild/Release/Bin` folder needs to be added to the path. -This is directly calling the built EMsoft functions from within Python. First, the :bash:`.../EMsoftBuild/Release/Bin` folder needs to be added to the path. -Second, complete the EMsoft package configuration following the `EMsoft Wiki Package Configuration `_. +This is directly calling the built EMsoft functions from within Python. First, the :bash:`.../EMsoftBuild/Release/Bin` folder needs to be added to the path. Second, complete the EMsoft package configuration following the `EMsoft Wiki Package Configuration `_. Then, create a Ni.xtal file as defined in `Crystal Data Entry Example `_. This crystal file will later be read into some of the unittests files.