fakecbed 0.5.1__tar.gz → 0.5.3__tar.gz

{fakecbed-0.5.1 → fakecbed-0.5.3}/.gitignore

@@ -21,8 +21,9 @@ tests/.coverage*
 # Ignore .pyc files.
 *.pyc
 
-# Ignore JSON files.
+# Ignore most JSON files.
 *.json
+!.zenodo.json
 
 # Ignore backup files.
 \#*#

fakecbed-0.5.3/.zenodo.json

@@ -0,0 +1,38 @@
+{
+    "creators": [
+	{
+	    "name": "Fitzpatrick, Matthew R. C.",
+	    "affiliation": "University of Victoria",
+	    "orcid": "0000-0001-5347-0629"
+	}
+    ],
+    "contributors": [
+        {
+            "name": "Blackburn, Arthur",
+            "affiliation": "University of Victoria",
+            "type": "Supervisor",
+	    "orcid": "0000-0001-6874-9729"
+        }
+    ],
+    "description": "<p>FakeCBED is Python library for generating quickly images that imitate convergent beam electron diffraction patterns.</p><p>This work was part-funded by the Natural Sciences and Engineering Research Council of Canada (NSERC), from Collaborative Research and Development grant (CRDPJ 543431), partnering with Hitachi High-Tech Canada.</p>",
+    "keywords": [
+	"pytorch",
+	"microscopy",
+	"diffraction",
+	"cbed",
+	"gpu"
+    ],
+    "license": {
+	"id": "GPL-3.0"
+    },
+    "publication_date": "2026-01-18",
+    "title": "FakeCBED",
+    "version": "0.5.3",
+    "access_right": "open",
+    "upload_type": "software",
+    "language": "eng",
+    "communities": [
+        {"identifier": "tem"},
+	{"identifier": "4d-stem"}
+    ]
+}

fakecbed-0.5.3/CITATION.cff

@@ -0,0 +1,30 @@
+cff-version: 1.2.0
+title: FakeCBED
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Matthew R. C.
+    family-names: Fitzpatrick
+    email: matthew.rc.fitzpatrick@gmail.com
+    affiliation: University of Victoria
+    orcid: 'https://orcid.org/0000-0001-5347-0629'
+repository-code: 'https://github.com/mrfitzpa/fakecbed'
+url: 'https://mrfitzpa.github.io/fakecbed/'
+abstract: >-
+  FakeCBED is Python library for generating quickly images that imitate
+  convergent beam electron diffraction patterns. 
+keywords:
+  - pytorch
+  - microscopy
+  - diffraction
+  - cbed
+  - gpu
+license: GPL-3.0
+version: 0.5.3
+date-released: '2026-01-18'
+identifiers:
+  - description: "This is the collection of archived snapshots of all versions."
+    type: doi
+    value: 10.5281/zenodo.18297325

{fakecbed-0.5.1 → fakecbed-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakecbed
-Version: 0.5.1
+Version: 0.5.3
 Summary: A Python library for generating quickly images that imitate convergent beam electron diffraction patterns.
 Author-email: Matthew Fitzpatrick <matthew.rc.fitzpatrick@gmail.com>
 Project-URL: Homepage, https://mrfitzpa.github.io/fakecbed
@@ -46,6 +46,7 @@ Dynamic: license-file
 [![PyPi Version](https://img.shields.io/pypi/v/fakecbed.svg)](https://pypi.org/project/fakecbed)
 [![Conda-Forge Version](https://img.shields.io/conda/vn/conda-forge/fakecbed.svg)](https://anaconda.org/conda-forge/fakecbed)
 [![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![DOI](https://img.shields.io/badge/DOI-10.5281/zenodo.18297325-blue.svg)](https://doi.org/10.5281/zenodo.18297325)
 
 `fakecbed` is a Python library for generating quickly images that imitate
 convergent beam electron diffraction patterns.

{fakecbed-0.5.1 → fakecbed-0.5.3}/README.md

@@ -6,6 +6,7 @@
 [![PyPi Version](https://img.shields.io/pypi/v/fakecbed.svg)](https://pypi.org/project/fakecbed)
 [![Conda-Forge Version](https://img.shields.io/conda/vn/conda-forge/fakecbed.svg)](https://anaconda.org/conda-forge/fakecbed)
 [![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![DOI](https://img.shields.io/badge/DOI-10.5281/zenodo.18297325-blue.svg)](https://doi.org/10.5281/zenodo.18297325)
 
 `fakecbed` is a Python library for generating quickly images that imitate
 convergent beam electron diffraction patterns.

{fakecbed-0.5.1 → fakecbed-0.5.3}/docs/build_docs.py

@@ -98,16 +98,28 @@ _mvdir("./_build/html/", "./pages/")
 
 cmd_output_as_bytes = subprocess.check_output("git tag", shell=True)
 cmd_output = cmd_output_as_bytes.decode("utf-8")
-tags = cmd_output.rstrip("\n").split("\n")
+tag_set = cmd_output.rstrip("\n").split("\n")
 
-pattern = r"v[0-9]+\.[0.9]+\.[0-9]+"
-release_tags = tuple(tag for tag in tags if re.fullmatch(pattern, tag))
+pattern = r"v[0-9]+\.[0-9]+\.[0-9]+"
+release_tag_set = tuple(tag for tag in tag_set if re.fullmatch(pattern, tag))
 
-for tag in release_tags:
+version_subset = dict()
+for tag in release_tag_set:
     version = tag[1:]
-    language = "en"
-    _build_doc(version, language, tag)
-    _mvdir("./_build/html/", "./pages/"+version+"/"+language+"/")
+    major, minor, patch = [int(int_as_str) for int_as_str in version.split(".")]
+    version_subset.setdefault(major, dict())
+    version_subset[major].setdefault(minor, 0)
+    version_subset[major][minor] = max(version_subset[major][minor], patch)
+
+for major in sorted(version_subset.keys()):
+    for minor in sorted(version_subset[major].keys()):
+        patch = version_subset[major][minor]
+        version = "{}.{}.{}".format(major, minor, patch)
+        tag = "v"+version
+        major_minor = "{}.{}".format(major, minor)
+        language = "en"
+        _build_doc(version, language, tag)
+        _mvdir("./_build/html/", "./pages/"+major_minor+"/"+language+"/")
 
 subprocess.run("cd ..; pip install .; cd docs", shell=True)
 _mvdir("./pages/", "../pages/")

{fakecbed-0.5.1 → fakecbed-0.5.3}/docs/conf.py

@@ -172,33 +172,54 @@ build_all_docs = os.environ.get("build_all_docs", None)
 pages_root = os.environ.get("pages_root", "")
 
 if build_all_docs is not None:
-    current_language = os.environ.get("current_language")
+    current_language = os.environ.get("current_language")    
     current_version = os.environ.get("current_version")
 
+    major, minor, patch = ((None, None, None)
+                           if (current_version == "latest")
+                           else current_version.split("."))
+    current_major_minor = ("latest"
+                           if (major is None)
+                           else "{}.{}".format(major, minor))
+
     html_context = {"current_language" : current_language,
                     "languages" : [],
-                    "current_version" : current_version,
+                    "current_version" : current_major_minor,
                     "versions" : []}
 
-    if (current_version == "latest"):
+    if current_version == "latest":
         html_context["languages"].append(["en", pages_root])
 
-    if (current_language == "en"):
+    if current_language == "en":
         html_context["versions"].append(["latest", pages_root])
 
     cmd_output_as_bytes = subprocess.check_output("git tag", shell=True)
     cmd_output = cmd_output_as_bytes.decode("utf-8")
-    tags = cmd_output.rstrip("\n").split("\n")
+    tag_set = cmd_output.rstrip("\n").split("\n")
 
-    pattern = r"v[0-9]+\.[0.9]+\.[0-9]+"
-    release_tags = tuple(tag for tag in tags if re.fullmatch(pattern, tag))
+    pattern = r"v[0-9]+\.[0-9]+\.[0-9]+"
+    release_tag_set = tuple(tag
+                            for tag
+                            in tag_set
+                            if re.fullmatch(pattern, tag))
 
-    if (current_version != "latest"):
+    version_subset = dict()
+    for tag in release_tag_set:
+        version = tag[1:]
+        major, minor, patch = [int(int_as_str)
+                               for int_as_str
+                               in version.split(".")]
+        version_subset.setdefault(major, dict())
+        version_subset[major].setdefault(minor, 0)
+        version_subset[major][minor] = max(version_subset[major][minor], patch)
+
+    if current_version != "latest":
         language = "en"
-        path = pages_root+"/"+current_version+"/"+language
+        path = pages_root+"/"+current_major_minor+"/"+language
         html_context["languages"].append([language, path])
 
-    for tag in release_tags:
-        version = tag[1:]
-        path = pages_root+"/"+version+"/"+current_language
-        html_context["versions"].append([version, path])
+    for major in sorted(version_subset.keys()):
+        for minor in sorted(version_subset[major].keys()):
+            major_minor = "{}.{}".format(major, minor)
+            path = pages_root+"/"+major_minor+"/"+current_language
+            html_context["versions"].append([major_minor, path])

{fakecbed-0.5.1 → fakecbed-0.5.3}/docs/index.rst

@@ -1,3 +1,8 @@
+.. meta::
+   :google-site-verification: kxE4d_wW0ikuxlKuVCgIxNZT81VDOxKWJ7R9mbTnvKA
+
+
+
 Fake Convergence Beam Electron Diffraction (FakeCBED)
 =====================================================
 

{fakecbed-0.5.1 → fakecbed-0.5.3}/fakecbed/discretized.py

@@ -635,14 +635,17 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
 
     Let :math:`u_{x}` and :math:`u_{y}` be the fractional horizontal and
     vertical coordinates, respectively, of a point in an undistorted image,
-    where :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)` is the bottom left
-    corner of the image. Secondly, let :math:`q_{x}` and :math:`q_{y}` be the
+    where :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of the
+    undistorted image. Secondly, let :math:`q_{x}` and :math:`q_{y}` be the
     fractional horizontal and vertical coordinates, respectively, of a point in
     a distorted image, where :math:`\left(q_{x},q_{y}\right)=\left(0,0\right)`
-    is the bottom left corner of the image. When users specify the distortion
-    model, represented by an instance of the class
-    :class:`distoptica.DistortionModel`, they also specify a coordinate
-    transformation, :math:`\left(T_{⌑;x}\left(u_{x},u_{y}\right),
+    :math:`\left[\left(q_{x},q_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of the
+    distorted image.. When users specify the distortion model, represented by an
+    instance of the class :class:`distoptica.DistortionModel`, they also specify
+    a coordinate transformation, :math:`\left(T_{⌑;x}\left(u_{x},u_{y}\right),
     T_{⌑;y}\left(u_{x},u_{y}\right)\right)`, which maps a given coordinate pair
     :math:`\left(u_{x},u_{y}\right)` to a corresponding coordinate pair
     :math:`\left(q_{x},q_{y}\right)`, and implicitly a right-inverse to said
@@ -867,7 +870,18 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         \end{cases}
         :label: LD_I_MF__1
 
-    4. For :math:`0\le k<N_{\text{D}}`, calculate
+    4. Calculate
+
+    .. math ::
+        \mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}\leftarrow
+        \mathcal{I}_{\text{TDS}}\left(T_{\square;x}\left(
+        q_{\mathring{\mathcal{I}};x;j},
+        q_{\mathring{\mathcal{I}};y;i}\right),
+        T_{\square;y}\left(q_{\mathring{\mathcal{I}};x;j},
+        q_{\mathring{\mathcal{I}};y;i}\right)\right),
+        :label: HD_I_CBED__1
+
+    5. For :math:`0\le k<N_{\text{D}}`, calculate
 
     .. math ::
         \mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}&
@@ -876,7 +890,7 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         q_{\mathring{\mathcal{I}};x;j},q_{\mathring{\mathcal{I}};y;i}\right),
         T_{\square;y}\left(q_{\mathring{\mathcal{I}};x;j},
         q_{\mathring{\mathcal{I}};y;i}\right)\right),
-        :label: HD_I_CBED__1
+        :label: HD_I_CBED__2
 
     .. math ::
         \mathring{\mathcal{I}}_{k;\text{DS};⌑;i,j}\leftarrow
@@ -905,7 +919,7 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         \mathcal{I}_{\text{DOM};⌑;n,m}+\mathcal{I}_{k;\text{DS};⌑;n,m}.
         :label: LD_I_DOM__2
 
-    5. Calculate
+    6. Calculate
 
     .. math ::
         \mathcal{I}_{\text{DOM};⌑;n,m}\leftarrow
@@ -914,7 +928,7 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         \mathcal{I}_{\text{DOM};⌑;n,m}.
         :label: LD_I_DOM__3
 
-    6. For :math:`0\le k<N_{\text{M}}`, calculate
+    7. For :math:`0\le k<N_{\text{M}}`, calculate
 
     .. math ::
         \mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}&
@@ -923,9 +937,9 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         q_{\mathring{\mathcal{I}};x;j},q_{\mathring{\mathcal{I}};y;i}\right),
         T_{\square;y}\left(q_{\mathring{\mathcal{I}};x;j},
         q_{\mathring{\mathcal{I}};y;i}\right)\right).
-        :label: HD_I_CBED__2
+        :label: HD_I_CBED__3
 
-    7. Calculate
+    8. Calculate
 
     .. math ::
         \mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}\leftarrow
@@ -933,21 +947,21 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         q_{\mathring{\mathcal{I}};x;j},
         q_{\mathring{\mathcal{I}};y;i}\right)\right)
         \left|\mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}\right|.
-        :label: HD_I_CBED__3
+        :label: HD_I_CBED__4
 
-    8. Apply average pooling to
+    9. Apply average pooling to
     :math:`\mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}` with a kernel of
     dimensions :math:`\left(N_{\mathring{\mathcal{I}};y}/N_{\mathcal{I};y},
     N_{\mathring{\mathcal{I}};x}/N_{\mathcal{I};x}\right)`, and store the result
     in :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`.
 
-    9. Apply a Gaussian filter to :math:`\mathcal{I}_{\text{CBED};⌑;n,m}` that
+    10. Apply a Gaussian filter to :math:`\mathcal{I}_{\text{CBED};⌑;n,m}` that
     is identical in outcome to that implemented by the function
     :func:`scipy.ndimage.gaussian_filter`, with ``sigma`` set to
     ``gaussian_filter_std_dev`` and ``truncate`` set to ``4``, and store the
     result in :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`.
 
-    10. Calculate
+    11. Calculate
 
     .. math ::
         k_{\text{I};1}\leftarrow
@@ -961,18 +975,18 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         k_{\text{I};2}\leftarrow k_{\text{I};1}+N_{\text{DPW}}-1.
         :label: k_I_2__1
 
-    11. If ``apply_shot_noise`` is set to ``True``, then apply shot/Poisson
+    12. If ``apply_shot_noise`` is set to ``True``, then apply shot/Poisson
     noise to :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`, and store the result in
     :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`.
 
-    12. If :math:`N_{\text{DPW}}>0`, then inpaint the pixels in the rows indexed
+    13. If :math:`N_{\text{DPW}}>0`, then inpaint the pixels in the rows indexed
     from :math:`k_{\text{I};1}` to :math:`k_{\text{I};2}` and the columns
     indexed from :math:`k_{\text{I};1}` to :math:`k_{\text{I};2}` of the image
     :math:`\mathcal{I}_{\text{CBED};⌑;n,m}` using the function
     :func:`skimage.restoration.inpaint_biharmonic`, and store the result in
     :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`.
 
-    13. Calculate
+    14. Calculate
 
     .. math ::
         \mathcal{I}_{\text{CBED};⌑;n,m}\leftarrow
@@ -981,25 +995,25 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         \mathcal{I}_{\text{CBED};⌑;n,m}.
         :label: LD_I_CBED__1
 
-    14. Update pixels of :math:`\mathcal{I}_{\text{CBED};⌑;n,m}` at pixel
+    15. Update pixels of :math:`\mathcal{I}_{\text{CBED};⌑;n,m}` at pixel
     locations specified by ``cold_pixels`` to the value of zero.
 
-    15. Apply min-max normalization of :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`,
+    16. Apply min-max normalization of :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`,
     and store result in :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`.
 
-    16. Calculate
+    17. Calculate
 
     .. math ::
         \mathcal{I}_{\text{CS};⌑;n,m}\leftarrow1
         -\mathcal{I}_{\text{MF};⌑;n,m}\mathcal{I}_{\text{OI};⌑;n,m}.
         :label: LD_I_CS__1
 
-    17. Convolve a :math:`3 \times 3` filter of ones over a symmetrically unity-padded
+    18. Convolve a :math:`3 \times 3` filter of ones over a symmetrically unity-padded
     :math:`\mathcal{I}_{\text{CS};⌑;n,m}` to yield an output matrix with the
     same dimensions of :math:`\mathcal{I}_{\text{CBED};⌑;n,m}`, and store said
     output matrix in :math:`\mathcal{I}_{\text{CS};⌑;n,m}`.
 
-    18. For :math:`0\le k<N_{\text{D}}`, calculate
+    19. For :math:`0\le k<N_{\text{D}}`, calculate
 
     .. math ::
         \mathcal{I}_{k;\text{DCM};⌑;n,m}\leftarrow
@@ -1008,8 +1022,8 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
 
     .. math ::
         \Omega_{k;\text{DCR};⌑}\leftarrow\begin{cases}
-        \text{True}, & \text{if }
-        \left(\sum_{n,m}\mathcal{I}_{k;\text{DCM};⌑;n,m}\neq0\right)\bigparallel
+        \text{True}, & \text{if }\left.\left(\sum_{n,m}
+        \mathcal{I}_{k;\text{DCM};⌑;n,m}\neq0\right)\right\Vert
         \left(\sum_{n,m}\mathcal{I}_{k;\text{DS};⌑;n,m}=0\right),\\
         \text{False}, & \text{otherwise},
         \end{cases}
@@ -3493,8 +3507,8 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
             N_{\mathcal{I};x}=N_{\mathcal{I};y},
             :label: N_I_x_eq_N_I_y__2
 
-        Furthermore, let :math:`N_{\text{max-iter}}=30, and let N_{\text{SS}}`
-        be ``disk_boundary_sample_size``.
+        Furthermore, let :math:`N_{\text{max-iter}}=30`, and let
+        :math:`N_{\text{SS}}` be ``disk_boundary_sample_size``.
 
         Next, let :math:`\partial S_{\text{PDS};x;l}` and :math:`\partial
         S_{\text{PDS};y;l}` denote

{fakecbed-0.5.1 → fakecbed-0.5.3}/fakecbed/shapes.py

@@ -36,12 +36,16 @@ nonnegative.
 
 Let :math:`u_{x}` and :math:`u_{y}` be the fractional horizontal and vertical
 coordinates, respectively, of a point in an undistorted image, where
-:math:`\left(u_{x},u_{y}\right)=\left(0,0\right)` is the bottom left corner of
-the image. Secondly, let :math:`q_{x}` and :math:`q_{y}` be the fractional
+:math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+:math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower left
+[upper right] corner of the lower left [upper right] pixel of the undistorted
+image. Secondly, let :math:`q_{x}` and :math:`q_{y}` be the fractional
 horizontal and vertical coordinates, respectively, of a point in a distorted
-image, where :math:`\left(q_{x},q_{y}\right)=\left(0,0\right)` is the bottom
-left corner of the image. When users specify a distortion model, represented by
-an :obj:`distoptica.DistortionModel` object, they also specify a coordinate
+image, where :math:`\left(q_{x},q_{y}\right)=\left(0,0\right)`
+:math:`\left[\left(q_{x},q_{y}\right)=\left(1,1\right)\right]` is the lower left
+[upper right] corner of the lower left [upper right] pixel of the distorted
+image. When users specify a distortion model, represented by an
+:obj:`distoptica.DistortionModel` object, they also specify a coordinate
 transformation which maps a given coordinate pair
 :math:`\left(u_{x},u_{y}\right)` to a corresponding coordinate pair
 :math:`\left(q_{x},q_{y}\right)`, and implicitly a right-inverse to said
@@ -277,10 +281,11 @@ class BaseShape(fancytypes.PreSerializableAndUpdatable):
         r"""Evaluate the intensity pattern of the undistorted shape.
 
         Let :math:`u_{x}` and :math:`u_{y}` be the fractional horizontal and
-        vertical coordinates, respectively, of a point in an undistorted image.
-        We adopt the convention where the fractional coordinate pair
-        :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)` is the bottom left
-        corner of an image.
+        vertical coordinates, respectively, of a point in an undistorted image,
+        where :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+        :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the
+        lower left [upper right] corner of the lower left [upper right] pixel of
+        the undistorted image.
 
         Parameters
         ----------
@@ -452,14 +457,23 @@ class Circle(BaseShape):
 
     .. math ::
         \mathcal{I}_{\text{C}}\left(u_{x},u_{y}\right)=
-        A_{\text{C}}\Theta\left(R_{\text{C}}
-        -\sqrt{\left(u_{x}-u_{x;c;\text{C}}\right)^{2}
-        +\left(u_{y}-u_{y;c;\text{C}}\right)^{2}}\right),
+        A_{\text{C}}\Theta\left(R_{\text{C}}-u_{r;\text{C}}\right),
         :label: intensity_pattern_of_circle__1
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
-    coordinates of the undistorted intensity pattern of the circle respectively,
-    and :math:`\Theta\left(\cdots\right)` is the Heaviside step function.
+    coordinates of the undistorted intensity pattern of the circle respectively;
+    :math:`\Theta\left(\cdots\right)` is the Heaviside step function; and
+
+    .. math ::
+        u_{r;\text{C}}=\sqrt{\left(u_{x}-u_{x;c;\text{C}}\right)^{2}
+        +\left(u_{y}-u_{y;c;\text{C}}\right)^{2}};
+        :label: u_r_C__1
+
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
 
     Parameters
     ----------
@@ -567,8 +581,10 @@ class Circle(BaseShape):
         delta_u_y = u_y-u_y_c
 
         u_r = torch.sqrt(delta_u_x*delta_u_x + delta_u_y*delta_u_y)
+
+        one = torch.tensor(1.0, device=u_r.device)
         
-        result = A * (u_r <= R)
+        result = A * torch.heaviside(R-u_r, one)
 
         return result
 
@@ -670,27 +686,47 @@ class Ellipse(BaseShape):
 
     .. math ::
         \mathcal{I}_{\text{E}}\left(u_{x},u_{y}\right)=
-        A_{\text{E}}\Theta\left(\Theta_{\arg;\text{E}}\left(u_{x},
-        u_{y}\right)\right),
+        A_{\text{E}}\Theta\left(
+        R_{\text{E}}\left(u_{\theta;\text{E}}\right)-u_{r;\text{E}}\right),
         :label: intensity_pattern_of_ellipse__1
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
     coordinates of the undistorted intensity pattern of the ellipse
-    respectively, :math:`\Theta\left(\cdots\right)` is the Heaviside step
-    function, and
+    respectively; :math:`\Theta\left(\cdots\right)` is the Heaviside step
+    function;
 
     .. math ::
-        &\Theta_{\arg;\text{E}}\left(u_{x},u_{y}\right)\\&\quad=
-        \left\{ 1-e_{\text{E}}^{2}\right\} a_{\text{E}}^{2}\\
-        &\quad\quad-\left\{ 1-e_{\text{E}}^{2}\right\} 
-        \left\{ \left[u_{x}-u_{x;c;\text{E}}\right]
-        \cos\left(\theta_{\text{E}}\right)
-        -\left[u_{y}-u_{y;c;\text{E}}\right]
-        \sin\left(\theta_{\text{E}}\right)\right\} ^{2}\\
-        &\quad\quad-\left\{ \left[u_{x}-
-        u_{x;c;\text{E}}\right]\sin\left(\theta_{\text{E}}\right)+\left[u_{y}-
-        u_{y;c;\text{E}}\right]\cos\left(\theta_{\text{E}}\right)\right\}^{2}.
-        :label: ellipse_support_arg__1
+        u_{r;\text{E}}=\sqrt{\left(u_{x}-u_{x;c;\text{E}}\right)^{2}
+        +\left(u_{y}-u_{y;c;\text{E}}\right)^{2}};
+        :label: u_r_E__1
+
+    .. math ::
+        u_{\theta;\text{E}}=
+        \tan^{-1}\left(\frac{u_{y}
+        -u_{y;c;\text{E}}}{u_{x}-u_{x;c;\text{E}}}\right);
+        :label: u_theta_E__1
+
+    and
+
+    .. math ::
+        R_{\text{E}}\left(u_{\theta;\text{E}}\right)=a_{\text{E}}
+        \sqrt{\frac{1-e_{\text{E}}^{2}}{1
+        -\left\{ e_{\text{E}}\cos\left(u_{\theta;\text{E}}
+        +\theta_{\text{E}}\right)\right\} ^{2}}}.
+        :label: R_E__1
+
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
+    Note that if :math:`\theta_{\text{E}}=0`, then the longest chord of the
+    ellipse is horizontal. Let us refer to this ellipse with
+    :math:`\theta_{\text{E}}=0` as the "reference shape". If
+    :math:`\theta_{\text{E}} \neq 0`, then the ellipse is equal to the reference
+    shape after rotating the latter shape clockwise by :math:`\theta_{\text{E}}`
+    about its center.
 
     Parameters
     ----------
@@ -802,42 +838,33 @@ class Ellipse(BaseShape):
 
 
     def _eval(self, u_x, u_y):
-        A = self._intra_shape_val
-        support_arg = self._calc_support_arg(u_x, u_y)
-        one = torch.tensor(1.0, device=support_arg.device)
-        result = A * torch.heaviside(support_arg, one)
-
-        return result
-
-
-
-    def _calc_support_arg(self, u_x, u_y):
         u_x_c, u_y_c = self._center
         a = self._semi_major_axis
         e = self._eccentricity
-        theta = torch.tensor(self._rotation_angle, dtype=u_x.dtype)
+        rotation_angle = self._rotation_angle
+        A = self._intra_shape_val
 
         delta_u_x = u_x-u_x_c
         delta_u_y = u_y-u_y_c
 
-        e_sq = e*e
-        a_sq = a*a
-        b_sq = (1-e_sq)*a_sq
+        u_r = torch.sqrt(delta_u_x*delta_u_x + delta_u_y*delta_u_y)
+        u_theta = torch.atan2(delta_u_y, delta_u_x) % (2*np.pi)
+
+        theta = torch.tensor(rotation_angle, dtype=u_r.dtype)
+        
+        u_theta_shifted = u_theta + theta
+        cos_u_theta_shifted = torch.cos(u_theta_shifted)
 
-        cos_theta = torch.cos(theta)
-        sin_theta = torch.sin(theta)
+        e_sq = e*e
 
-        delta_u_x_prime = delta_u_x*cos_theta - delta_u_y*sin_theta
-        delta_u_x_prime_sq = delta_u_x_prime*delta_u_x_prime
+        R = a * torch.sqrt((1 - e_sq)
+                           / (1 - e_sq*cos_u_theta_shifted*cos_u_theta_shifted))
 
-        delta_u_y_prime = delta_u_x*sin_theta + delta_u_y*cos_theta
-        delta_u_y_prime_sq = delta_u_y_prime*delta_u_y_prime
+        one = torch.tensor(1.0, device=u_theta.device)
 
-        support_arg = (b_sq
-                       - (b_sq/a_sq)*delta_u_x_prime_sq
-                       - delta_u_y_prime_sq)
+        result = A * torch.heaviside(R-u_r, one)
 
-        return support_arg
+        return result
 
 
 
@@ -945,7 +972,7 @@ class Peak(BaseShape):
         :label: intensity_pattern_of_peak__1
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
-    coordinates of the undistorted intensity pattern of the peak respectively,
+    coordinates of the undistorted intensity pattern of the peak respectively;
 
     .. math ::
         F_{\beta;\text{P}}\left(\omega\right)=\begin{cases}
@@ -987,6 +1014,12 @@ class Peak(BaseShape):
 
     with :math:`\Theta\left(\cdots\right)` being the Heaviside step function.
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     center : `array_like` (`float`, shape=(``2``,)), optional
@@ -1298,7 +1331,7 @@ class Band(BaseShape):
         :label: intensity_pattern_of_band__1
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
-    coordinates of the undistorted intensity pattern of the band respectively,
+    coordinates of the undistorted intensity pattern of the band respectively;
 
     .. math ::
         \Theta\left(\omega\right)=\begin{cases}
@@ -1316,7 +1349,7 @@ class Band(BaseShape):
     .. math ::
         d_{\text{B};1}\left(u_{x},u_{y}\right)=
         \frac{a_{\text{B};1}u_{x}+b_{\text{B};1}u_{y}
-        +c_{\text{B};1}}{\sqrt{a_{\text{B};1}^{2}+b_{\text{B};1}^{2}}};
+        +c_{\text{B};1}}{\sqrt{a_{\text{B};1}^{2}+b_{\text{B};1}^{2}}},
         :label: d_1_of_band__1
 
     with
@@ -1400,6 +1433,12 @@ class Band(BaseShape):
         \end{cases}
         :label: c_2_of_band__1
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     end_pt_1 : `array_like` (`float`, shape=(``2``,)), optional
@@ -1697,11 +1736,11 @@ class PlaneWave(BaseShape):
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
     coordinates of the undistorted intensity pattern of the plane wave
-    respectively,
+    respectively;
 
     .. math ::
         k_{x;\text{PW}}=\frac{2\pi}{\lambda_{\text{PW}}}
-        \cos\left(\theta_{\text{PW}}\right),
+        \cos\left(\theta_{\text{PW}}\right);
         :label: k_x_of_plane_wave__1
 
     and
@@ -1711,6 +1750,12 @@ class PlaneWave(BaseShape):
         \sin\left(\theta_{\text{PW}}\right).
         :label: k_y_of_plane_wave__1
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     amplitude : `float`, optional        
@@ -1944,12 +1989,12 @@ class Arc(BaseShape):
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
     coordinates of the undistorted intensity pattern of the circular arc
-    respectively, :math:`\Theta\left(\cdots\right)` is the Heaviside step
-    function,
+    respectively; :math:`\Theta\left(\cdots\right)` is the Heaviside step
+    function;
 
     .. math ::
         u_{r;\text{A}}=\sqrt{\left(u_{x}-u_{x;c;\text{A}}\right)^{2}
-        +\left(u_{y}-u_{y;c;\text{A}}\right)^{2}},
+        +\left(u_{y}-u_{y;c;\text{A}}\right)^{2}};
         :label: u_r_UA__1
 
     and
@@ -1960,6 +2005,12 @@ class Arc(BaseShape):
         -\theta_{\text{A}}\right\} \mod 2\pi.
         :label: u_theta_UA__1
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     center : `array_like` (`float`, shape=(``2``,)), optional
@@ -2218,24 +2269,24 @@ class GenericBlob(BaseShape):
     .. math ::
         \mathcal{I}_{\text{GB}}\left(u_{x},u_{y}\right)=
         A_{\text{GB}}\Theta\left(
-        R_{\text{GB}}\left(u_{\theta;\text{UA}}\right)-u_{r;\text{GB}}\right),
+        R_{\text{GB}}\left(u_{\theta;\text{GB}}\right)-u_{r;\text{GB}}\right),
         :label: intensity_pattern_of_generic_blob__1
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
     coordinates of the undistorted intensity pattern of the generic blob
-    respectively, :math:`\Theta\left(\cdots\right)` is the Heaviside step
-    function,
+    respectively; :math:`\Theta\left(\cdots\right)` is the Heaviside step
+    function;
 
     .. math ::
         u_{r;\text{GB}}=\sqrt{\left(u_{x}-u_{x;c;\text{GB}}\right)^{2}
         +\left(u_{y}-u_{y;c;\text{GB}}\right)^{2}};
-        :label: u_r_UGB__1
+        :label: u_r_GB__1
 
     .. math ::
         u_{\theta;\text{GB}}=
         \tan^{-1}\left(\frac{u_{y}
         -u_{y;c;\text{GB}}}{u_{x}-u_{x;c;\text{GB}}}\right);
-        :label: u_theta_UGB__1
+        :label: u_theta_GB__1
 
     and
 
@@ -2244,20 +2295,26 @@ class GenericBlob(BaseShape):
         D_{\text{GB};0}\\&\quad\mathop{+}\min\left(1,N_{\text{GB}}\right)
         \sum_{n=1}^{N_{\text{GB}}}D_{\text{GB};n}
         \cos\left(nu_{\theta;\text{GB}}-\phi_{\text{GB};n-1}\right),
-        :label: R_UGB__1
+        :label: R_GB__1
 
     with
 
     .. math ::
         D_{\text{GB};n} \ge 0,
         \quad\forall n\in\left\{ 1,\ldots,N_{\text{GB}}\right\},
-        :label: D_UGB_n__1
+        :label: D_GB_n__1
 
     and
 
     .. math ::
         D_{\text{GB};0}>\sum_{n=1}^{N_{\text{GB}}}D_{\text{GB};n}.
-        :label: D_UGB_n__2
+        :label: D_GB_n__2
+
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
 
     Parameters
     ----------
@@ -2377,12 +2434,12 @@ class GenericBlob(BaseShape):
 
         N = len(phi)
 
-        one = torch.tensor(1.0, device=u_x.device)
-
         R = D[0]*torch.ones_like(u_theta)
         for n in range(1, N+1):
             R += D[n]*torch.cos(n*u_theta - phi[n-1])
 
+        one = torch.tensor(1.0, device=u_r.device)
+
         result = A * torch.heaviside(R-u_r, one)
 
         return result
@@ -2555,11 +2612,11 @@ class Orbital(BaseShape):
 
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
     coordinates of the undistorted intensity pattern of the orbital
-    respectively,
+    respectively;
 
     .. math ::
         u_{r;\text{O}}=\sqrt{\left(u_{x}-u_{x;c;\text{O}}\right)^{2}
-        +\left(u_{y}-u_{y;c;\text{O}}\right)^{2}},
+        +\left(u_{y}-u_{y;c;\text{O}}\right)^{2}};
         :label: u_r_O__1
 
     .. math ::
@@ -2594,6 +2651,12 @@ class Orbital(BaseShape):
     u_{\phi;\text{O}}\right)` is the spherical harmonic function of degree
     :math:`l_{\text{O}}` and order :math:`m_{\text{O}}`.
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     center : `array_like` (`float`, shape=(``2``,)), optional
@@ -3037,6 +3100,12 @@ class Lune(BaseShape):
     where :math:`u_{x}` and :math:`u_{y}` are fractional horizontal and vertical
     coordinates of the undistorted intensity pattern of the lune respectively.
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     bg_ellipse : :class:`fakecbed.shapes.Circle` | :class:`fakecbed.shapes.Ellipse` | `None`, optional
@@ -3293,6 +3362,12 @@ class NonuniformBoundedShape(BaseShape):
     coordinates of the undistorted intensity pattern of the nonuniform bounded
     shape respectively.
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     support : :class:`fakecbed.shapes.Circle` | :class:`fakecbed.shapes.Ellipse` | :class:`fakecbed.shapes.Band` | :class:`fakecbed.shapes.Arc` | :class:`fakecbed.shapes.GenericBlob` | :class:`fakecbed.shapes.Lune` | `None`, optional

{fakecbed-0.5.1 → fakecbed-0.5.3}/fakecbed/tds.py

@@ -142,6 +142,12 @@ class Model(fakecbed.shapes.BaseShape):
     coordinates of the undistorted intensity pattern of the TDS model
     respectively.
 
+    By fractional coordinates, we mean that
+    :math:`\left(u_{x},u_{y}\right)=\left(0,0\right)`
+    :math:`\left[\left(u_{x},u_{y}\right)=\left(1,1\right)\right]` is the lower
+    left [upper right] corner of the lower left [upper right] pixel of an image
+    of the undistorted intensity pattern.
+
     Parameters
     ----------
     peaks : `array_like` (`fakecbed.shapes.Peak`, ndim=1), optional

{fakecbed-0.5.1 → fakecbed-0.5.3}/fakecbed/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.1'
-__version_tuple__ = version_tuple = (0, 5, 1)
+__version__ = version = '0.5.3'
+__version_tuple__ = version_tuple = (0, 5, 3)
 
-__commit_id__ = commit_id = 'g10cabd158'
+__commit_id__ = commit_id = 'gdd6869a60'

{fakecbed-0.5.1 → fakecbed-0.5.3}/fakecbed.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakecbed
-Version: 0.5.1
+Version: 0.5.3
 Summary: A Python library for generating quickly images that imitate convergent beam electron diffraction patterns.
 Author-email: Matthew Fitzpatrick <matthew.rc.fitzpatrick@gmail.com>
 Project-URL: Homepage, https://mrfitzpa.github.io/fakecbed
@@ -46,6 +46,7 @@ Dynamic: license-file
 [![PyPi Version](https://img.shields.io/pypi/v/fakecbed.svg)](https://pypi.org/project/fakecbed)
 [![Conda-Forge Version](https://img.shields.io/conda/vn/conda-forge/fakecbed.svg)](https://anaconda.org/conda-forge/fakecbed)
 [![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![DOI](https://img.shields.io/badge/DOI-10.5281/zenodo.18297325-blue.svg)](https://doi.org/10.5281/zenodo.18297325)
 
 `fakecbed` is a Python library for generating quickly images that imitate
 convergent beam electron diffraction patterns.

{fakecbed-0.5.1 → fakecbed-0.5.3}/fakecbed.egg-info/SOURCES.txt

@@ -1,5 +1,7 @@
 .coveragerc
 .gitignore
+.zenodo.json
+CITATION.cff
 LICENSE
 README.md
 pyproject.toml