| 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 |