gdar-sar 1.2.0.post3__py3-none-any.whl

gdar/io/gsar_info.py

@@ -0,0 +1,657 @@
+#!/usr/bin/python
+# :encoding=utf-8
+
+import copy
+from collections import OrderedDict
+
+import numpy as np
+
+from gdar.base import base, gtime
+from gdar.base.dtype import value_from_dtype
+from gdar.base.meta import make_meta, make_refsys
+from gdar.io.util import add_slc_processing_to_meta
+
+IDL_type_map = (
+    None,  # 0 used for no-data files
+    np.uint8,  # 1
+    np.int16,  # 2 signed short
+    np.int32,  # 3 signed long
+    np.float32,  # 4 single
+    np.float64,  # 5 double
+    np.complex64,  # 6 single-precision complex
+    None,  # 7
+    None,  # 8
+    np.complex128,  # 9 double-precision complex
+    None,  # 10
+    None,  # 11
+    np.uint16,  # 12 unsigned short
+    np.uint32,  # 13 unsigned long
+    np.int64,  # 14 signed long long
+    np.uint64,  # 15 unsigned long long
+)
+
+
+def lc_keys(dct):
+    # return dict([(k.lower(), dct[k]) for k in dct])
+    d = {}
+    for k in dct:
+        v = dct[k]
+        k = k.lower()
+        if k == "ytime":
+            if type(v) is list:
+                v = np.array(v, dtype="datetime64[ns]")
+            else:
+                v = np.datetime64(v, "ns")
+        d[k] = v
+    return d
+
+
+def to_dtype(value):
+    if type(value) is str:
+        return (np.dtype(np.datetime64(value, "ns")),)
+    if type(value) is np.ndarray:
+        return value.dtype, value.shape
+
+    return (np.dtype(type(value)),)
+
+
+def _decode_idl_value(value):
+    """Internal function for odict_from_idl_xml()"""
+
+    if isinstance(value, list):
+        return [_decode_idl_value(x) for x in value]
+    if not isinstance(value, OrderedDict):
+        return value
+    if "@IDLtype" not in value:
+        return value
+        # raise ValueError('XML not written by IDL XML2STRUCT')
+    itype = value["@IDLtype"]
+    if itype == "struct":
+        if "@IDLsize" in value:
+            # Array of structures. Create dtype first:
+            dtp = np.dtype([(kk,) + to_dtype(vv) for kk, vv in value["item"][0].items()])
+            # raise NotImplementedError('Arrays of structures'+
+            # 'not implemented yet')
+            val = np.ndarray(int(value["@IDLsize"]), dtype=dtp)
+            for name in dtp.names:
+                val[name] = np.array([v[name] for v in value["item"]])
+            return val
+
+        val = OrderedDict([(k, _decode_idl_value(value[k])) for k in value if k[0] != "@"])
+        return val
+    if itype == "string":
+        if "@IDLsize" in value:
+            val = np.array([_decode_idl_value(x) for x in value["item"]])
+        else:
+            val = value["#text"] if "#text" in value else ""
+        return val
+    if itype in ["int", "uint", "long", "ulong", "float", "double", "ulong64"]:
+        if itype in ["ulong", "ulong64"]:
+            itype = "uint"
+        val = np.fromstring(value["#text"], dtype=itype, sep=" ")
+    elif itype in ["complex", "dcomplex"]:
+        val = np.fromstring(value["#text"], dtype="double", sep=" ").view("complex")
+    else:
+        raise ValueError("IDLtype: " + itype + " not recognized")
+
+    if "@IDLsize" in value:
+        val.shape = np.fromstring(value["@IDLsize"], dtype="int", sep=" ")[::-1]
+    elif val.shape == (1,):
+        val = val[0]
+    return val
+
+
+# ======================= gdar_info.meta_from_info: ==========================
+
+
+def _instrument_substructure(iii):
+    platform = iii.pop("platform", "")
+
+    if "product" in iii:
+        product = iii.pop("product").split("-")
+        if len(product) > 1:
+            swath = product[-1]
+            mode = ""
+            for field in product[0:-1]:
+                mode += field
+        else:
+            if platform[:2] == "S1":
+                swath = product[0]
+                mode = swath[:-1]
+            else:
+                swath = ""
+                mode = product[0]
+    else:
+        mode, swath = "", ""
+
+    meta_instrument = {
+        "platform": platform,
+        "mode": mode,
+        "swath": swath,
+        "radarfreq": iii.pop("radarfreq", ""),
+        "polarization": iii.pop("polarization", ""),
+        "leftlooking": iii.pop("leftlooking", 0),
+    }
+
+    if "antenna" in iii:
+        meta_instrument["antenna"] = iii.pop("antenna")
+        if "npannels" in meta_instrument["antenna"]:
+            meta_instrument["antenna"]["npanels"] = meta_instrument["antenna"].pop("npannels")
+        if "npanels" not in meta_instrument["antenna"]:
+            meta_instrument["antenna"]["npanels"] = 14
+
+    else:
+        if platform == "ALOS":
+            meta_instrument["antenna"] = {"length": 8.7}
+        if platform == "ALOS2":
+            meta_instrument["antenna"] = {"length": 9.9}
+
+    if "pulse" in iii:
+        meta_instrument["pulse"] = iii.pop("pulse")
+
+    return meta_instrument
+
+
+def refsys_substructure(iii):
+    src_utc = np.datetime64(iii["ytime"], "ns")
+    # truncate to previous whole second boundary
+    yt_ref = np.datetime64(src_utc, "s")
+    # The tag 'orbit' was replaced by 'trajectory' after a short while
+    if "orbit" in iii:
+        iii["trajectory"] = iii["orbit"]
+        del iii["orbit"]
+    leftlook = iii["leftlooking"] if "leftlooking" in iii else 0
+    lookdir = "right" if leftlook == 0 else "left"
+    return make_refsys(
+        {
+            "type": "sar_zd_sr",
+            "utc": yt_ref,
+            "lookdirection": lookdir,
+            "trajectory": iii["trajectory"],
+        }
+    )
+
+
+def is_ytime(key):
+    # print("is_ytime: looking at {}".format(key))
+    return key in ["ytime", "mastergeometry"]
+
+
+conversions = ((is_ytime, gtime.parse_iso8601),)
+
+
+def meta_from_info(info, refgrid=None, nodatavalue=None):
+    """Convert a gdar *info* dictionary into a full metadata tree with grid.
+
+    Translates legacy info fields (trajectory, xtime, doppler, srgr, …) into
+    the canonical metadata structure expected by ``make_meta`` / ``make_grid``.
+
+    Parameters
+    ----------
+    info : dict or Immutable
+        Raw metadata dictionary as read from a ``.info`` / ``.json`` file.
+    refgrid : Grid or None
+        If provided, the output grid is co-registered to this reference.
+    nodatavalue : scalar or None
+        Override for the no-data sentinel; inferred from dtype if *None*.
+
+    Returns
+    -------
+    dict
+        Metadata tree ready for ``make_meta()``.
+    """
+    if isinstance(info, base.Immutable):
+        iii = info[...]
+    else:
+        # Shallow copy, this means only nodes contained in the
+        # root can be deleted from 'iii' without changing 'info'
+        iii = copy.copy(info)
+
+    _meta = {}
+    _meta["format"] = iii["format"]
+    _meta["description"] = iii["description"] if "description" in iii else iii["format"]
+
+    # Various ways of describing data types, translate to numpy dtype
+    if "datatemplate" in iii:
+        _meta["dtype"] = base.dtype_from_dtemplate(iii["datatemplate"])
+
+        del iii["datatemplate"]
+        del iii["datatype"]
+    elif "datatype" in iii:
+        _meta["dtype"] = np.dtype(IDL_type_map[iii["datatype"]])
+        del iii["datatype"]
+    else:
+        raise ValueError("No type information found in info")
+
+    assert "dtype" in _meta, "dtype missing in meta: 87tguIBKJInqhVJQCms"
+
+    _meta["nodatavalue"] = value_from_dtype(_meta["dtype"], value=nodatavalue)
+
+    # The tag 'orbit' was replaced by 'trajectory' after a short while
+    if "orbit" in iii:
+        iii["trajectory"] = iii["orbit"]
+        del iii["orbit"]
+
+    if "trajectory" in iii and "xtime" in iii:
+        if "srgr" in iii:
+            info_type = "sar_zd_gr"
+        elif "gpri" in info:
+            info_type = "gbradar"
+        else:
+            info_type = "sar_zd_sr"
+    else:
+        info_type = ""
+    leftlook = iii["leftlooking"] if "leftlooking" in iii else 0
+    lookdir = "right" if leftlook == 0 else "left"
+    # Grid:
+    inp0 = None
+    inp1 = None
+    if info_type in ["sar_zd_sr", "gbradar"]:
+        # for InSAR, the product name is in the input_0
+        # and input_1 substructures.
+        src_utc = np.datetime64(iii["ytime"], "ns")
+        # truncate to previous whole second boundary
+        yt_ref = np.datetime64(src_utc, "s")
+        yt_orig = (src_utc - yt_ref) / gtime.sec
+
+        _ref = {
+            "type": "sar_zd_sr",
+            "utc": yt_ref,
+            "lookdirection": lookdir,
+            "trajectory": iii["trajectory"],
+        }
+
+        if "input_0" in iii:
+            _ref["ref_0"] = refsys_substructure(iii["input_0"])
+            inp0 = iii.pop("input_0")
+        if "input_1" in iii:
+            _ref["ref_1"] = refsys_substructure(iii["input_1"])
+            inp1 = iii.pop("input_1")
+        my_ref = make_refsys(_ref)
+
+        # for coreg data, the grid must be taken from the reference geometry
+        # and the relative orbit defines the alternate refsys 'ref_0'
+        if refgrid is not None:
+            grid = refgrid[...]
+            # grid['ref_0'] = my_ref
+            refs = grid["refsys"][...]
+            refs["original"] = my_ref
+            grid["refsys"] = refs
+        else:
+            grid = {
+                # TODO: Check with orbit's t_ref
+                "origin": np.array([yt_orig, iii["xtime"]]),
+                "shape": np.array([iii["ysize"], iii["xsize"]]),
+                "samplespacing": np.array([1.0 / iii["ysamplefreq"], 1.0 / iii["xsamplefreq"]]),
+                "refsys": my_ref,
+            }
+        _meta["grid"] = grid
+        # Only keeping doppler from input0??
+        if (
+            ("doppler" in iii) or (inp0 is not None and "doppler" in inp0)
+        ) and info_type == "sar_zd_sr":
+            curdop = iii["doppler"] if ("doppler" in iii) else inp0["doppler"]
+            if "ytime" in curdop:
+                dopytime = curdop["ytime"]
+                dopval = curdop["offset"]
+            else:
+                dopytime = [yt_ref, yt_ref + np.timedelta64(1, "s")]
+                dopval = np.repeat(curdop["offset"][np.newaxis, :], 2, axis=0)
+            dopyarr = np.array(dopytime, "M8[ns]")
+            if not dopyarr.shape:
+                # Doppler time is scalar, make array with two elements
+                dopyarr = np.asarray(
+                    [
+                        np.datetime64(dopytime, "[ns]"),
+                        np.datetime64(dopytime, "[ns]") + np.timedelta64(1, "s"),
+                    ]
+                )
+                dopval = np.repeat(curdop["offset"][np.newaxis, :], 2, axis=0)
+            dop = {
+                "rgtime": curdop["xtime"],
+                "utc": dopyarr,
+                "values": dopval,
+            }
+            _meta["doppler"] = {"centroid": dop}
+            if "doppler" in iii:
+                del iii["doppler"]
+
+        del iii["xtime"]
+        del iii["ytime"]
+        del iii["xsamplefreq"]
+        del iii["ysamplefreq"]
+        del iii["statevector"]
+        del iii["trajectory"]
+
+        # For InSAR products, preserve original refsys's
+        for orig_i in range(2):
+            subkey = "input_{}".format(orig_i)
+            subref = "ref_{}".format(orig_i)
+            if subkey in iii:
+                m0 = meta_from_info(iii[subkey])
+                del iii[subkey]
+                _meta["grid"][subref] = m0.grid.refsys
+                # Delete grid/refsys from substructure
+                mm = m0[..., ...]
+                del mm["grid"]
+                _meta[subkey] = base.immutable(mm)
+
+    elif info_type == "sar_zd_gr":
+        # Ground range products, need a slant range refsys
+        # but different accessors
+
+        # TODO: Unify with sar_zd_sr, above
+
+        gr_orig = 0  # How to detect when gr origin is not zero?
+
+        if isinstance(iii["srgr"], list) or isinstance(iii["srgr"], np.ndarray):
+            groff = iii["srgr"][0]["offset"][0]
+            aztime = iii["srgr"]["ytime"]
+            grsr = iii["srgr"]["srgr_coeff"]
+            gr0 = iii["srgr"]["gr0"]
+        else:
+            groff = iii["srgr"]["offset"][0]
+            sft = np.asarray([-3, 3]) * gtime.sec
+            aztime = np.asarray(np.datetime64(iii["srgr"]["ytime"]) + sft).astype("datetime64[ns]")
+            grsr = np.row_stack((iii["srgr"]["srgr_coeff"], iii["srgr"]["srgr_coeff"]))
+            gr0 = np.repeat(iii["srgr"]["gr0"], 2)
+        # truncate to previous whole second boundary
+        utc_ref = np.min(aztime).astype("datetime64[s]").astype("datetime64[ns]")
+        my_srref = make_refsys(
+            {
+                "type": "sar_zd_sr",
+                "utc": utc_ref,
+                "lookdirection": lookdir,
+                "trajectory": iii["trajectory"],
+            }
+        )
+
+        # assert abs(groff - round(groff)) < 1e-4, 'noninteger offset'
+        # GSAR doesn't have 'origin', so 'srgr.offset' has
+        # taken some of that role for ground range refsys
+        # srgr.offset is in units of pixels, refsys.origin in refsys coordinates
+        # need samplespacing to fix this:
+        ssp = np.array([1.0 / iii["ysamplefreq"], iii["xspacing"]])
+        src_utc = np.datetime64(iii["ytime"], "ns")
+        coo_orig = np.array([(src_utc - utc_ref) / gtime.sec, gr_orig + groff * ssp[1]])
+
+        grspace = iii["xspacing"]
+        gr_max = grspace * iii["xsize"]
+
+        # Assume gr->sr polynomials are valid 50 km outside the product in
+        # either direction.
+        # Necessary for geocoding, at least until interpolators are NaN-tolerant
+        # Need to limit somewhat to avoid going outside valid areas for cooefficients.
+        grbd = np.min([55000.0, gr_max])
+
+        range_mapping = {
+            "utc": aztime,
+            "gr0": gr0,
+            "tol": np.array([1e-5]),
+            "grsr_coeff": grsr,  # in GSAR, 'srgr' maps from ground to slant range
+        }
+        # In gdar, as in Sentinel-1, the opposite is true
+
+        # Possible to do sanity check here :
+        # assert polyval(grsr_coeff, 0-gr0) == iii['srgr']['xtime']*const.c/2
+
+        my_ref = make_refsys(
+            {
+                "type": "sar_zd_gr",
+                "utc": utc_ref,
+                "range_mapping": range_mapping,
+                "grlim": np.array([-grbd, gr_max + grbd]) + coo_orig[1],
+                "sr_ref": my_srref,
+            }
+        )
+
+        # The GR grid is in units of [azimuth seconds, ground range metres]
+        _meta["grid"] = {
+            "origin": coo_orig,
+            "shape": np.array([iii["ysize"], iii["xsize"]]),
+            "samplespacing": ssp,
+            "offset": np.array([0, 0], dtype=np.int64),
+            "refsys": my_ref,
+        }
+        """ No doppler for grd products?
+        if 'doppler' in iii and 'ytime' in iii['doppler']:
+            dop = {
+                'rgtime': iii['doppler']['xtime'],
+                'utc': np.array(iii['doppler']['ytime'], 'M8[ns]'),
+                'values': iii['doppler']['offset'],
+            }
+            _meta['doppler'] = {'centroid': dop}
+            del iii['doppler']
+        """
+        del iii["xtime"]
+        del iii["ytime"]
+        del iii["xsamplefreq"]
+        del iii["ysamplefreq"]
+        del iii["xspacing"]
+        del iii["yspacing"]
+        del iii["statevector"]
+        del iii["trajectory"]
+        del iii["srgr"]
+
+    else:
+        _meta["grid"] = {
+            "origin": np.array([0, 0]),
+            "shape": np.array([iii["ysize"], iii["xsize"]]),
+            "samplespacing": np.array([1, 1]),
+            "refsys": {"type": ""},
+        }
+    del iii["xsize"]
+    del iii["ysize"]
+    del iii["format"]
+    del iii["nchannels"]
+    del iii["endian"]
+
+    # Instrument:
+    if info_type in ["sar_zd_sr", "sar_zd_gr", "gbradar"]:
+        if inp0 is not None:
+            void = _instrument_substructure(iii)
+            _meta["instrument"] = _instrument_substructure(inp0)
+        elif inp1 is not None:
+            void = _instrument_substructure(iii)
+            _meta["instrument"] = _instrument_substructure(inp1)
+        else:
+            _meta["instrument"] = _instrument_substructure(iii)
+
+    if info_type in ["sar_zd_sr"]:
+        if "azsweeprate" in _meta["instrument"]:
+            if _meta["instrument"]["azsweeprate"] != 0:
+                raise ValueError("Need to subtract Sweep from Doppler Centroid RIGHT NOW!")
+
+    if ("gate" in iii) or (inp0 is not None and "gate" in inp0):
+        _gate = _reform_gate(iii.pop("gate") if "gate" in iii else inp0["gate"], my_ref["utc"])
+        try:
+            igate = dict(_gate)
+        except ValueError:
+            igate = {}
+            for ik in _gate.dtype.names:
+                igate[ik] = _gate[ik]
+        _meta["gate"] = igate
+    procdicts = {}
+    for bwkey, winkey, metakey in zip(
+        ["ybandwidth", "xbandwidth"],
+        ["ywindowfunc", "xwindowfunc"],
+        ["azimuth", "range"],
+    ):
+        if bwkey in iii or winkey in iii:
+            pmeta = {}
+            if _meta["format"] == "SLC":
+                pmeta["numberoflooks"] = 1  # What to do for non-SLCs?
+            if bwkey in iii:
+                pmeta["totalbandwidth"] = iii.pop(bwkey)
+            if winkey in iii:
+                win = iii.pop(winkey)
+                if win.lower().startswith("hanning"):
+                    pmeta["windowtype"] = "general_hamming"
+                    if len(win.lower().split(" ")) > 1:
+                        # assumes format 'HANNING (0.90)'
+                        pmeta["windowparameters"] = float(win.lower().split(" ")[1][1:-1])
+                else:
+                    pmeta["windowtype"] = win.lower()
+            procdicts[metakey] = pmeta
+    if len(procdicts) == 2:
+        add_slc_processing_to_meta(_meta, procdicts["azimuth"], procdicts["range"])
+
+    for ifgtag in ["dt", "baseline", "nlooks"]:
+        if ifgtag in iii:
+            if "interferogram" not in _meta:
+                _meta["interferogram"] = {}
+            if ifgtag == "nlooks":
+                _meta["interferogram"][ifgtag] = iii.pop(ifgtag)[::-1]
+            else:
+                _meta["interferogram"][ifgtag] = iii.pop(ifgtag)
+
+    _meta["info_leftovers"] = {}
+    for kk in iii:
+        if kk == "geometricdoppler" or kk == "attitude":
+            idict = iii[kk].copy()
+            idict["ytime"] = np.asarray([gtime.parse_iso8601(iteri) for iteri in idict["ytime"]])
+            _meta["info_leftovers"][kk] = idict
+        else:
+            _meta["info_leftovers"][kk] = iii[kk]
+
+    if inp0 is not None:
+        for kk in [
+            "procfacility",
+            "procsoftware",
+            "calib",
+            "xwindowfunc",
+            "ywindowfunc",
+            "geometricdoppler",
+            "attitude",
+            "mastergeometry",
+        ]:
+            if kk in inp0:
+                if kk == "geometricdoppler" or kk == "attitude":
+                    inp0[kk]["ytime"] = np.asarray(
+                        [gtime.parse_iso8601(iteri) for iteri in inp0[kk]["ytime"]]
+                    )
+                _meta["info_leftovers"][kk] = inp0[kk]
+
+        for kk in ["xbandwidth", "ybandwidth"]:
+            if inp1 is not None:
+                val = min([inp0[kk], inp1[kk]])
+            else:
+                val = inp0[kk]
+            _meta["info_leftovers"][kk] = val
+
+    mm = make_meta(_meta, conversions=conversions)
+    # keyboard()
+    return mm
+
+
+def _reform_gate(_gate, utc_ref):
+    newgate = {}
+    newgate["shape"] = np.asarray([_gate["ysize"], _gate["xsize"]]).astype(np.int32)
+    newgate["samplespacing"] = np.asarray([1 / _gate["ysamplefreq"], 1 / _gate["xsamplefreq"]])
+    y0 = (gtime.parse_iso8601(_gate["ytime"]) - utc_ref) / gtime.sec
+    newgate["origin"] = np.asarray([y0, _gate["xtime"]])
+    newgate["offset"] = np.zeros(2)
+    return newgate
+
+
+class Struct:
+    """This class is used for its members, not its methods.
+
+    The primary convenience lies in saying foo.bar instead of foo['bar'].
+    In addition, some automatic translation is done during instantiation,
+    e.g. timestamps into datetime64 objects, and datatype specifications.
+    """
+
+    def __init__(self, d=None):
+        if d is None:
+            return
+
+        for k in d:
+            v = d[k]
+            # print("k: {}, v: {}".format(k, v))
+            if k.lower() == "datatype":
+                if isinstance(v, int):
+                    v = IDL_type_map[v]
+            elif type(v) is list:
+                if type(v[0]) is dict:
+                    # v = DataFrame(v)
+                    # Check for simple special case [{'re': xx, 'im': yy}, ...]
+                    if set(v[0].keys()) == set(["re", "im"]):
+                        v = np.array(v.re.values + 1j * v.im.values)
+            elif type(v) is dict:
+                v = Struct(v)
+            # elif type(v) in [unicode, str]:
+            elif type(v) in [str]:
+                try:
+                    v = np.datetime64(v)
+                except ValueError:
+                    pass
+            setattr(self, k.lower(), v)
+
+        # figure out dtype from datatype/datatemplate later
+        # must co
+        # if hasattr(self, 'datatemplate'):
+        #    self.dtype = dtype_from_dtemplate(self.datatemplate.lower())
+        # elif hasattr(self, 'datatype'):
+        #    self.datatype = np.dtype(IDL_type_map[self.datatype])
+
+    # Support iteration over keys and values, deferring to underlying dict
+    def __iter__(self):
+        return iter(self.__dict__)
+
+    def __setitem__(self, key, val):
+        # print("setting {0} to {1} in {2}".format(key, val, self))
+        setattr(self, key, val)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def set(self, **kw):
+        for k in kw:
+            self[k] = kw[k]
+
+    def copy(self):
+        return Struct(self)
+
+    def __repr__(self, level=4):
+        d = self.__dict__
+        return "%s(%s)" % (
+            self.__class__.__name__,
+            (",\n" + " " * level).join(
+                "%s=%s" % (k, (d[k].__repr__(level + 4) if isinstance(d[k], Struct) else d[k]))
+                for k in d
+            ),
+        )
+
+    def tohash(self):
+        h = {}
+        for k in self.__dict__:
+            v = self.__dict__[k]
+            if k == "datatype":
+                try:
+                    h[k] = IDL_type_map.index(v)
+                    continue
+                except ValueError:
+                    # structured types, parse them here
+                    # print("datatype missing")
+                    # keyboard()
+                    pass
+            elif isinstance(v, Struct):
+                h[k] = v.tohash()
+                continue
+            elif isinstance(v, np.datetime64):
+                h[k] = str(v)
+                continue
+            elif isinstance(v, np.ndarray):
+                if np.iscomplexobj(v):
+                    h[k] = [{"re": x.real, "im": x.imag} for x in v]
+                    continue
+                if len(v.dtype) == 0:
+                    h[k] = [str(x) for x in v]
+                    continue
+            elif isinstance(v, DataFrame):
+                print(k + ": DataFrame")
+                keyboard()
+            else:
+                h[k] = v
+        return h