sarkit-convert 0.1.0__tar.gz → 0.2.0__tar.gz

{sarkit_convert-0.1.0 → sarkit_convert-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarkit-convert
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python library for converting SAR data to standard formats.
 Author-Email: Valkyrie Systems Corporation <info@govsco.com>
 License: MIT
@@ -16,37 +16,27 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
 Requires-Dist: lxml>=5.1.0
 Requires-Dist: numpy>=1.26.3
-Requires-Dist: sarkit[verification]>=0.6.0
+Requires-Dist: pyproj>=3.7.2
+Requires-Dist: sarkit>=1.3.0
+Requires-Dist: scipy>=1.15.1
 Provides-Extra: iceye
 Requires-Dist: h5py>=3.12.1; extra == "iceye"
 Requires-Dist: python-dateutil>=2.9.0; extra == "iceye"
 Provides-Extra: cosmo
+Requires-Dist: astropy>=6.0.0; extra == "cosmo"
 Requires-Dist: h5py>=3.12.1; extra == "cosmo"
 Requires-Dist: python-dateutil>=2.9.0; extra == "cosmo"
-Requires-Dist: scipy>=1.15.1; extra == "cosmo"
 Requires-Dist: shapely>=2.0.2; extra == "cosmo"
-Provides-Extra: tsx
-Requires-Dist: lxml>=5.1.0; extra == "tsx"
-Requires-Dist: python-dateutil>=2.9.0; extra == "tsx"
-Requires-Dist: sarkit[verification]>=0.5.0; extra == "tsx"
-Requires-Dist: scipy>=1.15.1; extra == "tsx"
+Provides-Extra: terrasar
+Requires-Dist: python-dateutil>=2.9.0; extra == "terrasar"
 Provides-Extra: sentinel
 Requires-Dist: python-dateutil>=2.9.0; extra == "sentinel"
-Requires-Dist: scipy>=1.15.1; extra == "sentinel"
 Requires-Dist: tifffile>=2025.5.10; extra == "sentinel"
 Provides-Extra: all
 Requires-Dist: sarkit-convert[iceye]; extra == "all"
 Requires-Dist: sarkit-convert[cosmo]; extra == "all"
-Requires-Dist: sarkit-convert[tsx]; extra == "all"
+Requires-Dist: sarkit-convert[terrasar]; extra == "all"
 Requires-Dist: sarkit-convert[sentinel]; extra == "all"
-Provides-Extra: dev-lint
-Requires-Dist: ruff>=0.3.0; extra == "dev-lint"
-Requires-Dist: mypy>=1.8.0; extra == "dev-lint"
-Requires-Dist: types-python-dateutil>=2.9.0; extra == "dev-lint"
-Provides-Extra: dev-test
-Requires-Dist: pytest>=7.4.4; extra == "dev-test"
-Provides-Extra: dev
-Requires-Dist: sarkit-convert[dev-lint,dev-test]; extra == "dev"
 Description-Content-Type: text/markdown
 
 <div align="center">

{sarkit_convert-0.1.0 → sarkit_convert-0.2.0}/pyproject.toml

@@ -21,9 +21,11 @@ dynamic = []
 dependencies = [
     "lxml>=5.1.0",
     "numpy>=1.26.3",
-    "sarkit[verification]>=0.6.0",
+    "pyproj>=3.7.2",
+    "sarkit>=1.3.0",
+    "scipy>=1.15.1",
 ]
-version = "0.1.0"
+version = "0.2.0"
 
 [project.license]
 text = "MIT"
@@ -34,43 +36,28 @@ iceye = [
     "python-dateutil>=2.9.0",
 ]
 cosmo = [
+    "astropy>=6.0.0",
     "h5py>=3.12.1",
     "python-dateutil>=2.9.0",
-    "scipy>=1.15.1",
     "shapely>=2.0.2",
 ]
-tsx = [
-    "lxml>=5.1.0",
+terrasar = [
     "python-dateutil>=2.9.0",
-    "sarkit[verification]>=0.5.0",
-    "scipy>=1.15.1",
 ]
 sentinel = [
     "python-dateutil>=2.9.0",
-    "scipy>=1.15.1",
     "tifffile>=2025.5.10",
 ]
 all = [
     "sarkit-convert[iceye]",
     "sarkit-convert[cosmo]",
-    "sarkit-convert[tsx]",
+    "sarkit-convert[terrasar]",
     "sarkit-convert[sentinel]",
 ]
-dev-lint = [
-    "ruff>=0.3.0",
-    "mypy>=1.8.0",
-    "types-python-dateutil>=2.9.0",
-]
-dev-test = [
-    "pytest>=7.4.4",
-]
-dev = [
-    "sarkit-convert[dev-test,dev-lint]",
-]
 
 [dependency-groups]
 test = [
-    "nox>=2024.3.2",
+    "nox>=2025.2.9",
 ]
 doc = [
     "sphinx>=7.2.6",
@@ -78,6 +65,16 @@ doc = [
     "sphinx-rtd-theme>=2.0.0",
     "sphinxcontrib-autoprogram>=0.1.9",
 ]
+dev-lint = [
+    "ruff>=0.3.0",
+    "mypy>=1.8.0",
+    "types-python-dateutil>=2.9.0",
+]
+dev-test = [
+    "pytest>=7.4.4",
+    "smart-open[http]>=7.5",
+    "tifffile>=2025.5.10",
+]
 
 [build-system]
 requires = [
@@ -109,8 +106,10 @@ preview = true
 
 [[tool.mypy.overrides]]
 module = [
+    "astropy.*",
     "h5py.*",
     "lxml.*",
+    "pyproj.*",
     "scipy.*",
     "shapely.*",
 ]

{sarkit_convert-0.1.0 → sarkit_convert-0.2.0}/sarkit_convert/_utils.py

@@ -124,6 +124,38 @@ def polyfit2d_tol(x, y, z, max_order_x, max_order_y, tol, strict_tol=False):
     return best[0]
 
 
+def polyshift(poly, new_origin):
+    """Returns new polynomial with shifted origin
+
+    Args
+    ----
+    poly: array-like
+        1d polynomial coefficients, with constant term first
+    new_origin: float
+        location in `poly`'s domain to place new polynomial's origin
+
+    Returns
+    -------
+    new_poly
+        polynomial of same order as `poly` for which new_poly(0) == poly(new_origin)
+    """
+
+    working_coeffs = np.array(list(reversed(poly)))
+    output_coeffs = []
+
+    for _ in np.arange(len(poly)):
+        quot = np.zeros(shape=working_coeffs.shape)
+        rem = 0.0
+        for ndx, val in enumerate(working_coeffs):
+            carry = rem * new_origin
+            rem = val + carry
+            quot[ndx] = rem
+        output_coeffs.append(rem)
+        working_coeffs = quot[:-1]
+
+    return np.array(output_coeffs)
+
+
 def broadening_from_amp(amp_vals, threshold_db=None):
     """Compute the broadening factor from amplitudes
 

sarkit_convert-0.2.0/sarkit_convert/_version.py

@@ -0,0 +1 @@
+__version__ = '0.2.0'

sarkit_convert-0.1.0/sarkit_convert/csk.py → sarkit_convert-0.2.0/sarkit_convert/cosmo.py

@@ -17,8 +17,12 @@ metadata that would predict the complex data characteristics
 
 import argparse
 import contextlib
+import datetime
 import pathlib
 
+import astropy.coordinates as apcoord
+import astropy.units as apu
+import astropy.utils
 import dateutil.parser
 import h5py
 import lxml.builder
@@ -30,9 +34,13 @@ import sarkit.verification
 import sarkit.wgs84
 import scipy.constants
 import scipy.optimize
+import scipy.spatial.transform
 
+from sarkit_convert import __version__
 from sarkit_convert import _utils as utils
 
+astropy.utils.iers.conf.autodownload = False
+
 NSMAP = {
     "sicd": "urn:SICD:1.4.0",
 }
@@ -130,7 +138,6 @@ def hdf5_to_sicd(
     h5_filename,
     sicd_filename,
     classification,
-    ostaid,
     img_str,
     chan_index,
     tx_polarizations,
@@ -141,8 +148,10 @@ def hdf5_to_sicd(
         mission_id = h5_attrs["Mission ID"]
         if mission_id == "CSG":
             dataset_str = "IMG"
+            burst_str = "B0001"
         else:
             dataset_str = "SBI"
+            burst_str = "B001"
         sample_data_h5_path = f"{img_str}/{dataset_str}"
         sample_data_shape = h5file[sample_data_h5_path].shape
         sample_data_dtype = h5file[sample_data_h5_path].dtype
@@ -171,7 +180,6 @@ def hdf5_to_sicd(
 
     # Creation Info
     creation_time = dateutil.parser.parse(h5_attrs["Product Generation UTC"])
-    creation_site = h5_attrs["Processing Centre"]
     l0_ver = h5_attrs.get("L0 Software Version", "NONE")
     l1_ver = h5_attrs.get("L1A Software Version", "NONE")
     creation_application = f"L0: {l0_ver}, L1: {l1_ver}"
@@ -311,31 +319,34 @@ def hdf5_to_sicd(
     range_rate_per_hz = -scipy.constants.speed_of_light / (2 * center_frequency)
     range_rate = doppler_centroid * range_rate_per_hz
     range_rate_rate = doppler_rate * range_rate_per_hz
-    doppler_centroid_poly = utils.polyfit2d(
+    doppler_centroid_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         doppler_centroid.flatten(),
         4,
         4,
+        1e-2,
     )
-    doppler_rate_poly = utils.polyfit2d(
+    doppler_rate_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         doppler_rate.flatten(),
         4,
         4,
+        1e-3,
     )
     time_ca_samps = time_coords[..., 1] - start_minus_ref
     time_ca_poly = npp.polyfit(
         grid_coords[..., 1].flatten(), time_ca_samps.flatten(), 1
     )
     time_coa_samps = time_ca_samps + range_rate / range_rate_rate
-    time_coa_poly = utils.polyfit2d(
+    time_coa_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         time_coa_samps.flatten(),
         4,
         4,
+        1e-3,
     )
 
     range_ca = time_coords[..., 0] * scipy.constants.speed_of_light / 2
@@ -344,12 +355,13 @@ def hdf5_to_sicd(
         axis=0,
     )
     drsf = range_rate_rate * range_ca / speed_ca**2
-    drsf_poly = utils.polyfit2d(
+    drsf_poly = utils.polyfit2d_tol(
         grid_coords[..., 0].flatten(),
         grid_coords[..., 1].flatten(),
         drsf.flatten(),
         4,
         4,
+        1e-6,
     )
 
     llh_ddm = h5_attrs["Scene Centre Geodetic Coordinates"]
@@ -398,23 +410,176 @@ def hdf5_to_sicd(
     uspz = spz / npl.norm(spz)
     u_col = np.cross(uspz, u_row)
 
+    # Antenna
+    attitude_quaternion = np.roll(h5_attrs["Attitude Quaternions"], -1, axis=1)
+    attitude_times = h5_attrs["Attitude Times"]
+    attitude_utcs = [
+        ref_time + datetime.timedelta(seconds=attitude_time)
+        for attitude_time in attitude_times
+    ]
+
+    inertial_position = h5_attrs["Inertial Satellite Position"]
+    inertial_velocity = h5_attrs["Inertial Satellite Velocity"]
+    inertial_acceleration = h5_attrs["Inertial Satellite Acceleration"]
+    eci_apc_poly = utils.fit_state_vectors(
+        (0, (collection_stop_time - collection_start_time).total_seconds()),
+        h5_attrs["State Vectors Times"]
+        - (collection_start_time - ref_time).total_seconds(),
+        inertial_position,
+        inertial_velocity,
+        inertial_acceleration,
+        order=5,
+    )
+
+    def get_nadir_plane_at_time(time):
+        obstime = collection_start_time + datetime.timedelta(seconds=time)
+        eci_pos = npp.polyval(time, eci_apc_poly)
+        eci_vel = npp.polyval(time, npp.polyder(eci_apc_poly))
+
+        # Derived from https://adsabs.harvard.edu/full/2006ESASP.606E..35C, Section 3
+        z_sc = -eci_pos / np.linalg.norm(eci_pos)
+        y_sc_dir = np.cross(z_sc, eci_vel)
+        y_sc = y_sc_dir / np.linalg.norm(y_sc_dir)
+        x_sc = np.cross(y_sc, z_sc)
+        eci_2_ecf = np.array(
+            [
+                apcoord.GCRS(
+                    apcoord.CartesianRepresentation(1, 0, 0, unit=apu.m),
+                    obstime=obstime,
+                )
+                .transform_to(apcoord.ITRS(obstime=obstime))
+                .data.xyz.value,
+                apcoord.GCRS(
+                    apcoord.CartesianRepresentation(0, 1, 0, unit=apu.m),
+                    obstime=obstime,
+                )
+                .transform_to(apcoord.ITRS(obstime=obstime))
+                .data.xyz.value,
+                apcoord.GCRS(
+                    apcoord.CartesianRepresentation(0, 0, 1, unit=apu.m),
+                    obstime=obstime,
+                )
+                .transform_to(apcoord.ITRS(obstime=obstime))
+                .data.xyz.value,
+            ]
+        )
+        x_sc = x_sc @ eci_2_ecf
+        y_sc = y_sc @ eci_2_ecf
+        z_sc = z_sc @ eci_2_ecf
+        return np.array([x_sc, y_sc, z_sc])
+
+    rel_att_times = np.array(
+        [(att_utc - collection_start_time).total_seconds() for att_utc in attitude_utcs]
+    )
+    good_indices = np.where(
+        np.logical_and(
+            np.less(-60, rel_att_times),
+            np.less(rel_att_times, 60 + collection_duration),
+        )
+    )
+    good_times = rel_att_times[good_indices]
+    good_att_quat = attitude_quaternion[good_indices]
+    nadir_planes = [get_nadir_plane_at_time(time) for time in good_times]
+    body_frame = np.array(
+        [
+            scipy.spatial.transform.Rotation.from_quat(att_quat)
+            .inv()
+            .apply(nadir_plane.T)
+            .T
+            for att_quat, nadir_plane in zip(good_att_quat, nadir_planes)
+        ]
+    )
+
+    ux_rot = body_frame[:, 0, :]
+    uy_rot = body_frame[:, 1, :]
+
+    ant_x_dir_poly = utils.fit_state_vectors(
+        (0, (collection_stop_time - collection_start_time).total_seconds()),
+        good_times,
+        ux_rot,
+        None,
+        None,
+        order=4,
+    )
+    ant_y_dir_poly = utils.fit_state_vectors(
+        (0, (collection_stop_time - collection_start_time).total_seconds()),
+        good_times,
+        uy_rot,
+        None,
+        None,
+        order=4,
+    )
+
+    freq_zero = h5_attrs["Radar Frequency"]
+    antenna_beam_elevation = h5_attrs[img_str]["Antenna Beam Elevation"]
+    fit_order = 4
+
+    def fit_steering(code_change_lines, dcs):
+        if len(code_change_lines) > 1:
+            times = code_change_lines / prf
+            return npp.polyfit(times, dcs, fit_order)
+        else:
+            return np.array(dcs).reshape((1,))
+
+    if radar_mode_type != "STRIPMAP":
+        azimuth_ramp_code_change_lines = h5_attrs[img_str][burst_str][
+            "Azimuth Ramp Code Change Lines"
+        ]
+        azimuth_steering = h5_attrs[img_str][burst_str]["Azimuth Steering"]
+        elevation_ramp_code_change_lines = h5_attrs[img_str][burst_str][
+            "Elevation Ramp Code Change Lines"
+        ]
+        elevation_steering = h5_attrs[img_str][burst_str]["Elevation Steering"]
+        eb_dcx = np.sin(np.deg2rad(azimuth_steering))
+        eb_dcx_poly = fit_steering(azimuth_ramp_code_change_lines, eb_dcx)
+        eb_dcy = -np.sin(np.deg2rad(antenna_beam_elevation + elevation_steering))
+        eb_dcy_poly = fit_steering(elevation_ramp_code_change_lines, eb_dcy)
+    else:
+        eb_dcx_poly = [0.0]
+        eb_dcy_poly = [-np.sin(np.deg2rad(antenna_beam_elevation))]
+
+    antenna_az_gains = h5_attrs[img_str]["Azimuth Antenna Pattern Gains"]
+    antenna_az_origin = h5_attrs[img_str]["Azimuth Antenna Pattern Origin"]
+    antenna_az_spacing = h5_attrs[img_str]["Azimuth Antenna Pattern Resolution"]
+
+    antenna_rg_gains = h5_attrs[img_str]["Range Antenna Pattern Gains"]
+    antenna_rg_origin = h5_attrs[img_str]["Range Antenna Pattern Origin"]
+    antenna_rg_spacing = h5_attrs[img_str]["Range Antenna Pattern Resolution"]
+
+    def fit_gains(origin, spacing, gains):
+        fit_limit = -9
+        array_mask = gains > fit_limit
+        dcs = np.sin(np.deg2rad(origin + spacing * np.arange(len(gains))))
+        return npp.polyfit(dcs[array_mask], gains[array_mask], fit_order)
+
+    antenna_array_gain = np.zeros((fit_order + 1, fit_order + 1), dtype=float)
+    antenna_array_gain[0, :] = fit_gains(
+        antenna_rg_origin, antenna_rg_spacing, antenna_rg_gains
+    )
+    antenna_array_gain[:, 0] = fit_gains(
+        antenna_az_origin, antenna_az_spacing, antenna_az_gains
+    )
+    antenna_array_gain[0, 0] = 0.0
+
     # Build XML
     sicd = lxml.builder.ElementMaker(
         namespace=NSMAP["sicd"], nsmap={None: NSMAP["sicd"]}
     )
-    collection_info = sicd.CollectionInfo(
+    sicd_xml_obj = sicd.SICD()
+    sicd_ew = sksicd.ElementWrapper(sicd_xml_obj)
+
+    sicd_ew["CollectionInfo"] = sicd.CollectionInfo(
         sicd.CollectorName(collector_name),
         sicd.CoreName(core_name),
         sicd.CollectType("MONOSTATIC"),
         sicd.RadarMode(sicd.ModeType(radar_mode_type), sicd.ModeID(radar_mode_id)),
         sicd.Classification(classification),
     )
-    image_creation = sicd.ImageCreation(
+    sicd_ew["ImageCreation"] = sicd.ImageCreation(
         sicd.Application(creation_application),
         sicd.DateTime(creation_time.isoformat() + "Z"),
-        sicd.Site(creation_site),
     )
-    image_data = sicd.ImageData(
+    sicd_ew["ImageData"] = sicd.ImageData(
         sicd.PixelType(pixel_type),
         sicd.NumRows(str(num_rows)),
         sicd.NumCols(str(num_cols)),
@@ -434,7 +599,7 @@ def hdf5_to_sicd(
         return [sicd.Lat(str(arr[0])), sicd.Lon(str(arr[1]))]
 
     # Placeholder locations
-    geo_data = sicd.GeoData(
+    sicd_ew["GeoData"] = sicd.GeoData(
         sicd.EarthModel("WGS_84"),
         sicd.SCP(sicd.ECF(*make_xyz(scp_ecf)), sicd.LLH(*make_llh(scp_llh))),
         sicd.ImageCorners(
@@ -468,7 +633,7 @@ def hdf5_to_sicd(
     col_window_name = h5_attrs["Azimuth Focusing Weighting Function"]
     col_window_coeff = h5_attrs["Azimuth Focusing Weighting Coefficient"]
 
-    grid = sicd.Grid(
+    sicd_ew["Grid"] = sicd.Grid(
         sicd.ImagePlane("SLANT"),
         sicd.Type("RGZERO"),
         sicd.TimeCOAPoly(),
@@ -503,33 +668,27 @@ def hdf5_to_sicd(
             ),
         ),
     )
-    sksicd.Poly2dType().set_elem(grid.find("./{*}TimeCOAPoly"), time_coa_poly)
-    sksicd.Poly2dType().set_elem(grid.find("./{*}Row/{*}DeltaKCOAPoly"), [[0]])
-    sksicd.Poly2dType().set_elem(
-        grid.find("./{*}Col/{*}DeltaKCOAPoly"), col_deltakcoa_poly
-    )
+    sicd_ew["Grid"]["TimeCOAPoly"] = time_coa_poly
+    sicd_ew["Grid"]["Row"]["DeltaKCOAPoly"] = [[0]]
+    sicd_ew["Grid"]["Col"]["DeltaKCOAPoly"] = col_deltakcoa_poly
     rcs_row_sf = None
     rcs_col_sf = None
     if row_window_name == "HAMMING":
         wgts = scipy.signal.windows.general_hamming(512, row_window_coeff, sym=True)
-        wgtfunc = sicd.WgtFunct()
-        sksicd.TRANSCODERS["Grid/Row/WgtFunct"].set_elem(wgtfunc, wgts)
-        grid.find("./{*}Row").append(wgtfunc)
+        sicd_ew["Grid"]["Row"]["WgtFunct"] = wgts
         row_broadening_factor = utils.broadening_from_amp(wgts)
         row_wid = row_broadening_factor / row_bw
-        sksicd.DblType().set_elem(grid.find("./{*}Row/{*}ImpRespWid"), row_wid)
+        sicd_ew["Grid"]["Row"]["ImpRespWid"] = row_wid
         rcs_row_sf = 1 + np.var(wgts) / np.mean(wgts) ** 2
     if col_window_name == "HAMMING":
         wgts = scipy.signal.windows.general_hamming(512, col_window_coeff, sym=True)
-        wgtfunc = sicd.WgtFunct()
-        sksicd.TRANSCODERS["Grid/Col/WgtFunct"].set_elem(wgtfunc, wgts)
-        grid.find("./{*}Col").append(wgtfunc)
+        sicd_ew["Grid"]["Col"]["WgtFunct"] = wgts
         col_broadening_factor = utils.broadening_from_amp(wgts)
         col_wid = col_broadening_factor / col_bw
-        sksicd.DblType().set_elem(grid.find("./{*}Col/{*}ImpRespWid"), col_wid)
+        sicd_ew["Grid"]["Col"]["ImpRespWid"] = col_wid
         rcs_col_sf = 1 + np.var(wgts) / np.mean(wgts) ** 2
 
-    timeline = sicd.Timeline(
+    sicd_ew["Timeline"] = sicd.Timeline(
         sicd.CollectStart(collection_start_time.isoformat() + "Z"),
         sicd.CollectDuration(str(collection_duration)),
         sicd.IPP(
@@ -544,10 +703,9 @@ def hdf5_to_sicd(
             ),
         ),
     )
-    sksicd.PolyType().set_elem(timeline.find("./{*}IPP/{*}Set/{*}IPPPoly"), [0, prf])
+    sicd_ew["Timeline"]["IPP"]["Set"][0]["IPPPoly"] = [0, prf]
 
-    position = sicd.Position(sicd.ARPPoly())
-    sksicd.XyzPolyType().set_elem(position.find("./{*}ARPPoly"), apc_poly)
+    sicd_ew["Position"]["ARPPoly"] = apc_poly
 
     rcv_channels = sicd.RcvChannels(
         {"size": str(len(tx_rcv_pols))},
@@ -559,7 +717,7 @@ def hdf5_to_sicd(
             )
         )
 
-    radar_collection = sicd.RadarCollection(
+    sicd_ew["RadarCollection"] = sicd.RadarCollection(
         sicd.TxFrequency(sicd.Min(str(tx_freq_min)), sicd.Max(str(tx_freq_max))),
         sicd.Waveform(
             {"size": "1"},
@@ -577,7 +735,7 @@ def hdf5_to_sicd(
         rcv_channels,
     )
     if len(tx_polarizations) > 1:
-        radar_collection.find("./{*}TxPolarization").text = "SEQUENCE"
+        sicd_ew["RadarCollection"]["TxPolarization"] = "SEQUENCE"
         tx_sequence = sicd.TxSequence({"size": str(len(tx_polarizations))})
         for ndx, tx_pol in enumerate(tx_polarizations):
             tx_sequence.append(
@@ -585,7 +743,12 @@ def hdf5_to_sicd(
             )
         rcv_channels.addprevious(tx_sequence)
 
-    image_formation = sicd.ImageFormation(
+    now = (
+        datetime.datetime.now(datetime.timezone.utc)
+        .isoformat(timespec="microseconds")
+        .replace("+00:00", "Z")
+    )
+    sicd_ew["ImageFormation"] = sicd.ImageFormation(
         sicd.RcvChanProc(sicd.NumChanProc("1"), sicd.ChanIndex(str(chan_index))),
         sicd.TxRcvPolarizationProc(tx_rcv_polarization),
         sicd.TStartProc(str(0)),
@@ -598,9 +761,23 @@ def hdf5_to_sicd(
         sicd.ImageBeamComp("SV"),
         sicd.AzAutofocus("NO"),
         sicd.RgAutofocus("NO"),
+        sicd.Processing(
+            sicd.Type(f"sarkit-convert {__version__} @ {now}"),
+            sicd.Applied("true"),
+        ),
+    )
+
+    sicd_ew["Antenna"]["TwoWay"]["XAxisPoly"] = ant_x_dir_poly
+    sicd_ew["Antenna"]["TwoWay"]["YAxisPoly"] = ant_y_dir_poly
+    sicd_ew["Antenna"]["TwoWay"]["FreqZero"] = freq_zero
+    sicd_ew["Antenna"]["TwoWay"]["EB"]["DCXPoly"] = eb_dcx_poly
+    sicd_ew["Antenna"]["TwoWay"]["EB"]["DCYPoly"] = eb_dcy_poly
+    sicd_ew["Antenna"]["TwoWay"]["Array"]["GainPoly"] = antenna_array_gain
+    sicd_ew["Antenna"]["TwoWay"]["Array"]["PhasePoly"] = np.zeros(
+        dtype=float, shape=(1, 1)
     )
 
-    rma = sicd.RMA(
+    sicd_ew["RMA"] = sicd.RMA(
         sicd.RMAlgoType("OMEGA_K"),
         sicd.ImageType("INCA"),
         sicd.INCA(
@@ -611,25 +788,11 @@ def hdf5_to_sicd(
             sicd.DopCentroidPoly(),
         ),
     )
-    sksicd.PolyType().set_elem(rma.find("./{*}INCA/{*}TimeCAPoly"), time_ca_poly)
-    sksicd.Poly2dType().set_elem(rma.find("./{*}INCA/{*}DRateSFPoly"), drsf_poly)
-    sksicd.Poly2dType().set_elem(
-        rma.find("./{*}INCA/{*}DopCentroidPoly"), doppler_centroid_poly
-    )
-    sicd_xml_obj = sicd.SICD(
-        collection_info,
-        image_creation,
-        image_data,
-        geo_data,
-        grid,
-        timeline,
-        position,
-        radar_collection,
-        image_formation,
-        rma,
-    )
+    sicd_ew["RMA"]["INCA"]["TimeCAPoly"] = time_ca_poly
+    sicd_ew["RMA"]["INCA"]["DRateSFPoly"] = drsf_poly
+    sicd_ew["RMA"]["INCA"]["DopCentroidPoly"] = doppler_centroid_poly
 
-    image_formation.addnext(sksicd.compute_scp_coa(sicd_xml_obj.getroottree()))
+    sicd_ew["SCPCOA"] = sksicd.compute_scp_coa(sicd_xml_obj.getroottree())
 
     # Add Radiometric
     if mission_id == "CSK":
@@ -668,7 +831,7 @@ def hdf5_to_sicd(
                 sksicd.Poly2dType().set_elem(
                     radiometric.find("./{*}RCSSFPoly"), rcssf_poly
                 )
-            sicd_xml_obj.find("./{*}RMA").addprevious(radiometric)
+            sicd_xml_obj.find("./{*}Antenna").addprevious(radiometric)
 
     # Add Geodata Corners
     sicd_xmltree = sicd_xml_obj.getroottree()
@@ -708,7 +871,7 @@ def hdf5_to_sicd(
     metadata = sksicd.NitfMetadata(
         xmltree=sicd_xmltree,
         file_header_part={
-            "ostaid": ostaid,
+            "ostaid": h5_attrs["Processing Centre"],
             "ftitle": core_name,
             "security": {
                 "clas": classification[0].upper(),
@@ -756,11 +919,6 @@ def main(args=None):
         type=pathlib.Path,
         help='path of the output SICD file. The string "{pol}" will be replaced with polarization for multiple images',
     )
-    parser.add_argument(
-        "--ostaid",
-        help="content of the originating station ID (OSTAID) field of the NITF header",
-        default="Unknown",
-    )
     config = parser.parse_args(args)
 
     tx_polarizations = []
@@ -810,7 +968,6 @@ def main(args=None):
             h5_filename=config.input_h5_file,
             sicd_filename=img_info["filename"],
             classification=config.classification,
-            ostaid=config.ostaid,
             img_str=img_str,
             chan_index=img_info["chan_index"],
             tx_polarizations=tx_polarizations,