xradio 0.0.50__py3-none-any.whl → 0.0.52__py3-none-any.whl

xradio/_utils/dict_helpers.py

@@ -43,6 +43,30 @@ def make_time_measure_attrs(units=["s"], scale="utc", time_format="mjd") -> dict
     return {"units": u, "scale": scale, "format": time_format, "type": "time"}
 
 
+def make_time_measure_dict(data, units=["s"], scale="utc", time_format="mjd") -> dict:
+    """
+    create a time measure dictionary given value and units
+    Parameters
+    ----------
+    value : numeric or array of numerics
+        Time value
+    units: str
+        Time units
+    scale: str
+        Time scale
+    time_format: str
+        Time format
+    Returns
+    -------
+    dict
+    """
+    x = {}
+    x["attrs"] = make_time_measure_attrs(units, scale, time_format)
+    x["data"] = data
+    x["dims"] = []
+    return x
+
+
 def make_time_coord_attrs(units=["s"], scale="utc", time_format="mjd") -> dict:
     """
     create a time measure dictionary given value and units

xradio/_utils/schema.py

@@ -190,14 +190,14 @@ casacore_to_msv4_measure_type = {
             "LSRK": "lsrk",
             "LSRD": "lsrd",
             "BARY": "BARY",
-            "GEO": "GEO",
+            "GEO": "gcrs",
             "TOPO": "TOPO",
         },  # The frames/observer we are not sure if/how to translate to astropy are uppercase
     },
     "position": {
         "type": "location",
         "Ref": "frame",
-        "Ref_map": {"ITRF": "GRS80"},
+        "Ref_map": {"ITRF": "ITRS"},
     },
     "uvw": {
         "type": "uvw",

xradio/image/_util/_casacore/xds_from_casacore.py

@@ -10,7 +10,7 @@ import numpy as np
 import xarray as xr
 from astropy import units as u
 from casacore import tables
-from casacore.images import coordinates
+from casacore.images import coordinates, image as casa_image
 
 from .common import (
     _active_mask,
@@ -32,10 +32,11 @@ from ..common import (
 from ...._utils._casacore.tables import extract_table_attributes, open_table_ro
 from xradio._utils.coord_math import _deg_to_rad
 from xradio._utils.dict_helpers import (
-    make_quantity,
+    _casacore_q_to_xradio_q,
     make_frequency_reference_dict,
+    make_quantity,
     make_skycoord_dict,
-    _casacore_q_to_xradio_q,
+    make_time_measure_dict,
 )
 
 
@@ -89,19 +90,126 @@ def _add_mask(
     return xds
 
 
+def _casa_image_to_xds_image_attrs(image: casa_image, history: bool = True) -> dict:
+    """
+    get the image attributes from the casacoreimage object
+    """
+    meta_dict = image.info()
+    coord_dict = copy.deepcopy(meta_dict["coordinates"])
+    attrs = {}
+    attrs[_image_type] = image.info()["imageinfo"]["imagetype"]
+    attrs["units"] = image.unit()
+    attrs["telescope"] = {}
+    telescope = attrs["telescope"]
+    for k in ("observer", "obsdate", "telescope", "telescopeposition"):
+        if k.startswith("telescope"):
+            if k == "telescope":
+                telescope["name"] = coord_dict[k]
+            elif k in coord_dict:
+                casa_pos = coord_dict[k]
+                location = {}
+                loc_attrs = {}
+                loc_attrs["type"] = "location"
+                loc_attrs["frame"] = casa_pos["refer"]
+                """
+                if casa_pos["refer"] == "ITRF":
+                    loc_attrs["ellipsoid"] = "GRS80"
+                """
+                loc_attrs["units"] = [
+                    casa_pos["m0"]["unit"],
+                    casa_pos["m1"]["unit"],
+                    casa_pos["m2"]["unit"],
+                ]
+                loc_attrs["coordinate_system"] = "geocentric"
+                loc_attrs["origin_object_name"] = "earth"
+                location["attrs"] = loc_attrs
+                location["data"] = [
+                    casa_pos["m0"]["value"],
+                    casa_pos["m1"]["value"],
+                    casa_pos["m2"]["value"],
+                ]
+                telescope["location"] = location
+                """
+                del (
+                    telescope["position"]["refer"],
+                    telescope["position"]["m0"],
+                    telescope["position"]["m1"],
+                    telescope["position"]["m2"],
+                )
+                """
+        elif k == "obsdate":
+            obsdate = coord_dict[k]
+            """
+            o_attrs = {"type": "time"}
+            o_attrs["scale"] = coord_dict[k]["refer"]
+            myu = coord_dict[k]["m0"]["unit"]
+            o_attrs["units"] = myu if isinstance(myu, list) else [myu]
+            o_attrs["format"] = _get_time_format(m0["value"], m0["unit"])
+            o_date = {}
+            o_date["attrs"] = o_attrs
+            """
+            m0 = obsdate["m0"]
+            attrs["obsdate"] = make_time_measure_dict(
+                data=m0["value"],
+                units=m0["unit"],
+                scale=obsdate["refer"],
+                time_format=_get_time_format(m0["value"], m0["unit"]),
+            )
+        else:
+            attrs[k] = coord_dict[k] if k in coord_dict else ""
+    dir_key = next((k for k in coord_dict if k.startswith("direction")), None)
+    if dir_key:
+        frame, eqnx = _convert_direction_system(coord_dict[dir_key]["system"], "system")
+    else:
+        frame = "icrs"
+        logger.warning(
+            "No direction coordinate found from which "
+            "to get pointing center frame. Assuming ICRS"
+        )
+    # it looks like the pointing center is always in radians in a casa image coord system dict
+    # note that in a casa image, the pointing center does not explicitly have a reference frame
+    # associated with it.
+    # point_center = coord_dict["pointingcenter"]
+    attrs[_pointing_center] = make_skycoord_dict(
+        coord_dict["pointingcenter"]["value"].tolist(), ["rad", "rad"], frame
+    )
+    imageinfo = meta_dict["imageinfo"]
+    obj = "objectname"
+    attrs[_object_name] = imageinfo[obj] if obj in imageinfo else ""
+    attrs["user"] = meta_dict["miscinfo"]
+    defmask = "Image_defaultmask"
+    with open_table_ro(image.name()) as casa_table:
+        # the actual mask is a data var and data var names are all caps by convention
+        attrs[_active_mask] = (
+            casa_table.getkeyword(defmask).upper()
+            if defmask in casa_table.keywordnames()
+            else None
+        )
+    attrs["description"] = None
+    # if also loading history, put it as another xds in the image attrs
+    if history:
+        htable = os.sep.join([os.path.abspath(image.name()), "logtable"])
+        if os.path.isdir(htable):
+            attrs["history"] = read_generic_table(htable)
+        else:
+            logger.warning(
+                f"Unable to find history table {htable}. History will not be included"
+            )
+    return attrs
+
+
 def _add_sky_or_aperture(
     xds: xr.Dataset,
     ary: Union[np.ndarray, da.array],
     dimorder: list,
     img_full_path: str,
     has_sph_dims: bool,
+    history: bool,
 ) -> xr.Dataset:
     xda = xr.DataArray(ary, dims=dimorder).astype(ary.dtype)
     with _open_image_ro(img_full_path) as casa_image:
-        image_type = casa_image.info()["imageinfo"]["imagetype"]
-        unit = casa_image.unit()
-    xda.attrs[_image_type] = image_type
-    xda.attrs["units"] = unit
+        xda.attrs = _casa_image_to_xds_image_attrs(casa_image, history)
+    # xds.attrs = attrs
     name = "SKY" if has_sph_dims else "APERTURE"
     xda = xda.rename(name)
     xds[xda.name] = xda
@@ -143,7 +251,7 @@ def _add_vel_attrs(xds: xr.Dataset, coord_dict: dict) -> xr.Dataset:
     return xds
 
 
-def _casa_image_to_xds_attrs(img_full_path: str, history: bool = True) -> dict:
+def _casa_image_to_xds_attrs(img_full_path: str) -> dict:
     """
     Get the xds level attribut/es as a python dictionary
     """
@@ -187,67 +295,6 @@ def _casa_image_to_xds_attrs(img_full_path: str, history: bool = True) -> dict:
             if j in coord_dir_dict:
                 dir_dict[j] = coord_dir_dict[j]
         attrs["direction"] = dir_dict
-    attrs["telescope"] = {}
-    telescope = attrs["telescope"]
-    attrs["obsdate"] = {"type": "time"}
-    obsdate = attrs["obsdate"]
-    attrs[_pointing_center] = coord_dict["pointingcenter"].copy()
-    for k in ("observer", "obsdate", "telescope", "telescopeposition"):
-        if k.startswith("telescope"):
-            if k == "telescope":
-                telescope["name"] = coord_dict[k]
-            elif k in coord_dict:
-                telescope["position"] = coord_dict[k]
-                telescope["position"]["ellipsoid"] = telescope["position"]["refer"]
-                if telescope["position"]["refer"] == "ITRF":
-                    telescope["position"]["ellipsoid"] = "GRS80"
-                telescope["position"]["units"] = [
-                    telescope["position"]["m0"]["unit"],
-                    telescope["position"]["m1"]["unit"],
-                    telescope["position"]["m2"]["unit"],
-                ]
-                telescope["position"]["value"] = [
-                    telescope["position"]["m0"]["value"],
-                    telescope["position"]["m1"]["value"],
-                    telescope["position"]["m2"]["value"],
-                ]
-                del (
-                    telescope["position"]["refer"],
-                    telescope["position"]["m0"],
-                    telescope["position"]["m1"],
-                    telescope["position"]["m2"],
-                )
-        elif k == "obsdate":
-            obsdate["scale"] = coord_dict[k]["refer"]
-            myu = coord_dict[k]["m0"]["unit"]
-            obsdate["units"] = myu if isinstance(myu, list) else [myu]
-            obsdate["value"] = coord_dict[k]["m0"]["value"]
-            obsdate["format"] = _get_time_format(obsdate["value"], obsdate["units"])
-            obsdate["type"] = "time"
-        else:
-            attrs[k] = coord_dict[k] if k in coord_dict else ""
-    imageinfo = meta_dict["imageinfo"]
-    obj = "objectname"
-    attrs[_object_name] = imageinfo[obj] if obj in imageinfo else ""
-    attrs["user"] = meta_dict["miscinfo"]
-    defmask = "Image_defaultmask"
-    with open_table_ro(img_full_path) as casa_table:
-        # the actual mask is a data var and data var names are all caps by convention
-        attrs[_active_mask] = (
-            casa_table.getkeyword(defmask).upper()
-            if defmask in casa_table.keywordnames()
-            else None
-        )
-    attrs["description"] = None
-    # if also loading history, put it as another xds in the attrs
-    if history:
-        htable = os.sep.join([img_full_path, "logtable"])
-        if os.path.isdir(htable):
-            attrs["history"] = read_generic_table(htable)
-        else:
-            logger.warning(
-                f"Unable to find history table {htable}. History will not be included"
-            )
     return copy.deepcopy(attrs)
 
 

xradio/image/_util/_casacore/xds_to_casacore.py

@@ -19,12 +19,16 @@ def _compute_direction_dict(xds: xr.Dataset) -> dict:
     """
     direction = {}
     xds_dir = xds.attrs["direction"]
+    direction["_axes_sizes"] = np.array(
+        [xds.sizes[dim] for dim in ("l", "m")], dtype=np.int32
+    )
+    direction["_image_axes"] = np.array([2, 3], dtype=np.int32)
     direction["system"] = xds_dir["reference"]["attrs"]["equinox"].upper()
     if direction["system"] == "J2000.0":
         direction["system"] = "J2000"
     direction["projection"] = xds_dir["projection"]
     direction["projection_parameters"] = xds_dir["projection_parameters"]
-    direction["units"] = np.array(xds_dir["reference"]["attrs"]["units"], dtype="<U16")
+    direction["units"] = xds_dir["reference"]["attrs"]["units"]
     direction["crval"] = np.array(xds_dir["reference"]["data"])
     direction["cdelt"] = np.array((xds.l[1] - xds.l[0], xds.m[1] - xds.m[0]))
     direction["crpix"] = _compute_sky_reference_pixel(xds)
@@ -34,9 +38,9 @@ def _compute_direction_dict(xds: xr.Dataset) -> dict:
     for s in ["longpole", "latpole"]:
         m = "lonpole" if s == "longpole" else s
         # lonpole, latpole are numerical values in degrees in casa images
-        direction[s] = Angle(
-            str(xds_dir[m]["data"]) + xds_dir[m]["attrs"]["units"][0]
-        ).deg
+        direction[s] = float(
+            Angle(str(xds_dir[m]["data"]) + xds_dir[m]["attrs"]["units"][0]).deg
+        )
     return direction
 
 
@@ -69,6 +73,8 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     for a CASA image coordinate system
     """
     spec = {}
+    spec["_axes_sizes"] = np.array([xds.sizes["frequency"]], dtype=np.int32)
+    spec["_image_axes"] = np.array([0], dtype=np.int32)
     spec["formatUnit"] = ""
     spec["name"] = "Frequency"
     # spec["nativeType"] = _native_types.index(xds.frequency.attrs["native_type"])
@@ -76,7 +82,7 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     spec["nativeType"] = 0
     spec["restfreq"] = xds.frequency.attrs["rest_frequency"]["data"]
     # spec["restfreqs"] = copy.deepcopy(xds.frequency.attrs["restfreqs"]["value"])
-    spec["restfreqs"] = [spec["restfreq"]]
+    spec["restfreqs"] = np.array([spec["restfreq"]])
     spec["system"] = xds.frequency.attrs["reference_value"]["attrs"]["observer"].upper()
     u = xds.frequency.attrs["reference_value"]["attrs"]["units"]
     spec["unit"] = u if isinstance(u, str) else u[0]
@@ -88,53 +94,65 @@ def _compute_spectral_dict(xds: xr.Dataset) -> dict:
     wcs = {}
     wcs["ctype"] = "FREQ"
     wcs["pc"] = 1.0
-    wcs["crval"] = xds.frequency.attrs["reference_value"]["data"]
-    wcs["cdelt"] = xds.frequency.values[1] - xds.frequency.values[0]
-    wcs["crpix"] = (wcs["crval"] - xds.frequency.values[0]) / wcs["cdelt"]
+    wcs["crval"] = float(xds.frequency.attrs["reference_value"]["data"])
+    wcs["cdelt"] = float(xds.frequency.values[1] - xds.frequency.values[0])
+    wcs["crpix"] = float((wcs["crval"] - xds.frequency.values[0]) / wcs["cdelt"])
     spec["wcs"] = wcs
     return spec
 
 
 def _coord_dict_from_xds(xds: xr.Dataset) -> dict:
     coord = {}
-    coord["telescope"] = xds.attrs["telescope"]["name"]
-    coord["observer"] = xds.attrs["observer"]
+    sky_ap = "SKY" if "SKY" in xds.data_vars else "APERTURE"
+    if "telescope" in xds[sky_ap].attrs:
+        tel = xds[sky_ap].attrs["telescope"]
+        if "name" in tel:
+            coord["telescope"] = xds[sky_ap].attrs["telescope"]["name"]
+        if "location" in tel:
+            xds_telloc = tel["location"]
+            telloc = {}
+            telloc["refer"] = xds_telloc["attrs"]["frame"]
+            if telloc["refer"] == "GRS80":
+                telloc["refer"] = "ITRF"
+            for i in range(3):
+                telloc[f"m{i}"] = {
+                    "unit": xds_telloc["attrs"]["units"][i],
+                    "value": xds_telloc["data"][i],
+                }
+            telloc["type"] = "position"
+            coord["telescopeposition"] = telloc
+    if "observer" in xds[sky_ap].attrs:
+        coord["observer"] = xds[sky_ap].attrs["observer"]
     obsdate = {}
     obsdate["refer"] = xds.coords["time"].attrs["scale"]
     obsdate["type"] = "epoch"
     obsdate["m0"] = {}
     obsdate["m0"]["unit"] = xds.coords["time"].attrs["units"][0]
-    obsdate["m0"]["value"] = xds.coords["time"].values[0]
+    obsdate["m0"]["value"] = float(xds.coords["time"].values[0])
     coord["obsdate"] = obsdate
-    coord["pointingcenter"] = xds.attrs[_pointing_center].copy()
-    if "position" in xds.attrs["telescope"]:
-        telpos = {}
-        telpos["refer"] = xds.attrs["telescope"]["position"]["ellipsoid"]
-        if xds.attrs["telescope"]["position"]["ellipsoid"] == "GRS80":
-            telpos["refer"] = "ITRF"
-        for i in range(3):
-            telpos[f"m{i}"] = {
-                "unit": xds.attrs["telescope"]["position"]["units"][i],
-                "value": xds.attrs["telescope"]["position"]["value"][i],
-            }
-        telpos["type"] = "position"
-        coord["telescopeposition"] = telpos
+    if _pointing_center in xds[sky_ap].attrs:
+        coord["pointingcenter"] = {
+            "initial": True,
+            "value": xds[sky_ap].attrs[_pointing_center]["data"],
+        }
     if "l" in xds.coords:
         coord["direction0"] = _compute_direction_dict(xds)
     else:
         coord["linear0"] = _compute_linear_dict(xds)
     coord["stokes1"] = {
-        "axes": np.array(["Stokes"], dtype="<U16"),
+        "_axes_sizes": np.array([xds.sizes["polarization"]], dtype=np.int32),
+        "_image_axes": np.array([1], dtype=np.int32),
+        "axes": ["Stokes"],
         "cdelt": np.array([1.0]),
         "crpix": np.array([0.0]),
         "crval": np.array([1.0]),
         "pc": np.array([[1.0]]),
-        "stokes": np.array(xds.polarization.values, dtype="<U16"),
+        "stokes": xds.polarization.values.tolist(),
     }
     coord["spectral2"] = _compute_spectral_dict(xds)
-    coord["pixelmap0"] = np.array([0, 1])
-    coord["pixelmap1"] = np.array([2])
-    coord["pixelmap2"] = np.array([3])
+    coord["pixelmap0"] = np.array([0, 1], dtype=np.int32)
+    coord["pixelmap1"] = np.array([2], dtype=np.int32)
+    coord["pixelmap2"] = np.array([3], dtype=np.int32)
     coord["pixelreplace0"] = np.array([0.0, 0.0])
     coord["pixelreplace1"] = np.array([0.0])
     coord["pixelreplace2"] = np.array([0.0])
@@ -144,7 +162,6 @@ def _coord_dict_from_xds(xds: xr.Dataset) -> dict:
     # this probbably needs some verification
     coord["worldreplace0"] = [0.0, 0.0]
     coord["worldreplace1"] = np.array(coord["stokes1"]["crval"])
-    # print("spectral", coord["spectral2"])
     coord["worldreplace2"] = np.array(coord["spectral2"]["wcs"]["crval"])
     return coord
 
@@ -181,7 +198,7 @@ def _imageinfo_dict_from_xds(xds: xr.Dataset) -> dict:
     ii["image_type"] = (
         xds[ap_sky].attrs["image_type"] if "image_type" in xds[ap_sky].attrs else ""
     )
-    ii["objectname"] = xds.attrs[_object_name]
+    ii["objectname"] = xds[ap_sky].attrs[_object_name]
     if "BEAM" in xds.data_vars:
         # multi beam
         pp = {}
@@ -231,7 +248,9 @@ def _write_casa_data(xds: xr.Dataset, image_full_path: str) -> None:
         else ("frequency", "polarization", "v", "u")
     )
     casa_image_shape = xds[sky_ap].isel(time=0).transpose(*trans_coords).shape[::-1]
-    active_mask = xds.attrs["active_mask"] if _active_mask in xds.attrs else ""
+    active_mask = (
+        xds[sky_ap].attrs["active_mask"] if _active_mask in xds[sky_ap].attrs else ""
+    )
     masks = []
     masks_rec = {}
     mask_rec = {

xradio/image/_util/_fits/xds_from_fits.py

@@ -17,9 +17,10 @@ from ..common import (
 )
 from xradio._utils.coord_math import _deg_to_rad
 from xradio._utils.dict_helpers import (
-    make_quantity,
     make_frequency_reference_dict,
+    make_quantity,
     make_skycoord_dict,
+    make_time_measure_dict,
 )
 import copy
 import dask
@@ -49,7 +50,7 @@ def _fits_image_to_xds(
     sphr_dims = helpers["sphr_dims"]
     ary = _read_image_array(img_full_path, chunks, helpers, verbose)
     dim_order = _get_xds_dim_order(sphr_dims)
-    xds = _add_sky_or_aperture(xds, ary, dim_order, helpers, sphr_dims)
+    xds = _add_sky_or_aperture(xds, ary, dim_order, header, helpers, sphr_dims)
     xds.attrs = attrs
     xds = _add_coord_attrs(xds, helpers)
     if helpers["has_multibeam"]:
@@ -70,13 +71,7 @@ def _add_coord_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
 
 def _add_time_attrs(xds: xr.Dataset, helpers: dict) -> xr.Dataset:
     time_coord = xds.coords["time"]
-    meta = copy.deepcopy(helpers["obsdate"])
-    del meta["value"]
-    # meta["units"] = [ meta["units"] ]
-    # meta['format'] = 'MJD'
-    # meta['time_scale'] = meta['refer']
-    # del meta['refer']
-    time_coord.attrs = meta
+    time_coord.attrs = copy.deepcopy(helpers["obsdate"]["attrs"])
     xds.assign_coords(time=time_coord)
     return xds
 
@@ -176,15 +171,6 @@ def _xds_direction_attrs_from_header(helpers: dict, header) -> dict:
     direction["reference"] = make_skycoord_dict(
         [0.0, 0.0], units=["rad", "rad"], frame=ref_sys
     )
-    """
-    direction["reference"] = {
-        "type": "sky_coord",
-        "frame": ref_sys,
-        "equinox": ref_eqx,
-        "units": ["rad", "rad"],
-        "value": [0.0, 0.0],
-    }
-    """
     dir_axes = helpers["dir_axes"]
     ddata = []
     dunits = []
@@ -261,18 +247,21 @@ def _get_telescope_metadata(helpers: dict, header) -> dict:
         r = np.sqrt(np.sum(xyz * xyz))
         lat = np.arcsin(z / r)
         long = np.arctan2(y, x)
-        tel["position"] = {
-            "type": "position",
-            # I haven't seen a FITS keyword for reference frame of telescope posiiton
-            "ellipsoid": "GRS80",
-            "units": ["rad", "rad", "m"],
-            "value": np.array([long, lat, r]),
+        tel["location"] = {
+            "attrs": {
+                "coordinate_system": "geocentric",
+                # I haven't seen a FITS keyword for reference frame of telescope posiiton
+                "frame": "ITRF",
+                "origin_object_name": "earth",
+                "type": "location",
+                "units": ["rad", "rad", "m"],
+            },
+            "data": np.array([long, lat, r]),
         }
-        helpers["tel_pos"] = tel["position"]
     return tel
 
 
-def _pointing_center_to_metadata(helpers: dict, header) -> dict:
+def _compute_pointing_center(helpers: dict, header) -> dict:
     # Neither helpers or header is modified
     t_axes = helpers["t_axes"]
     long_unit = header[f"CUNIT{t_axes[0]}"]
@@ -285,7 +274,9 @@ def _pointing_center_to_metadata(helpers: dict, header) -> dict:
     pc_lat = float(header[f"CRVAL{t_axes[1]}"]) * unit[1]
     pc_long = pc_long.to(u.rad).value
     pc_lat = pc_lat.to(u.rad).value
-    return {"value": np.array([pc_long, pc_lat]), "initial": True}
+    return make_skycoord_dict(
+        [pc_long, pc_lat], units=["rad", "rad"], frame=helpers["ref_sys"]
+    )
 
 
 def _user_attrs_from_header(header) -> dict:
@@ -382,7 +373,7 @@ def _create_dim_map(helpers: dict, header) -> dict:
     return dim_map
 
 
-def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> dict:
+def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> tuple:
     primary = None
     beams = None
     for hdu in hdulist:
@@ -418,9 +409,7 @@ def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> dict:
     if dir_axes is not None:
         attrs["direction"] = _xds_direction_attrs_from_header(helpers, header)
     # FIXME read fits data in chunks in case all data too large to hold in memory
-    has_mask = da.any(da.isnan(primary.data)).compute()
-    attrs["active_mask"] = "MASK0" if has_mask else None
-    helpers["has_mask"] = has_mask
+    helpers["has_mask"] = da.any(da.isnan(primary.data)).compute()
     beam = _beam_attr_from_header(helpers, header)
     if beam != "mb":
         helpers["beam"] = beam
@@ -432,24 +421,15 @@ def _fits_header_to_xds_attrs(hdulist: fits.hdu.hdulist.HDUList) -> dict:
             helpers["dtype"] = "float64"
         else:
             raise RuntimeError(f'Unhandled data type {header["BITPIX"]}')
-    helpers["btype"] = header["BTYPE"] if "BTYPE" in header else None
-    helpers["bunit"] = header["BUNIT"] if "BUNIT" in header else None
-    attrs["object_name"] = header["OBJECT"] if "OBJECT" in header else None
-    obsdate = {}
-    obsdate["type"] = "time"
-    obsdate["value"] = Time(header["DATE-OBS"], format="isot").mjd
-    obsdate["units"] = ["d"]
-    obsdate["scale"] = header["TIMESYS"]
-    obsdate["format"] = "MJD"
-    attrs["obsdate"] = obsdate
-    helpers["obsdate"] = obsdate
-    attrs["observer"] = header["OBSERVER"]
-    attrs["pointing_center"] = _pointing_center_to_metadata(helpers, header)
-    attrs["description"] = None
-    attrs["telescope"] = _get_telescope_metadata(helpers, header)
+    helpers["obsdate"] = make_time_measure_dict(
+        data=Time(header["DATE-OBS"], format="isot").mjd,
+        units=["d"],
+        scale=header["TIMESYS"],
+        time_format="MJD",
+    )
+
     # TODO complete _make_history_xds when spec has been finalized
     # attrs['history'] = _make_history_xds(header)
-    attrs["user"] = _user_attrs_from_header(header)
     return attrs, helpers, header
 
 
@@ -532,7 +512,7 @@ def _create_coords(
 
 
 def _get_time_values(helpers):
-    return [helpers["obsdate"]["value"]]
+    return [helpers["obsdate"]["data"]]
 
 
 def _get_pol_values(helpers):
@@ -710,14 +690,22 @@ def _add_sky_or_aperture(
     xds: xr.Dataset,
     ary: Union[np.ndarray, da.array],
     dim_order: list,
+    header,
     helpers: dict,
     has_sph_dims: bool,
 ) -> xr.Dataset:
     xda = xr.DataArray(ary, dims=dim_order)
-    image_type = helpers["btype"]
-    unit = helpers["bunit"]
-    xda.attrs[_image_type] = image_type
-    xda.attrs["units"] = unit
+    for h, a in zip(
+        ["BUNIT", "BTYPE", "OBJECT", "OBSERVER"],
+        ["units", _image_type, "object_name", "observer"],
+    ):
+        if h in header:
+            xda.attrs[a] = header[h]
+    xda.attrs["obsdate"] = helpers["obsdate"].copy()
+    xda.attrs["pointing_center"] = _compute_pointing_center(helpers, header)
+    xda.attrs["telescope"] = _get_telescope_metadata(helpers, header)
+    xda.attrs["description"] = None
+    xda.attrs["user"] = _user_attrs_from_header(header)
     name = "SKY" if has_sph_dims else "APERTURE"
     xda = xda.rename(name)
     xds[xda.name] = xda
@@ -727,6 +715,9 @@ def _add_sky_or_aperture(
         mask.attrs = {}
         mask = mask.rename("MASK0")
         xds["MASK0"] = mask
+        xda.attrs["active_mask"] = "MASK0"
+    xda = xda.rename(name)
+    xds[xda.name] = xda
     return xds
 
 

xradio/image/_util/_zarr/common.py

@@ -13,4 +13,4 @@ _np_types = {
     "int64": np.int64,
 }
 
-_top_level_sub_xds = "_attrs_xds"
+_top_level_sub_xds = "_attrs_xds_"