fakecbed 0.2.0__tar.gz → 0.3.0__tar.gz

{fakecbed-0.2.0 → fakecbed-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fakecbed
-Version: 0.2.0
+Version: 0.3.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

{fakecbed-0.2.0 → fakecbed-0.3.0}/fakecbed/discretized.py

@@ -21,12 +21,6 @@
 ## Load libraries/packages/modules ##
 #####################################
 
-# For accessing attributes of functions.
-import inspect
-
-# For randomly selecting items in dictionaries.
-import random
-
 # For performing deep copies.
 import copy
 
@@ -74,9 +68,7 @@ __all__ = ["CBEDPattern"]
 
 
 def _check_and_convert_undistorted_tds_model(params):
-    current_func_name = inspect.stack()[0][3]
-    char_idx = 19
-    obj_name = current_func_name[char_idx:]
+    obj_name = "undistorted_tds_model"
     obj = params[obj_name]
 
     accepted_types = (fakecbed.tds.Model, type(None))
@@ -95,7 +87,7 @@ def _check_and_convert_undistorted_tds_model(params):
 
 
 def _pre_serialize_undistorted_tds_model(undistorted_tds_model):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = undistorted_tds_model
     serializable_rep = obj_to_pre_serialize.pre_serialize()
     
     return serializable_rep
@@ -111,11 +103,11 @@ def _de_pre_serialize_undistorted_tds_model(serializable_rep):
 
 
 def _check_and_convert_undistorted_disks(params):
-    current_func_name = inspect.stack()[0][3]
-    char_idx = 19
-    obj_name = current_func_name[char_idx:]
+    obj_name = "undistorted_disks"
     obj = params[obj_name]
 
+    current_func_name = "_check_and_convert_undistorted_disks"
+
     try:
         for undistorted_disk in obj:
             accepted_types = (fakecbed.shapes.NonuniformBoundedShape,)
@@ -147,7 +139,7 @@ def _check_and_convert_undistorted_disks(params):
 
 
 def _pre_serialize_undistorted_disks(undistorted_disks):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = undistorted_disks
     serializable_rep = tuple()
     for elem in obj_to_pre_serialize:
         serializable_rep += (elem.pre_serialize(),)
@@ -172,9 +164,7 @@ def _de_pre_serialize_undistorted_disks(serializable_rep):
 
 
 def _check_and_convert_undistorted_misc_shapes(params):
-    current_func_name = inspect.stack()[0][3]
-    char_idx = 19
-    obj_name = current_func_name[char_idx:]
+    obj_name = "undistorted_misc_shapes"
     obj = params[obj_name]
 
     accepted_types = (fakecbed.shapes.Circle,
@@ -188,6 +178,8 @@ def _check_and_convert_undistorted_misc_shapes(params):
                       fakecbed.shapes.Lune,
                       fakecbed.shapes.NonuniformBoundedShape)
 
+    current_func_name = "_check_and_convert_undistorted_misc_shapes"
+
     try:
         for undistorted_misc_shape in obj:
             kwargs = {"obj": undistorted_misc_shape,
@@ -205,7 +197,7 @@ def _check_and_convert_undistorted_misc_shapes(params):
 
 
 def _pre_serialize_undistorted_misc_shapes(undistorted_misc_shapes):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = undistorted_misc_shapes
     serializable_rep = tuple()
     for elem in obj_to_pre_serialize:
         serializable_rep += (elem.pre_serialize(),)
@@ -249,9 +241,7 @@ def _de_pre_serialize_undistorted_misc_shapes(serializable_rep):
 
 
 def _check_and_convert_undistorted_outer_illumination_shape(params):
-    current_func_name = inspect.stack()[0][3]
-    char_idx = 19
-    obj_name = current_func_name[char_idx:]
+    obj_name = "undistorted_outer_illumination_shape"
     obj = params[obj_name]
 
     accepted_types = (fakecbed.shapes.Circle,
@@ -275,7 +265,7 @@ def _check_and_convert_undistorted_outer_illumination_shape(params):
 
 def _pre_serialize_undistorted_outer_illumination_shape(
         undistorted_outer_illumination_shape):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = undistorted_outer_illumination_shape
     serializable_rep = obj_to_pre_serialize.pre_serialize()
     
     return serializable_rep
@@ -298,8 +288,7 @@ def _de_pre_serialize_undistorted_outer_illumination_shape(serializable_rep):
 
 
 def _check_and_convert_gaussian_filter_std_dev(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "gaussian_filter_std_dev"
     func_alias = czekitout.convert.to_nonnegative_float
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     gaussian_filter_std_dev = func_alias(**kwargs)
@@ -308,9 +297,8 @@ def _check_and_convert_gaussian_filter_std_dev(params):
 
 
 
-def _pre_serialize_gaussian_filter_std_dev(
-        gaussian_filter_std_dev):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+def _pre_serialize_gaussian_filter_std_dev(gaussian_filter_std_dev):
+    obj_to_pre_serialize = gaussian_filter_std_dev
     serializable_rep = obj_to_pre_serialize
     
     return serializable_rep
@@ -325,9 +313,7 @@ def _de_pre_serialize_gaussian_filter_std_dev(serializable_rep):
 
 
 def _check_and_convert_distortion_model(params):
-    current_func_name = inspect.stack()[0][3]
-    char_idx = 19
-    obj_name = current_func_name[char_idx:]
+    obj_name = "distortion_model"
     obj = params[obj_name]
 
     num_pixels_across_pattern = \
@@ -351,6 +337,8 @@ def _check_and_convert_distortion_model(params):
     sampling_grid_dims_in_pixels = \
         distortion_model_core_attrs["sampling_grid_dims_in_pixels"]
 
+    current_func_name = "_check_and_convert_distortion_model"
+
     if ((sampling_grid_dims_in_pixels[0]%num_pixels_across_pattern != 0)
         or (sampling_grid_dims_in_pixels[1]%num_pixels_across_pattern != 0)):
         err_msg = globals()[current_func_name+"_err_msg_1"]
@@ -361,7 +349,7 @@ def _check_and_convert_distortion_model(params):
 
 
 def _pre_serialize_distortion_model(distortion_model):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = distortion_model
     serializable_rep = obj_to_pre_serialize.pre_serialize()
     
     return serializable_rep
@@ -377,8 +365,7 @@ def _de_pre_serialize_distortion_model(serializable_rep):
 
 
 def _check_and_convert_num_pixels_across_pattern(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "num_pixels_across_pattern"
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     num_pixels_across_pattern = czekitout.convert.to_positive_int(**kwargs)
 
@@ -387,7 +374,7 @@ def _check_and_convert_num_pixels_across_pattern(params):
 
 
 def _pre_serialize_num_pixels_across_pattern(num_pixels_across_pattern):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = num_pixels_across_pattern
     serializable_rep = obj_to_pre_serialize
     
     return serializable_rep
@@ -402,8 +389,7 @@ def _de_pre_serialize_num_pixels_across_pattern(serializable_rep):
 
 
 def _check_and_convert_apply_shot_noise(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "apply_shot_noise"
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     apply_shot_noise = czekitout.convert.to_bool(**kwargs)
 
@@ -412,7 +398,7 @@ def _check_and_convert_apply_shot_noise(params):
 
 
 def _pre_serialize_apply_shot_noise(apply_shot_noise):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = apply_shot_noise
     serializable_rep = obj_to_pre_serialize
     
     return serializable_rep
@@ -426,9 +412,43 @@ def _de_pre_serialize_apply_shot_noise(serializable_rep):
 
 
 
+def _check_and_convert_rng_seed(params):
+    obj_name = "rng_seed"
+    obj = params[obj_name]
+
+    current_func_name = "_check_and_convert_rng_seed"
+    
+    if obj is not None:
+        kwargs = {"obj": obj, "obj_name": obj_name}
+        try:
+            rng_seed = czekitout.convert.to_nonnegative_int(**kwargs)
+        except:
+            err_msg = globals()[current_func_name+"_err_msg_1"]
+            raise TypeError(err_msg)
+    else:
+        rng_seed = obj
+
+    return rng_seed
+
+
+
+def _pre_serialize_rng_seed(rng_seed):
+    obj_to_pre_serialize = rng_seed
+    serializable_rep = obj_to_pre_serialize
+    
+    return serializable_rep
+
+
+
+def _de_pre_serialize_rng_seed(serializable_rep):
+    rng_seed = serializable_rep
+
+    return rng_seed
+
+
+
 def _check_and_convert_detector_partition_width_in_pixels(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "detector_partition_width_in_pixels"
     func_alias = czekitout.convert.to_nonnegative_int
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     detector_partition_width_in_pixels = func_alias(**kwargs)
@@ -439,7 +459,7 @@ def _check_and_convert_detector_partition_width_in_pixels(params):
 
 def _pre_serialize_detector_partition_width_in_pixels(
         detector_partition_width_in_pixels):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = detector_partition_width_in_pixels
     serializable_rep = obj_to_pre_serialize
     
     return serializable_rep
@@ -454,14 +474,15 @@ def _de_pre_serialize_detector_partition_width_in_pixels(serializable_rep):
 
 
 def _check_and_convert_cold_pixels(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "cold_pixels"
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     cold_pixels = czekitout.convert.to_pairs_of_ints(**kwargs)
 
     num_pixels_across_pattern = \
         _check_and_convert_num_pixels_across_pattern(params)
 
+    current_func_name = "_check_and_convert_cold_pixels"
+
     coords_of_cold_pixels = cold_pixels
     for coords_of_cold_pixel in coords_of_cold_pixels:
         row, col = coords_of_cold_pixel
@@ -491,8 +512,7 @@ def _de_pre_serialize_cold_pixels(serializable_rep):
 
 
 def _check_and_convert_mask_frame(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "mask_frame"
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     mask_frame = czekitout.convert.to_quadruplet_of_nonnegative_ints(**kwargs)
 
@@ -501,7 +521,7 @@ def _check_and_convert_mask_frame(params):
 
 
 def _pre_serialize_mask_frame(mask_frame):
-    obj_to_pre_serialize = random.choice(list(locals().values()))
+    obj_to_pre_serialize = mask_frame
     serializable_rep = obj_to_pre_serialize
     
     return serializable_rep
@@ -516,8 +536,7 @@ def _de_pre_serialize_mask_frame(serializable_rep):
 
 
 def _check_and_convert_deep_copy(params):
-    current_func_name = inspect.stack()[0][3]
-    obj_name = current_func_name[19:]
+    obj_name = "deep_copy"
     kwargs = {"obj": params[obj_name], "obj_name": obj_name}
     deep_copy = czekitout.convert.to_bool(**kwargs)
 
@@ -526,9 +545,7 @@ def _check_and_convert_deep_copy(params):
 
 
 def _check_and_convert_overriding_image(params):
-    current_func_name = inspect.stack()[0][3]
-    char_idx = 19
-    obj_name = current_func_name[char_idx:]
+    obj_name = "overriding_image"
     obj = params[obj_name]
 
     func_alias = fakecbed.shapes._check_and_convert_real_torch_matrix
@@ -542,6 +559,8 @@ def _check_and_convert_overriding_image(params):
     num_pixels_across_pattern = params["num_pixels_across_pattern"]
     expected_image_dims_in_pixels = 2*(num_pixels_across_pattern,)
 
+    current_func_name = "_check_and_convert_overriding_image"
+
     if overriding_image.shape != expected_image_dims_in_pixels:
         unformatted_err_msg = globals()[current_func_name+"_err_msg_1"]
         args = expected_image_dims_in_pixels
@@ -578,6 +597,8 @@ _default_num_pixels_across_pattern = \
     512
 _default_apply_shot_noise = \
     False
+_default_rng_seed = \
+    None
 _default_detector_partition_width_in_pixels = \
     0
 _default_cold_pixels = \
@@ -908,7 +929,7 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         \text{det}\left(\mathbf{J}_{\square}\left(
         q_{\mathring{\mathcal{I}};x;j},
         q_{\mathring{\mathcal{I}};y;i}\right)\right)
-        \mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}.
+        \left|\mathring{\mathcal{I}}_{\text{CBED};⌑;i,j}\right|.
         :label: HD_I_CBED__3
 
     8. Apply average pooling to
@@ -1051,6 +1072,9 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         If ``apply_shot_noise`` is set to ``True``, then shot noise is applied
         to the image of the fake CBED pattern. Otherwise, no shot noise is
         applied.
+    rng_seed : `int` | `None`, optional
+        ``rng_seed`` specifies the seed used in the random number generator used
+        to apply shot noise.
     detector_partition_width_in_pixels : `int`, optional
         The detector partition width in units of pixels,
         :math:`N_{\text{DPW}}`. Must be nonnegative.
@@ -1073,6 +1097,7 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
                         "num_pixels_across_pattern",
                         "distortion_model",
                         "apply_shot_noise",
+                        "rng_seed",
                         "detector_partition_width_in_pixels",
                         "cold_pixels",
                         "mask_frame")
@@ -1107,6 +1132,8 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
                  _default_distortion_model,
                  apply_shot_noise=\
                  _default_apply_shot_noise,
+                 rng_seed=\
+                 _default_rng_seed,
                  detector_partition_width_in_pixels=\
                  _default_detector_partition_width_in_pixels,
                  cold_pixels=\
@@ -1670,21 +1697,24 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         method_name = ("_calc_maskless_and_noiseless_image"
                        "_and_cache_select_intermediates")
         method_alias = getattr(self, method_name)
-        maskless_and_noiseless_image = method_alias(u_x, u_y)
+        image = method_alias(u_x, u_y)
+
+        apply_shot_noise = self._apply_shot_noise
+        if apply_shot_noise == True:
+            np_rng = np.random.default_rng(self._rng_seed)
+            torch_rng_seed = np_rng.integers(low=0, high=2**32-1).item()
+            torch_rng = torch.Generator().manual_seed(torch_rng_seed)
+            image = torch.poisson(image, torch_rng)
 
+        image = self._apply_detector_partition_inpainting(input_image=image)
+            
         if self._illumination_support is None:
             method_name = "_calc_illumination_support"
             method_alias = getattr(self, method_name)
             self._illumination_support = method_alias(u_x, u_y)
         illumination_support = self._illumination_support
 
-        noiseless_image = maskless_and_noiseless_image*illumination_support
-
-        apply_shot_noise = self._apply_shot_noise
-
-        image = (torch.poisson(noiseless_image)
-                 if (apply_shot_noise == True)
-                 else noiseless_image)
+        image = image*illumination_support        
 
         coords_of_cold_pixels = self._cold_pixels
         L, R, B, T = self._mask_frame
@@ -1698,8 +1728,6 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
         for coords_of_cold_pixel in coords_of_cold_pixels:
             image[coords_of_cold_pixel] = 0
 
-        image = self._apply_detector_partition_inpainting(input_image=image)
-            
         image = self._normalize_matrix(input_matrix=image)
 
         image = torch.clip(image, min=0)
@@ -1732,6 +1760,8 @@ class CBEDPattern(fancytypes.PreSerializableAndUpdatable):
                                         + (disk_supports
                                            * intra_disk_shapes).sum(dim=0))
 
+        maskless_and_noiseless_image = torch.abs(maskless_and_noiseless_image)
+
         kwargs = {"input_matrix": maskless_and_noiseless_image,
                   "truncate": 4}
         maskless_and_noiseless_image = self._apply_2d_guassian_filter(**kwargs)
@@ -2539,6 +2569,10 @@ _check_and_convert_distortion_model_err_msg_1 = \
      "grid, specified by the object ``distortion_model``,  must be divisible "
      "by the object ``num_pixels_across_pattern``.")
 
+_check_and_convert_rng_seed_err_msg_1 = \
+    ("The object ``rng_seed`` must be either a nonnegative integer or of the "
+     "type `NoneType`.")
+
 _check_and_convert_cold_pixels_err_msg_1 = \
     ("The object ``cold_pixels`` must be a sequence of integer pairs, where "
      "each integer pair specifies valid pixel coordinates (i.e. row and column "