fakecbed 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

fakecbed/discretized.py

@@ -2975,6 +2975,7 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
                             "_principal_disk_is_clipped",
                             "_principal_disk_is_absent",
                             "_disk_overlap_map",
+                            "_principal_disk_is_overlapping",
                             "_principal_disk_analysis_results",
                             "_principal_disk_bounding_box"
                             "_in_uncropped_image_fractional_coords",
@@ -4505,6 +4506,191 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
 
 
 
+    def get_disk_overlap_map(self, deep_copy=_default_deep_copy):
+        r"""Return the image of the disk overlap map of the cropped fake CBED 
+        pattern.
+
+        Parameters
+        ----------
+        deep_copy : `bool`, optional
+            Let ``disk_overlap_map`` denote the attribute
+            :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_overlap_map`.
+
+            If ``deep_copy`` is set to ``True``, then a deep copy of
+            ``disk_overlap_map`` is returned.  Otherwise, a reference to
+            ``disk_overlap_map`` is returned.
+
+        Returns
+        -------
+        disk_overlap_map : `torch.Tensor` (`int`, ndim=2)
+            The attribute
+            :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_overlap_map`.
+
+        """
+        params = {"deep_copy": deep_copy}
+        deep_copy = _check_and_convert_deep_copy(params)
+
+        if self._disk_overlap_map is None:
+            method_name = "_calc_disk_overlap_map"
+            method_alias = getattr(self, method_name)
+            self._disk_overlap_map = method_alias()
+
+        disk_overlap_map = (self._disk_overlap_map.detach().clone()
+                            if (deep_copy == True)
+                            else self._disk_overlap_map)
+
+        return disk_overlap_map
+
+
+
+    def _calc_disk_overlap_map(self):
+        uncropped_cbed_pattern_disk_overlap_map = \
+            self._cbed_pattern.get_disk_overlap_map(deep_copy=False)
+        uncropped_cbed_pattern_disk_overlap_map = \
+            uncropped_cbed_pattern_disk_overlap_map.cpu().detach().clone()
+
+        signal_to_crop = \
+            self._generate_uncropped_blank_signal()
+        signal_to_crop.data[2] = \
+            uncropped_cbed_pattern_disk_overlap_map.numpy(force=True)
+
+        optional_params = self._generate_optional_cropping_params()
+
+        kwargs = {"input_signal": signal_to_crop,
+                  "optional_params": optional_params}
+        cropped_signal = empix.crop(**kwargs)
+
+        N_W_h, N_W_v = self._cropping_window_dims_in_pixels
+        L, R, B, T = self._mask_frame  # Mask frame of cropped pattern.
+
+        disk_overlap_map = cropped_signal.data[2]
+        disk_overlap_map_dtype = uncropped_cbed_pattern_disk_overlap_map.dtype
+        disk_overlap_map = torch.from_numpy(disk_overlap_map)
+        disk_overlap_map = disk_overlap_map.to(device=self._device,
+                                               dtype=disk_overlap_map_dtype)
+        disk_overlap_map[:T, :] = 0
+        disk_overlap_map[max(N_W_v-B, 0):, :] = 0
+        disk_overlap_map[:, :L] = 0
+        disk_overlap_map[:, max(N_W_h-R, 0):] = 0
+    
+        return disk_overlap_map
+
+
+
+    @property
+    def disk_overlap_map(self):
+        r"""`torch.Tensor`: The image of the disk overlap map of the cropped 
+        fake CBED pattern.
+
+        See the documentation for the attribute
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.signal` for additional
+        context.
+
+        Let ``signal``, ``device``, and ``core_attrs`` denote the attributes
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.signal`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.device`, and
+        :attr:`~fancytypes.Checkable.core_attrs` respectively.
+
+        ``disk_overlap_map`` is calculated effectively by:
+
+        .. code-block:: python
+
+           N_W_h, N_W_v = core_attrs["cropping_window_dims_in_pixels"]
+           L, R, B, T = core_attrs["mask_frame"]
+
+           disk_overlap_map = signal.data[2]
+           disk_overlap_map = torch.from_numpy(disk_overlap_map)
+           disk_overlap_map = disk_overlap_map.to(device=device, dtype=int)
+           disk_overlap_map[:T, :] = 0
+           disk_overlap_map[max(N_W_v-B, 0):, :] = 0
+           disk_overlap_map[:, :L] = 0
+           disk_overlap_map[:, max(N_W_h-R, 0):] = 0
+
+        Note that ``disk_overlap_map`` should be considered **read-only**.
+
+        """
+        result = self.get_disk_overlap_map(deep_copy=True)
+
+        return result
+
+
+
+    @property
+    def principal_disk_is_overlapping(self):
+        r"""`bool`: Equals ``True`` if the "principal" CBED disk exists and is 
+        overlapping with another CBED disk in the image of the cropped fake CBED
+        pattern.
+
+        See the summary documentation for the class
+        :class:`fakecbed.discretized.CroppedCBEDPattern` for additional context,
+        as well as the documentation for the attribute
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_overlap_map`.
+
+        Let ``core_attrs``, ``num_disks``, ``disk_supports``, and
+        ``disk_overlap_map`` denote the attributes
+        :attr:`~fancytypes.Checkable.core_attrs`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.num_disks`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_supports`, and
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_overlap_map`
+        respectively.
+
+        ``principal_disk_is_overlapping`` is calculated effectively by:
+
+        .. code-block:: python
+
+           principal_disk_idx = core_attrs["principal_disk_idx"]
+
+           principal_disk_support = (disk_supports[principal_disk_idx]
+                                     if (principal_disk_idx < num_disks)
+                                     else torch.zeros_like(disk_overlap_map))
+
+           principal_disk_is_overlapping = \
+               torch.any(disk_overlap_map*principal_disk_support > 1.5).item()
+
+        Note that ``principal_disk_is_overlapping`` should be considered
+        **read-only**.
+
+        """
+        if self._principal_disk_is_overlapping is None:
+            method_name = ("_calc_principal_disk_is_overlapping"
+                           "_and_cache_select_intermediates")
+            method_alias = getattr(self, method_name)
+            self._principal_disk_is_overlapping = method_alias()
+
+        result = self._principal_disk_is_overlapping
+        
+        return result
+
+
+    
+    def _calc_principal_disk_is_overlapping_and_cache_select_intermediates(
+            self):
+        principal_disk_idx = self._principal_disk_idx
+        num_disks = self._num_disks
+
+        if self._disk_supports is None:
+            method_name = "_calc_disk_supports"
+            method_alias = getattr(self, method_name)
+            self._disk_supports = method_alias()
+        disk_supports = self._disk_supports
+
+        if self._disk_overlap_map is None:
+            method_name = "_calc_disk_overlap_map"
+            method_alias = getattr(self, method_name)
+            self._disk_overlap_map = method_alias()
+        disk_overlap_map = self._disk_overlap_map
+
+        principal_disk_support = (disk_supports[principal_disk_idx]
+                                  if (principal_disk_idx < num_disks)
+                                  else torch.zeros_like(disk_overlap_map))
+
+        principal_disk_is_overlapping = \
+            torch.any(disk_overlap_map*principal_disk_support > 1.5).item()
+
+        return principal_disk_is_overlapping
+
+
+
     def get_signal(self, deep_copy=_default_deep_copy):
         r"""Return the hyperspy signal representation of the cropped fake CBED 
         pattern.
@@ -4576,11 +4762,11 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
             self._generate_cropped_blank_signal().axes_manager
         
         signal.axes_manager[0].name = \
-            r"cropped fake CBED pattern attribute"
+            "cropped fake CBED pattern attribute"
         signal.axes_manager[1].name = \
-            r"fractional horizontal coordinate of uncropped fake CBED pattern"
+            "fractional horizontal coordinate of uncropped fake CBED pattern"
         signal.axes_manager[2].name = \
-            r"fractional vertical coordinate of uncropped fake CBED pattern"
+            "fractional vertical coordinate of uncropped fake CBED pattern"
 
         return signal
 
@@ -4597,7 +4783,8 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
                             "_disk_clipping_registry",
                             "_disk_absence_registry",
                             "_principal_disk_is_clipped",
-                            "_principal_disk_is_absent")
+                            "_principal_disk_is_absent",
+                            "_principal_disk_is_overlapping")
         for attr_name in attr_name_subset:
             attr = getattr(self, attr_name)
             if attr is None:
@@ -4660,12 +4847,19 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
         :class:`fakecbed.discretized.CBEDPattern` and
         :class:`fakecbed.discretized.CroppedCBEDPattern` for additional context.
 
-        Let
+        Let ``disk_clipping_registry``, ``disk_absence_registry``,
+        ``principal_disk_is_clipped``, ``principal_disk_is_absent``,
+        ``principal_disk_is_overlapping``,
         ``principal_disk_bounding_box_in_uncropped_image_fractional_coords``,
         ``principal_disk_bounding_box_in_cropped_image_fractional_coords``,
         ``principal_disk_boundary_pts_in_uncropped_image_fractional_coords``,
         ``principal_disk_boundary_pts_in_cropped_image_fractional_coords``, and
         ``core_attrs`` denote the attributes
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_clipping_registry`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_absence_registry`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.principal_disk_is_clipped`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.principal_disk_is_absent`,
+        :attr:`fakecbed.discretized.CroppedCBEDPattern.principal_disk_is_overlapping`,
         :attr:`fakecbed.discretized.CroppedCBEDPattern.principal_disk_bounding_box_in_uncropped_image_fractional_coords`,
         :attr:`fakecbed.discretized.CroppedCBEDPattern.principal_disk_bounding_box_in_cropped_image_fractional_coords`,
         :attr:`fakecbed.discretized.CroppedCBEDPattern.principal_disk_boundary_pts_in_uncropped_image_fractional_coords`,
@@ -4727,46 +4921,96 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
            kwargs["value"] = pre_serialize()
            signal.metadata.set_item(**kwargs)
 
-           tensor = \
+           def _convert_attr_to_metadata_item(attr):
+               if isinstance(attr, (tuple, bool)):
+                   metadata_item = \
+                       attr
+               else:
+                   if len(attr.shape) == 1:
+                       metadata_item = \
+                           tuple(elem
+                                 for elem
+                                 in attr.cpu().detach().clone().tolist())
+                   else:
+                       metadata_item = \
+                           tuple(tuple(pt)
+                                 for pt
+                                 in attr.cpu().detach().clone().tolist())
+
+               return metadata_item
+
+           attr = disk_clipping_registry
+           kwargs["item_path"] = "FakeCBED.disk_clipping_registry"
+           kwargs["value"] = _convert_attr_to_metadata_item(attr)
+           signal.metadata.set_item(**kwargs)
+
+           attr = disk_absence_registry
+           kwargs["item_path"] = "FakeCBED.disk_absence_registry"
+           kwargs["value"] = _convert_attr_to_metadata_item(attr)
+           signal.metadata.set_item(**kwargs)
+
+           attr = principal_disk_is_clipped
+           kwargs["item_path"] = "FakeCBED.principal_disk_is_clipped"
+           kwargs["value"] = _convert_attr_to_metadata_item(attr)
+           signal.metadata.set_item(**kwargs)
+
+           attr = principal_disk_is_absent
+           kwargs["item_path"] = "FakeCBED.principal_disk_is_absent"
+           kwargs["value"] = _convert_attr_to_metadata_item(attr)
+           signal.metadata.set_item(**kwargs)
+
+           attr = principal_disk_is_overlapping
+           kwargs["item_path"] = "FakeCBED.principal_disk_is_overlapping"
+           kwargs["value"] = _convert_attr_to_metadata_item(attr)
+           signal.metadata.set_item(**kwargs)
+
+           attr = \
                principal_disk_bounding_box_in_uncropped_image_fractional_coords
            kwargs["item_path"] = \
                ("FakeCBED.principal_disk_bounding_box"
                 "_in_uncropped_image_fractional_coords")
            kwargs["value"] = \
-               tuple(tensor.cpu().detach().clone().tolist())
+               _convert_attr_to_metadata_item(attr)
            _ = \
                signal.metadata.set_item(**kwargs)
 
-           tensor = \
+           attr = \
                principal_disk_bounding_box_in_cropped_image_fractional_coords
            kwargs["item_path"] = \
                ("FakeCBED.principal_disk_bounding_box"
                 "_in_cropped_image_fractional_coords")
            kwargs["value"] = \
-               tuple(tensor.cpu().detach().clone().tolist())
+               _convert_attr_to_metadata_item(attr)
            _ = \
                signal.metadata.set_item(**kwargs)
 
-           tensor = \
+           attr = \
                principal_disk_boundary_pts_in_uncropped_image_fractional_coords
            kwargs["item_path"] = \
                ("FakeCBED.principal_disk_boundary_pts"
                 "_in_uncropped_image_fractional_coords")
            kwargs["value"] = \
-               tuple(tensor.cpu().detach().clone().tolist())
+               _convert_attr_to_metadata_item(attr)
            _ = \
                signal.metadata.set_item(**kwargs)
 
-           tensor = \
+           attr = \
                principal_disk_boundary_pts_in_cropped_image_fractional_coords
            kwargs["item_path"] = \
                ("FakeCBED.principal_disk_boundary_pts"
                 "_in_cropped_image_fractional_coords")
            kwargs["value"] = \
-               tuple(tensor.cpu().detach().clone().tolist())
+               _convert_attr_to_metadata_item(attr)
            _ = \
                signal.metadata.set_item(**kwargs)
 
+           signal.axes_manager[0].name = \
+               "cropped fake CBED pattern attribute"
+           signal.axes_manager[1].name = \
+               "fractional horizontal coordinate of uncropped fake CBED pattern"
+           signal.axes_manager[2].name = \
+               "fractional vertical coordinate of uncropped fake CBED pattern"
+
         Note that ``signal`` should be considered **read-only**.
 
         """
@@ -5014,115 +5258,6 @@ class CroppedCBEDPattern(fancytypes.PreSerializableAndUpdatable):
 
 
 
-    def get_disk_overlap_map(self, deep_copy=_default_deep_copy):
-        r"""Return the image of the disk overlap map of the cropped fake CBED 
-        pattern.
-
-        Parameters
-        ----------
-        deep_copy : `bool`, optional
-            Let ``disk_overlap_map`` denote the attribute
-            :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_overlap_map`.
-
-            If ``deep_copy`` is set to ``True``, then a deep copy of
-            ``disk_overlap_map`` is returned.  Otherwise, a reference to
-            ``disk_overlap_map`` is returned.
-
-        Returns
-        -------
-        disk_overlap_map : `torch.Tensor` (`int`, ndim=2)
-            The attribute
-            :attr:`fakecbed.discretized.CroppedCBEDPattern.disk_overlap_map`.
-
-        """
-        params = {"deep_copy": deep_copy}
-        deep_copy = _check_and_convert_deep_copy(params)
-
-        if self._disk_overlap_map is None:
-            method_name = ("_calc_disk_overlap_map")
-            method_alias = getattr(self, method_name)
-            self._disk_overlap_map = method_alias()
-
-        disk_overlap_map = (self._disk_overlap_map.detach().clone()
-                            if (deep_copy == True)
-                            else self._disk_overlap_map)
-
-        return disk_overlap_map
-
-
-
-    def _calc_disk_overlap_map(self):
-        uncropped_cbed_pattern_disk_overlap_map = \
-            self._cbed_pattern.get_disk_overlap_map(deep_copy=False)
-        uncropped_cbed_pattern_disk_overlap_map = \
-            uncropped_cbed_pattern_disk_overlap_map.cpu().detach().clone()
-
-        signal_to_crop = \
-            self._generate_uncropped_blank_signal()
-        signal_to_crop.data[2] = \
-            uncropped_cbed_pattern_disk_overlap_map.numpy(force=True)
-
-        optional_params = self._generate_optional_cropping_params()
-
-        kwargs = {"input_signal": signal_to_crop,
-                  "optional_params": optional_params}
-        cropped_signal = empix.crop(**kwargs)
-
-        N_W_h, N_W_v = self._cropping_window_dims_in_pixels
-        L, R, B, T = self._mask_frame  # Mask frame of cropped pattern.
-
-        disk_overlap_map = cropped_signal.data[2]
-        disk_overlap_map_dtype = uncropped_cbed_pattern_disk_overlap_map.dtype
-        disk_overlap_map = torch.from_numpy(disk_overlap_map)
-        disk_overlap_map = disk_overlap_map.to(device=self._device,
-                                               dtype=disk_overlap_map_dtype)
-        disk_overlap_map[:T, :] = 0
-        disk_overlap_map[max(N_W_v-B, 0):, :] = 0
-        disk_overlap_map[:, :L] = 0
-        disk_overlap_map[:, max(N_W_h-R, 0):] = 0
-    
-        return disk_overlap_map
-
-
-
-    @property
-    def disk_overlap_map(self):
-        r"""`torch.Tensor`: The image of the disk overlap map of the cropped 
-        fake CBED pattern.
-
-        See the documentation for the attribute
-        :attr:`fakecbed.discretized.CroppedCBEDPattern.signal` for additional
-        context.
-
-        Let ``signal``, ``device``, and ``core_attrs`` denote the attributes
-        :attr:`fakecbed.discretized.CroppedCBEDPattern.signal`,
-        :attr:`fakecbed.discretized.CroppedCBEDPattern.device`, and
-        :attr:`~fancytypes.Checkable.core_attrs` respectively.
-
-        ``disk_overlap_map`` is calculated effectively by:
-
-        .. code-block:: python
-
-           N_W_h, N_W_v = core_attrs["cropping_window_dims_in_pixels"]
-           L, R, B, T = core_attrs["mask_frame"]
-
-           disk_overlap_map = signal.data[2]
-           disk_overlap_map = torch.from_numpy(disk_overlap_map)
-           disk_overlap_map = disk_overlap_map.to(device=device, dtype=int)
-           disk_overlap_map[:T, :] = 0
-           disk_overlap_map[max(N_W_v-B, 0):, :] = 0
-           disk_overlap_map[:, :L] = 0
-           disk_overlap_map[:, max(N_W_h-R, 0):] = 0
-
-        Note that ``disk_overlap_map`` should be considered **read-only**.
-
-        """
-        result = self.get_disk_overlap_map(deep_copy=True)
-
-        return result
-
-
-
 ###########################
 ## Define error messages ##
 ###########################

fakecbed/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)
 
 __commit_id__ = commit_id = None

fakecbed-0.5.1.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: fakecbed
+Version: 0.5.1
+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
+Project-URL: Repository, https://github.com/mrfitzpa/fakecbed
+Keywords: pytorch,microscopy,diffraction,cbed
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: distoptica>=0.4.0
+Requires-Dist: empix>=0.0.6
+Provides-Extra: tests
+Requires-Dist: pytest-cov; extra == "tests"
+Provides-Extra: examples
+Requires-Dist: jupyter; extra == "examples"
+Requires-Dist: ipympl; extra == "examples"
+Provides-Extra: docs
+Requires-Dist: sphinx<7; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: docutils; extra == "docs"
+Provides-Extra: all
+Requires-Dist: fakecbed[docs,examples,tests]; extra == "all"
+Dynamic: license-file
+
+# Fake Convergence Beam Electron Diffraction (FakeCBED)
+
+[![Test library](https://github.com/mrfitzpa/fakecbed/actions/workflows/test_library.yml/badge.svg)](https://github.com/mrfitzpa/fakecbed/actions/workflows/test_library.yml)
+[![Code Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/mrfitzpa/adb03c4c54f978f44822ffa033fe6762/raw/fakecbed_coverage_badge.json)](https://github.com/mrfitzpa/fakecbed/actions/workflows/measure_code_coverage.yml)
+[![Documentation](https://img.shields.io/badge/docs-read-brightgreen)](https://mrfitzpa.github.io/fakecbed)
+[![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)
+
+`fakecbed` is a Python library for generating quickly images that imitate
+convergent beam electron diffraction patterns.
+
+Visit the `fakecbed` [website](https://mrfitzpa.github.io/fakecbed) for a web
+version of the installation instructions, the reference guide, and the examples
+archive.
+
+The source code can be found in the [`fakecbed` GitHub
+repository](https://github.com/mrfitzpa/fakecbed).
+
+
+
+## Table of contents
+
+- [Instructions for installing and uninstalling
+  `fakecbed`](#instructions-for-installing-and-uninstalling-fakecbed)
+  - [Installing `fakecbed`](#installing-fakecbed)
+    - [Installing `fakecbed` using `pip`](#installing-fakecbed-using-pip)
+    - [Installing `fakecbed` using
+      `conda`](#installing-fakecbed-using-conda)
+  - [Uninstalling `fakecbed`](#uninstalling-fakecbed)
+- [Learning how to use `fakecbed`](#learning-how-to-use-fakecbed)
+
+
+
+## Instructions for installing and uninstalling `fakecbed`
+
+
+
+### Installing `fakecbed`
+
+For all installation scenarios, first open up the appropriate command line
+interface. On Unix-based systems, you could open e.g. a terminal. On Windows
+systems you could open e.g. an Anaconda Prompt as an administrator.
+
+Before installing `fakecbed`, it is recommended that users install `PyTorch` in
+the same environment that they intend to install `fakecbed` according to the
+instructions given [here](https://pytorch.org/get-started/locally/) for their
+preferred PyTorch installation option.
+
+
+
+#### Installing `fakecbed` using `pip`
+
+Before installing `fakecbed`, make sure that you have activated the (virtual)
+environment in which you intend to install said package. After which, simply run
+the following command:
+
+    pip install fakecbed
+
+The above command will install the latest stable version of `fakecbed`.
+
+To install the latest development version from the main branch of the [fakecbed
+GitHub repository](https://github.com/mrfitzpa/fakecbed), one must first clone
+the repository by running the following command:
+
+    git clone https://github.com/mrfitzpa/fakecbed.git
+
+Next, change into the root of the cloned repository, and then run the following
+command:
+
+    pip install .
+
+Note that you must include the period as well. The above command executes a
+standard installation of `fakecbed`.
+
+Optionally, for additional features in `fakecbed`, one can install additional
+dependencies upon installing `fakecbed`. To install a subset of additional
+dependencies (along with the standard installation), run the following command
+from the root of the repository:
+
+    pip install .[<selector>]
+
+where `<selector>` can be one of the following:
+
+* `tests`: to install the dependencies necessary for running unit tests;
+* `examples`: to install the dependencies necessary for executing files stored
+  in `<root>/examples`, where `<root>` is the root of the repository;
+* `docs`: to install the dependencies necessary for documentation generation;
+* `all`: to install all of the above optional dependencies.
+
+Alternatively, one can run:
+
+    pip install fakecbed[<selector>]
+
+elsewhere in order to install the latest stable version of `fakecbed`, along
+with the subset of additional dependencies specified by `<selector>`.
+
+
+
+#### Installing `fakecbed` using `conda`
+
+Before proceeding, make sure that you have activated the (virtual) `conda`
+environment in which you intend to install said package. For Windows systems,
+users must install `PyTorch` separately prior to following the remaining
+instructions below.
+
+To install `fakecbed` using the `conda` package manager, run the following
+command:
+
+    conda install -c conda-forge fakecbed
+
+The above command will install the latest stable version of `fakecbed`.
+
+
+
+### Uninstalling `fakecbed`
+
+If `fakecbed` was installed using `pip`, then to uninstall, run the following
+command:
+
+    pip uninstall fakecbed
+
+If `fakecbed` was installed using `conda`, then to uninstall, run the following
+command:
+
+    conda remove fakecbed
+
+
+
+## Learning how to use `fakecbed`
+
+For those new to the `fakecbed` library, it is recommended that they take a look
+at the [Examples](https://mrfitzpa.github.io/fakecbed/examples.html) page, which
+contain code examples that show how one can use the `fakecbed` library. While
+going through the examples, readers can consult the [fakecbed reference
+guide](https://mrfitzpa.github.io/fakecbed/_autosummary/fakecbed.html) to
+understand what each line of code is doing.

fakecbed-0.5.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+fakecbed/__init__.py,sha256=iP73WNV_HZgxiVUVdesbJqlrhDGESooh1hlBs8kox9M,1342
+fakecbed/discretized.py,sha256=uV9tc8CC0K6GG1rGp2Nvq8p9qf6zLmp4lWTbKicmULE,205011
+fakecbed/shapes.py,sha256=Lo4pg46lpBwGiUJB6Q3X6gxoaa1d9eRwwjG49gkZ2zY,116472
+fakecbed/tds.py,sha256=mk5359ErIhdpCoTdHq9r1-foKb8t3qCOHqNoabx3bQw,8066
+fakecbed/version.py,sha256=cYMOhuaBHd0MIZmumuccsEQ-AxM8LIJy9dsBAWgOpqE,704
+fakecbed-0.5.1.dist-info/licenses/LICENSE,sha256=N0P3pKtRMvfb64jmgJdlerg3TnS0a2QC776AzPsbZIg,35128
+fakecbed-0.5.1.dist-info/METADATA,sha256=NGCr4SUFD2W5hKMPPe1mv3YAHRvMQ4TlKUITz_hjVgQ,7023
+fakecbed-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fakecbed-0.5.1.dist-info/top_level.txt,sha256=l0jL8P0CjRiCSznYLnq7riaAnOmYaV3zjjjIJx9vjSQ,9
+fakecbed-0.5.1.dist-info/RECORD,,

fakecbed-0.4.0.dist-info/METADATA

@@ -1,61 +0,0 @@
-Metadata-Version: 2.4
-Name: fakecbed
-Version: 0.4.0
-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
-Project-URL: Repository, https://github.com/mrfitzpa/fakecbed
-Keywords: pytorch,microscopy,diffraction,cbed
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: OS Independent
-Classifier: Natural Language :: English
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: distoptica>=0.4.0
-Requires-Dist: empix
-Requires-Dist: hyperspy
-Provides-Extra: tests
-Requires-Dist: pytest-cov; extra == "tests"
-Provides-Extra: examples
-Requires-Dist: jupyter; extra == "examples"
-Requires-Dist: ipympl; extra == "examples"
-Provides-Extra: docs
-Requires-Dist: sphinx<7; extra == "docs"
-Requires-Dist: sphinx_rtd_theme; extra == "docs"
-Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
-Requires-Dist: numpydoc; extra == "docs"
-Requires-Dist: docutils; extra == "docs"
-Provides-Extra: all
-Requires-Dist: fakecbed[docs,examples,tests]; extra == "all"
-Dynamic: license-file
-
-# Fake Convergence Beam Electron Diffraction (fakecbed)
-
-[![Test library](https://github.com/mrfitzpa/fakecbed/actions/workflows/test_library.yml/badge.svg)](https://github.com/mrfitzpa/fakecbed/actions/workflows/test_library.yml)
-[![Code Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/mrfitzpa/adb03c4c54f978f44822ffa033fe6762/raw/fakecbed_coverage_badge.json)](https://github.com/mrfitzpa/fakecbed/actions/workflows/measure_code_coverage.yml)
-[![Documentation](https://img.shields.io/badge/docs-read-brightgreen)](https://mrfitzpa.github.io/fakecbed)
-[![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)
-
-`fakecbed` is a Python library for generating quickly images that imitate
-convergent beam electron diffraction patterns.
-
-Visit the `fakecbed` [website](https://mrfitzpa.github.io/fakecbed) for a web
-version of the installation instructions, the reference guide, and the examples
-archive.
-
-<!--
-For those reading raw .rst files, see file `docs/INSTALL.rst` for instructions
-on installing the `fakecbed` library.
--->

fakecbed-0.4.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-fakecbed/__init__.py,sha256=iP73WNV_HZgxiVUVdesbJqlrhDGESooh1hlBs8kox9M,1342
-fakecbed/discretized.py,sha256=OZMfP6svmM1X9nr9_HH9UneM7HeYCORnql6ub6VEiiY,199216
-fakecbed/shapes.py,sha256=Lo4pg46lpBwGiUJB6Q3X6gxoaa1d9eRwwjG49gkZ2zY,116472
-fakecbed/tds.py,sha256=mk5359ErIhdpCoTdHq9r1-foKb8t3qCOHqNoabx3bQw,8066
-fakecbed/version.py,sha256=2_0GUP7yBCXRus-qiJKxQD62z172WSs1sQ6DVpPsbmM,704
-fakecbed-0.4.0.dist-info/licenses/LICENSE,sha256=N0P3pKtRMvfb64jmgJdlerg3TnS0a2QC776AzPsbZIg,35128
-fakecbed-0.4.0.dist-info/METADATA,sha256=S6dfO2H9VfL8U83rZ4KbTZxGzOq1qkcEKWbEo84P91w,3044
-fakecbed-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fakecbed-0.4.0.dist-info/top_level.txt,sha256=l0jL8P0CjRiCSznYLnq7riaAnOmYaV3zjjjIJx9vjSQ,9
-fakecbed-0.4.0.dist-info/RECORD,,