LSST Applications g0603fd7c41+501e3db9f9,g0aad566f14+23d8574c86,g0dd44d6229+a1a4c8b791,g2079a07aa2+86d27d4dc4,g2305ad1205+a62672bbc1,g2bbee38e9b+047b288a59,g337abbeb29+047b288a59,g33d1c0ed96+047b288a59,g3a166c0a6a+047b288a59,g3d1719c13e+23d8574c86,g487adcacf7+cb7fd919b2,g4be5004598+23d8574c86,g50ff169b8f+96c6868917,g52b1c1532d+585e252eca,g591dd9f2cf+4a9e435310,g63cd9335cc+585e252eca,g858d7b2824+23d8574c86,g88963caddf+0cb8e002cc,g99cad8db69+43388bcaec,g9ddcbc5298+9a081db1e4,ga1e77700b3+a912195c07,gae0086650b+585e252eca,gb0e22166c9+60f28cb32d,gb2522980b2+793639e996,gb3a676b8dc+b4feba26a1,gb4b16eec92+63f8520565,gba4ed39666+c2a2e4ac27,gbb8dafda3b+a5d255a82e,gc120e1dc64+d820f8acdb,gc28159a63d+047b288a59,gc3e9b769f7+f4f1cc6b50,gcf0d15dbbd+a1a4c8b791,gdaeeff99f8+f9a426f77a,gdb0af172c8+b6d5496702,ge79ae78c31+047b288a59,w.2024.19
LSST Data Management Base Package
Loading...
Searching...
No Matches
Functions | Variables
lsst.scarlet.lite.utils Namespace Reference

Functions

np.ndarray integrated_gaussian_value (np.ndarray x, float sigma)
 
np.ndarray integrated_circular_gaussian (np.ndarray|None x=None, np.ndarray|None y=None, float sigma=0.8)
 
 get_circle_mask (int diameter, npt.DTypeLike dtype=np.float64)
 
 is_attribute_safe_to_transfer (name, value)
 
 continue_class (cls)
 

Variables

 ScalarLike = bool | int | float | complex
 
tuple ScalarTypes = (bool, int, float, complex)
 
 sqrt2 = np.sqrt(2)
 
 INTRINSIC_SPECIAL_ATTRIBUTES
 

Function Documentation

◆ continue_class()

lsst.scarlet.lite.utils.continue_class ( cls) 
Re-open the decorated class, adding any new definitions into the
original.
For example:
.. code-block:: python
    class Foo:
        pass
    @continueClass
    class Foo:
        def run(self):
            return None
is equivalent to:
.. code-block:: python
    class Foo:
        def run(self):
            return None
.. warning::
    Python's built-in `super` function does not behave properly in classes
    decorated with `continue_class`.  Base class methods must be invoked
    directly using their explicit types instead.

This is copied directly from lsst.utils. If any additional functions are
used from that repo we should remove this function and make lsst.utils
a dependency. But for now, it is easier to copy this single wrapper
than to include lsst.utils and all of its dependencies.

Definition at line 158 of file utils.py.

158def continue_class(cls):
159 """Re-open the decorated class, adding any new definitions into the
160 original.
161 For example:
162 .. code-block:: python
163 class Foo:
164 pass
165 @continueClass
166 class Foo:
167 def run(self):
168 return None
169 is equivalent to:
170 .. code-block:: python
171 class Foo:
172 def run(self):
173 return None
174 .. warning::
175 Python's built-in `super` function does not behave properly in classes
176 decorated with `continue_class`. Base class methods must be invoked
177 directly using their explicit types instead.
178
179 This is copied directly from lsst.utils. If any additional functions are
180 used from that repo we should remove this function and make lsst.utils
181 a dependency. But for now, it is easier to copy this single wrapper
182 than to include lsst.utils and all of its dependencies.
183 """
184 orig = getattr(sys.modules[cls.__module__], cls.__name__)
185 for name in dir(cls):
186 # Common descriptors like classmethod and staticmethod can only be
187 # accessed without invoking their magic if we use __dict__; if we use
188 # getattr on those we'll get e.g. a bound method instance on the dummy
189 # class rather than a classmethod instance we can put on the target
190 # class.
191 attr = cls.__dict__.get(name, None) or getattr(cls, name)
192 if is_attribute_safe_to_transfer(name, attr):
193 setattr(orig, name, attr)
194 return orig

◆ get_circle_mask()

lsst.scarlet.lite.utils.get_circle_mask ( int diameter,
npt.DTypeLike dtype = np.float64 ) 
Get a boolean image of a circle

Parameters
----------
diameter:
    The diameter of the circle and width
    of the image.
dtype:
    The `dtype` of the image.

Returns
-------
circle:
    A boolean array with ones for the pixels with centers
    inside of the circle and zeros
    outside of the circle.

Definition at line 94 of file utils.py.

94def get_circle_mask(diameter: int, dtype: npt.DTypeLike = np.float64):
95 """Get a boolean image of a circle
96
97 Parameters
98 ----------
99 diameter:
100 The diameter of the circle and width
101 of the image.
102 dtype:
103 The `dtype` of the image.
104
105 Returns
106 -------
107 circle:
108 A boolean array with ones for the pixels with centers
109 inside of the circle and zeros
110 outside of the circle.
111 """
112 c = (diameter - 1) / 2
113 # The center of the circle and its radius are
114 # off by half a pixel for circles with
115 # even numbered diameter
116 if diameter % 2 == 0:
117 radius = diameter / 2
118 else:
119 radius = c
120 x = np.arange(diameter)
121 x, y = np.meshgrid(x, x)
122 r = np.sqrt((x - c) ** 2 + (y - c) ** 2)
123
124 circle = np.ones((diameter, diameter), dtype=dtype)
125 circle[r > radius] = 0
126 return circle
127
128

◆ integrated_circular_gaussian()

np.ndarray lsst.scarlet.lite.utils.integrated_circular_gaussian ( np.ndarray | None x = None,
np.ndarray | None y = None,
float sigma = 0.8 ) 
Create a circular Gaussian that is integrated over pixels

This is typically used for the model PSF,
working well with the default parameters.

Parameters
----------
x, y:
    The x,y-coordinates to evaluate the integrated Gaussian.
    If `X` and `Y` are `None` then they will both be given the
    default value `numpy.arange(-7, 8)`, resulting in a
    `15x15` centered image.
sigma:
    The standard deviation of the Gaussian.

Returns
-------
image:
    A Gaussian function integrated over `X` and `Y`.

Definition at line 56 of file utils.py.

58) -> np.ndarray:
59 """Create a circular Gaussian that is integrated over pixels
60
61 This is typically used for the model PSF,
62 working well with the default parameters.
63
64 Parameters
65 ----------
66 x, y:
67 The x,y-coordinates to evaluate the integrated Gaussian.
68 If `X` and `Y` are `None` then they will both be given the
69 default value `numpy.arange(-7, 8)`, resulting in a
70 `15x15` centered image.
71 sigma:
72 The standard deviation of the Gaussian.
73
74 Returns
75 -------
76 image:
77 A Gaussian function integrated over `X` and `Y`.
78 """
79 if x is None:
80 if y is None:
81 x = np.arange(-7, 8)
82 y = x
83 else:
84 raise ValueError(
85 f"Either X and Y must be specified, or neither must be specified, got {x=} and {y=}"
86 )
87 elif y is None:
88 raise ValueError(f"Either X and Y must be specified, or neither must be specified, got {x=} and {y=}")
89
90 result = integrated_gaussian_value(x, sigma)[None, :] * integrated_gaussian_value(y, sigma)[:, None]
91 return result / np.sum(result)
92
93

◆ integrated_gaussian_value()

np.ndarray lsst.scarlet.lite.utils.integrated_gaussian_value ( np.ndarray x,
float sigma ) 
A Gaussian function evaluated at `x`

Parameters
----------
x:
    The coordinates to evaluate the integrated Gaussian
    (ie. the centers of pixels).
sigma:
    The standard deviation of the Gaussian.

Returns
-------
gaussian:
    A Gaussian function integrated over `x`

Definition at line 35 of file utils.py.

35def integrated_gaussian_value(x: np.ndarray, sigma: float) -> np.ndarray:
36 """A Gaussian function evaluated at `x`
37
38 Parameters
39 ----------
40 x:
41 The coordinates to evaluate the integrated Gaussian
42 (ie. the centers of pixels).
43 sigma:
44 The standard deviation of the Gaussian.
45
46 Returns
47 -------
48 gaussian:
49 A Gaussian function integrated over `x`
50 """
51 lhs = erfc((0.5 - x) / (sqrt2 * sigma))
52 rhs = erfc((2 * x + 1) / (2 * sqrt2 * sigma))
53 return np.sqrt(np.pi / 2) * sigma * (1 - lhs + 1 - rhs)
54
55

◆ is_attribute_safe_to_transfer()

lsst.scarlet.lite.utils.is_attribute_safe_to_transfer ( name,
value ) 
Return True if an attribute is safe to monkeypatch-transfer to another
class.
This rejects special methods that are defined automatically for all
classes, leaving only those explicitly defined in a class decorated by
`continueClass` or registered with an instance of `TemplateMeta`.

Definition at line 144 of file utils.py.

144def is_attribute_safe_to_transfer(name, value):
145 """Return True if an attribute is safe to monkeypatch-transfer to another
146 class.
147 This rejects special methods that are defined automatically for all
148 classes, leaving only those explicitly defined in a class decorated by
149 `continueClass` or registered with an instance of `TemplateMeta`.
150 """
151 if name.startswith("__") and (
152 value is getattr(object, name, None) or name in INTRINSIC_SPECIAL_ATTRIBUTES
153 ):
154 return False
155 return True
156
157

Variable Documentation

◆ INTRINSIC_SPECIAL_ATTRIBUTES

lsst.scarlet.lite.utils.INTRINSIC_SPECIAL_ATTRIBUTES
Initial value:
1= frozenset(
2 (
3 "__qualname__",
4 "__module__",
5 "__metaclass__",
6 "__dict__",
7 "__weakref__",
8 "__class__",
9 "__subclasshook__",
10 "__name__",
11 "__doc__",
12 )
13)

Definition at line 129 of file utils.py.

◆ ScalarLike

lsst.scarlet.lite.utils.ScalarLike = bool | int | float | complex

Definition at line 28 of file utils.py.

◆ ScalarTypes

tuple lsst.scarlet.lite.utils.ScalarTypes = (bool, int, float, complex)

Definition at line 29 of file utils.py.

◆ sqrt2

lsst.scarlet.lite.utils.sqrt2 = np.sqrt(2)

Definition at line 32 of file utils.py.

Generated on Thu May 16 2024 08:50:43 for LSST Applications by doxygen 1.10.0