Debian Codegraph @

asdf_astropy/converters/transform/polynomial.py

raw
1 import numpy as np
2 from packaging.version import parse as parse_version
3
4 from asdf_astropy.converters.helpers import parse_tag_version
5
6 from .core import TransformConverterBase
7
8
9 class PolynomialConverter(TransformConverterBase):
10 """
11 ASDF support for serializing the 1D and 2D polynomial models.
12 """
13
14 # Schema versions prior to 1.2 included an unrelated "domain"
15 # property. We can't serialize the new domain values with those
16 # versions because they don't validate.
17 _DOMAIN_WINDOW_MIN_VERSION = parse_version("1.2.0")
18
19 tags = ("tag:stsci.edu:asdf/transform/polynomial-*",)
20 types = (
21 "astropy.modeling.polynomial.Polynomial1D",
22 "astropy.modeling.polynomial.Polynomial2D",
23 )
24
25 def to_yaml_tree_transform(self, model, tag, ctx):
26 from astropy.modeling.polynomial import Polynomial1D, Polynomial2D
27
28 if isinstance(model, Polynomial1D):
29 coefficients = np.array(model.parameters)
30 elif isinstance(model, Polynomial2D):
31 degree = model.degree
32 coefficients = np.zeros((degree + 1, degree + 1))
33 for i in range(degree + 1):
34 for j in range(degree + 1):
35 if i + j < degree + 1:
36 name = "c" + str(i) + "_" + str(j)
37 coefficients[i, j] = getattr(model, name).value
38
39 node = {"coefficients": coefficients}
40
41 if parse_tag_version(tag) >= self._DOMAIN_WINDOW_MIN_VERSION:
42 if model.n_inputs == 1:
43 if model.domain is not None:
44 node["domain"] = model.domain
45 if model.window is not None:
46 node["window"] = model.window
47 else:
48 if model.x_domain or model.y_domain is not None:
49 node["domain"] = (model.x_domain, model.y_domain)
50 if model.x_window or model.y_window is not None:
51 node["window"] = (model.x_window, model.y_window)
52
53 return node
54
55 def from_yaml_tree_transform(self, node, tag, ctx):
56 from astropy.modeling.polynomial import Polynomial1D, Polynomial2D
57
58 coefficients = np.asarray(node["coefficients"])
59 n_dim = coefficients.ndim
60
61 if n_dim == 1:
62 domain = node.get("domain", None)
63 window = node.get("window", None)
64
65 model = Polynomial1D(coefficients.size - 1, domain=domain, window=window)
66 model.parameters = coefficients
67 elif n_dim == 2: # noqa: PLR2004
68 x_domain, y_domain = tuple(node.get("domain", (None, None)))
69 x_window, y_window = tuple(node.get("window", (None, None)))
70 shape = coefficients.shape
71 degree = shape[0] - 1
72 if shape[0] != shape[1]:
73 msg = "Coefficients must be an (n+1, n+1) matrix"
74 raise TypeError(msg)
75
76 coeffs = {}
77 for i in range(shape[0]):
78 for j in range(shape[0]):
79 if i + j < degree + 1:
80 name = "c" + str(i) + "_" + str(j)
81 coeffs[name] = coefficients[i, j]
82 model = Polynomial2D(
83 degree,
84 x_domain=x_domain,
85 y_domain=y_domain,
86 x_window=x_window,
87 y_window=y_window,
88 **coeffs,
89 )
90 else:
91 msg = "astropy supports only 1D or 2D polynomial models"
92 raise NotImplementedError(msg)
93
94 return model
95
96
97 _CLASS_NAME_TO_POLY_INFO = {
98 "Legendre1D": ("legendre", 1),
99 "Legendre2D": ("legendre", 2),
100 "Chebyshev1D": ("chebyshev", 1),
101 "Chebyshev2D": ("chebyshev", 2),
102 "Hermite1D": ("hermite", 1),
103 "Hermite2D": ("hermite", 2),
104 }
105
106 _POLY_INFO_TO_CLASS_NAME = {v: k for k, v in _CLASS_NAME_TO_POLY_INFO.items()}
107
108
109 class OrthoPolynomialConverter(TransformConverterBase):
110 """
111 ASDF support for serializing models that inherit
112 OrthoPolyomialBase.
113 """
114
115 # Map of model class name to (polynomial type, number of dimensions) tuple:
116
117 tags = ("tag:stsci.edu:asdf/transform/ortho_polynomial-*",)
118 types = (
119 "astropy.modeling.polynomial.Legendre1D",
120 "astropy.modeling.polynomial.Legendre2D",
121 "astropy.modeling.polynomial.Chebyshev1D",
122 "astropy.modeling.polynomial.Chebyshev2D",
123 "astropy.modeling.polynomial.Hermite1D",
124 "astropy.modeling.polynomial.Hermite2D",
125 )
126
127 def to_yaml_tree_transform(self, model, tag, ctx):
128 poly_type = _CLASS_NAME_TO_POLY_INFO[model.__class__.__name__][0]
129 if model.n_inputs == 1:
130 coefficients = np.array(model.parameters)
131 else:
132 coefficients = np.zeros((model.x_degree + 1, model.y_degree + 1))
133 for i in range(model.x_degree + 1):
134 for j in range(model.y_degree + 1):
135 name = f"c{i}_{j}"
136 coefficients[i, j] = getattr(model, name).value
137
138 node = {"polynomial_type": poly_type, "coefficients": coefficients}
139
140 if model.n_inputs == 1:
141 if model.domain is not None:
142 node["domain"] = model.domain
143 if model.window is not None:
144 node["window"] = model.window
145 else:
146 if model.x_domain or model.y_domain is not None:
147 node["domain"] = (model.x_domain, model.y_domain)
148 if model.x_window or model.y_window is not None:
149 node["window"] = (model.x_window, model.y_window)
150
151 return node
152
153 def from_yaml_tree_transform(self, node, tag, ctx):
154 from astropy.modeling import polynomial
155
156 coefficients = np.asarray(node["coefficients"])
157 poly_type = node["polynomial_type"]
158 n_dim = coefficients.ndim
159
160 class_name = _POLY_INFO_TO_CLASS_NAME[(poly_type, n_dim)]
161 model_type = getattr(polynomial, class_name)
162
163 coefficients = np.asarray(node["coefficients"])
164 if n_dim == 1:
165 domain = node.get("domain", None)
166 window = node.get("window", None)
167 model = model_type(coefficients.size - 1, domain=domain, window=window)
168 model.parameters = coefficients
169 elif n_dim == 2: # noqa: PLR2004
170 x_domain, y_domain = tuple(node.get("domain", (None, None)))
171 x_window, y_window = tuple(node.get("window", (None, None)))
172 coeffs = {}
173 shape = coefficients.shape
174 x_degree = shape[0] - 1
175 y_degree = shape[1] - 1
176 for i in range(x_degree + 1):
177 for j in range(y_degree + 1):
178 name = f"c{i}_{j}"
179 coeffs[name] = coefficients[i, j]
180 model = model_type(
181 x_degree,
182 y_degree,
183 x_domain=x_domain,
184 y_domain=y_domain,
185 x_window=x_window,
186 y_window=y_window,
187 **coeffs,
188 )
189 else:
190 msg = "astropy supports only 1D or 2D polynomial models"
191 raise NotImplementedError(msg)
192
193 return model