asp-plot 0.1.0__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: asp_plot
-Version: 0.1.0
+Version: 0.2.0
 Summary: Package for plotting outputs Ames Stereo Pipeline processing
 Author: Ben Purinton
 Author-email: Ben Purinton <purinton@uw.edu>
@@ -54,6 +54,12 @@ $ pytest
 
 ### Package and upload
 
+```
+$ rm -rf dist/
+```
+
+Then update version in `pyproject.toml` and `setup.py`, then:
+
 ```
 $ python3 -m pip install --upgrade build
 $ python3 -m build

{asp_plot-0.1.0 → asp_plot-0.2.0}/README.md

@@ -39,6 +39,12 @@ $ pytest
 
 ### Package and upload
 
+```
+$ rm -rf dist/
+```
+
+Then update version in `pyproject.toml` and `setup.py`, then:
+
 ```
 $ python3 -m pip install --upgrade build
 $ python3 -m build

{asp_plot-0.1.0 → asp_plot-0.2.0}/asp_plot/__init__.py

@@ -1,4 +1,5 @@
 import asp_plot.utils
+import asp_plot.stereopair_metadata_parser
 import asp_plot.processing_parameters
 import asp_plot.scenes
 import asp_plot.bundle_adjust

{asp_plot-0.1.0 → asp_plot-0.2.0}/asp_plot/bundle_adjust.py

@@ -8,30 +8,31 @@ import contextily as ctx
 from asp_plot.utils import ColorBar, Plotter, save_figure
 
 
-class ReadResiduals:
+class ReadBundleAdjustFiles:
     def __init__(self, directory, bundle_adjust_directory):
         self.directory = directory
         self.bundle_adjust_directory = bundle_adjust_directory
 
-    def get_init_final_residuals_csvs(self):
+    def get_csv_paths(self, geodiff_files=False):
         filenames = [
             "*-initial_residuals_pointmap.csv",
             "*-final_residuals_pointmap.csv",
         ]
 
+        if geodiff_files:
+            filenames = [f.replace(".csv", "-diff.csv") for f in filenames]
+
         paths = [
-            glob.glob(
-                os.path.join(self.directory, self.bundle_adjust_directory, filename)
-            )[0]
-            for filename in filenames
+            glob.glob(os.path.join(self.directory, self.bundle_adjust_directory, f))[0]
+            for f in filenames
         ]
 
         for path in paths:
             if not os.path.isfile(path):
-                raise ValueError(f"Residuals CSV file not found: {path}")
+                raise ValueError(f"CSV file not found: {path}")
 
-        resid_init_path, resid_final_path = paths
-        return resid_init_path, resid_final_path
+        initial, final = paths
+        return initial, final
 
     def get_residuals_gdf(self, csv_path):
         cols = [
@@ -66,11 +67,38 @@ class ReadResiduals:
         resid_gdf.filename = os.path.basename(csv_path)
         return resid_gdf
 
-    def get_init_final_residuals_gdfs(self):
-        resid_init_path, resid_final_path = self.get_init_final_residuals_csvs()
-        resid_init_gdf = self.get_residuals_gdf(resid_init_path)
+    def get_geodiff_gdf(self, csv_path):
+        cols = [
+            "lon",
+            "lat",
+            "height_diff_meters",
+        ]
+
+        geodiff_df = pd.read_csv(csv_path, skiprows=7, names=cols)
+
+        geodiff_gdf = gpd.GeoDataFrame(
+            geodiff_df,
+            geometry=gpd.points_from_xy(
+                geodiff_df["lon"], geodiff_df["lat"], crs="EPSG:4326"
+            ),
+        )
+
+        geodiff_gdf.filename = os.path.basename(csv_path)
+        return geodiff_gdf
+
+    def get_initial_final_residuals_gdfs(self):
+        resid_initial_path, resid_final_path = self.get_csv_paths()
+        resid_initial_gdf = self.get_residuals_gdf(resid_initial_path)
         resid_final_gdf = self.get_residuals_gdf(resid_final_path)
-        return resid_init_gdf, resid_final_gdf
+        return resid_initial_gdf, resid_final_gdf
+
+    def get_initial_final_geodiff_gdfs(self):
+        geodiff_initial_path, geodiff_final_path = self.get_csv_paths(
+            geodiff_files=True
+        )
+        geodiff_initial_gdf = self.get_geodiff_gdf(geodiff_initial_path)
+        geodiff_final_gdf = self.get_geodiff_gdf(geodiff_final_path)
+        return geodiff_initial_gdf, geodiff_final_gdf
 
     def get_mapproj_residuals_gdf(self):
         path = glob.glob(
@@ -123,18 +151,18 @@ class ReadResiduals:
         return resid_triangulation_uncert_df
 
 
-class PlotResiduals(Plotter):
+class PlotBundleAdjustFiles(Plotter):
     def __init__(self, geodataframes, **kwargs):
         super().__init__(**kwargs)
         if not isinstance(geodataframes, list):
             raise ValueError("Input must be a list of GeoDataFrames")
         self.geodataframes = geodataframes
 
-    def get_residual_stats(self, gdf, column_name="mean_residual"):
+    def gdf_percentile_stats(self, gdf, column_name="mean_residual"):
         stats = gdf[column_name].quantile([0.25, 0.50, 0.84, 0.95]).round(2).tolist()
         return stats
 
-    def plot_n_residuals(
+    def plot_n_gdfs(
         self,
         column_name="mean_residual",
         cbar_label="Mean Residual (m)",
@@ -175,10 +203,15 @@ class PlotResiduals(Plotter):
                     clim=clim,
                     column_name=column_name,
                     cbar_label=cbar_label,
+                    cmap=cmap,
                 )
             else:
                 self.plot_geodataframe(
-                    ax=axa[i], gdf=gdf, column_name=column_name, cbar_label=cbar_label
+                    ax=axa[i],
+                    gdf=gdf,
+                    column_name=column_name,
+                    cbar_label=cbar_label,
+                    cmap=cmap,
                 )
 
             ctx.add_basemap(ax=axa[i], **ctx_kwargs)
@@ -187,7 +220,7 @@ class PlotResiduals(Plotter):
                 axa[i].autoscale(False)
 
             # Show some statistics and information
-            stats = self.get_residual_stats(gdf, column_name)
+            stats = self.gdf_percentile_stats(gdf, column_name)
             stats_text = f"(n={gdf.shape[0]})\n" + "\n".join(
                 f"{quantile*100:.0f}th: {stat}"
                 for quantile, stat in zip([0.25, 0.50, 0.84, 0.95], stats)

{asp_plot-0.1.0 → asp_plot-0.2.0}/asp_plot/cli/asp_plot.py

@@ -3,9 +3,10 @@ import glob
 import subprocess
 import click
 import contextily as ctx
+from itertools import count
 from asp_plot.processing_parameters import ProcessingParameters
-from asp_plot.scenes import ScenePlotter
-from asp_plot.bundle_adjust import ReadResiduals, PlotResiduals
+from asp_plot.scenes import ScenePlotter, SceneGeometryPlotter
+from asp_plot.bundle_adjust import ReadBundleAdjustFiles, PlotBundleAdjustFiles
 from asp_plot.stereo import StereoPlotter
 from asp_plot.utils import compile_report
 
@@ -44,7 +45,7 @@ from asp_plot.utils import compile_report
 @click.option(
     "--plots_directory",
     prompt=True,
-    default="asp_plots",
+    default="asp_plots_for_report",
     help="Directory to put output plots. Default: asp_plots",
 )
 @click.option(
@@ -68,27 +69,23 @@ def main(
     os.makedirs(plots_directory, exist_ok=True)
     report_pdf_path = os.path.join(directory, report_filename)
 
+    figure_counter = count(0)
+
     # Geometry plot
-    try:
-        subprocess.run(["dg_geom_plot.py", directory])
-        subprocess.run(
-            f"mv {directory}/*stereo_geom.png {plots_directory}/00_stereo_geom.png",
-            shell=True,
-        )
-    except:
-        print(
-            "Could not generate stereo geometry plot, check your path for dg_geom_plot.py"
-        )
+    plotter = SceneGeometryPlotter(directory)
+
+    plotter.dg_geom_plot(save_dir=plots_directory, fig_fn=f"{next(figure_counter):02}.png")
 
     # Scene plot
     plotter = ScenePlotter(directory, stereo_directory, title="Mapprojected Scenes")
 
-    plotter.plot_orthos(save_dir=plots_directory, fig_fn="01_orthos.png")
+    plotter.plot_orthos(save_dir=plots_directory, fig_fn=f"{next(figure_counter):02}.png")
 
     # Bundle adjustment plots
-    residuals = ReadResiduals(directory, bundle_adjust_directory)
-    resid_init_gdf, resid_final_gdf = residuals.get_init_final_residuals_gdfs()
-    resid_mapprojected_gdf = residuals.get_mapproj_residuals_gdf()
+    ba_files = ReadBundleAdjustFiles(directory, bundle_adjust_directory)
+    resid_initial_gdf, resid_final_gdf = ba_files.get_initial_final_residuals_gdfs()
+    geodiff_initial_gdf, geodiff_final_gdf = ba_files.get_initial_final_geodiff_gdfs()
+    resid_mapprojected_gdf = ba_files.get_mapproj_residuals_gdf()
 
     ctx_kwargs = {
         "crs": map_crs,
@@ -97,48 +94,69 @@ def main(
         "alpha": 0.5,
     }
 
-    plotter = PlotResiduals(
-        [resid_init_gdf, resid_final_gdf],
+    plotter = PlotBundleAdjustFiles(
+        [resid_initial_gdf, resid_final_gdf],
         lognorm=True,
         title="Bundle Adjust Initial and Final Residuals (Log Scale)",
     )
 
-    plotter.plot_n_residuals(
+    plotter.plot_n_gdfs(
         column_name="mean_residual",
         cbar_label="Mean Residual (m)",
         map_crs=map_crs,
         save_dir=plots_directory,
-        fig_fn="02_ba_residuals_log.png",
+        fig_fn=f"{next(figure_counter):02}.png",
         **ctx_kwargs,
     )
 
     plotter.lognorm = False
     plotter.title = "Bundle Adjust Initial and Final Residuals (Linear Scale)"
 
-    plotter.plot_n_residuals(
+    plotter.plot_n_gdfs(
         column_name="mean_residual",
         cbar_label="Mean Residual (m)",
         common_clim=False,
         map_crs=map_crs,
         save_dir=plots_directory,
-        fig_fn="03_ba_residuals_linear.png",
+        fig_fn=f"{next(figure_counter):02}.png",
         **ctx_kwargs,
     )
 
-    plotter = PlotResiduals(
+    plotter = PlotBundleAdjustFiles(
         [resid_mapprojected_gdf],
         title="Bundle Adjust Midpoint distance between\nfinal interest points projected onto reference DEM",
     )
 
-    plotter.plot_n_residuals(
+    plotter.plot_n_gdfs(
         column_name="mapproj_ip_dist_meters",
         cbar_label="Interest point distance (m)",
         map_crs=map_crs,
         save_dir=plots_directory,
-        fig_fn="04_ba_residuals_mapproj_dist.png",
+        fig_fn=f"{next(figure_counter):02}.png",
         **ctx_kwargs,
     )
 
+    plotter = PlotBundleAdjustFiles(
+        [geodiff_initial_gdf, geodiff_final_gdf],
+        lognorm=False,
+        title="Bundle Adjust Initial and Final Geodiff vs. Reference DEM"
+    )
+
+    clim = (float(geodiff_initial_gdf["height_diff_meters"].quantile(0.05)), float(geodiff_initial_gdf["height_diff_meters"].quantile(0.95)))
+    abs_max = max(abs(clim[0]), abs(clim[1]))
+    clim = (-abs_max, abs_max)
+
+    plotter.plot_n_gdfs(
+        column_name="height_diff_meters",
+        cbar_label="Height difference (m)",
+        map_crs=map_crs,
+        cmap="RdBu",
+        clim=clim,
+        save_dir=plots_directory,
+        fig_fn=f"{next(figure_counter):02}.png",
+        **ctx_kwargs
+    )
+
     # Stereo plots
     plotter = StereoPlotter(
         directory,
@@ -150,7 +168,7 @@ def main(
 
     plotter.plot_match_points(
         save_dir=plots_directory,
-        fig_fn="05_stereo_match_points.png",
+        fig_fn=f"{next(figure_counter):02}.png",
     )
 
     plotter.title = "Disparity (pixels)"
@@ -159,14 +177,14 @@ def main(
         unit="pixels",
         quiver=True,
         save_dir=plots_directory,
-        fig_fn="06_disparity_pixels.png",
+        fig_fn=f"{next(figure_counter):02}.png",
     )
 
     plotter.title = "Stereo DEM Results"
 
     plotter.plot_dem_results(
         save_dir=plots_directory,
-        fig_fn="07_stereo_dem_results.png",
+        fig_fn=f"{next(figure_counter):02}.png",
     )
 
     # Compile report

asp_plot-0.2.0/asp_plot/scenes.py

@@ -0,0 +1,216 @@
+import os
+import glob
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+from shapely import wkt
+from asp_plot.utils import Raster, Plotter, save_figure
+from asp_plot.stereopair_metadata_parser import StereopairMetadataParser
+
+
+class SceneGeometryPlotter(StereopairMetadataParser):
+    def __init__(self, directory, **kwargs):
+        super().__init__(directory=directory, **kwargs)
+
+    def get_scene_string(self, p, key="id1_dict"):
+        scene_string = (
+            "\nID:%s, GSD:%0.2f, off:%0.1f, az:%0.1f, el:%0.1f, it:%0.1f, ct:%0.1f, scan:%s, tdi:%i"
+            % (
+                p[key]["id"],
+                p[key]["meanproductgsd"],
+                p[key]["meanoffnadirviewangle"],
+                p[key]["meansataz"],
+                (90 - p[key]["meansatel"]),
+                p[key]["meanintrackviewangle"],
+                (p[key]["meancrosstrackviewangle"]),
+                p[key]["scandir"],
+                p[key]["tdi"],
+            )
+        )
+        return scene_string
+
+    def get_title(self, p):
+        title = p["pairname"]
+        title += "\nCenter datetime: %s" % p["cdate"]
+        title += "\nTime offset: %s" % str(p["dt"])
+        title += "\nConv. angle: %0.2f, B:H ratio: %0.2f, Int. area: %0.2f km2" % (
+            p["conv_ang"],
+            p["bh"],
+            p["intersection_area"],
+        )
+        title += self.get_scene_string(p, "id1_dict")
+        title += self.get_scene_string(p, "id2_dict")
+        return title
+
+    def skyplot(self, ax, p, title=True, tight_layout=True):
+        """
+        Function to plot stereo geometry from dg xml
+        Parameters
+        -----------
+        p: pair dictionary
+            dictionary with xml info read from get_pair_dict function
+        ax: matplotlib.axes
+            polar axes object to plot the skyplot on
+        """
+        ax.set_theta_direction(-1)
+        ax.set_theta_zero_location("N")
+        ax.grid(True)
+
+        plot_kw = {"marker": "o", "ls": "", "ms": 5}
+
+        ax.plot(0, 0, marker="o", color="k")
+        ax.plot(
+            np.radians(p["id1_dict"]["meansataz"]),
+            (90 - p["id1_dict"]["meansatel"]),
+            label=p["id1_dict"]["id"],
+            **plot_kw,
+        )
+        ax.plot(
+            np.radians(p["id2_dict"]["meansataz"]),
+            (90 - p["id2_dict"]["meansatel"]),
+            label=p["id2_dict"]["id"],
+            **plot_kw,
+        )
+        ax.plot(
+            [
+                np.radians(p["id1_dict"]["meansataz"]),
+                np.radians(p["id2_dict"]["meansataz"]),
+            ],
+            [90 - p["id1_dict"]["meansatel"], 90 - p["id2_dict"]["meansatel"]],
+            color="k",
+            ls="--",
+            lw=0.5,
+            alpha=0.5,
+        )
+
+        ax.legend(loc="lower left", fontsize="small")
+
+        ax.set_rmin(0)
+        ax.set_rmax(50)
+        if title:
+            ax.set_title(self.get_title(p), fontsize=8)
+        if tight_layout:
+            plt.tight_layout()
+
+    def map_plot(
+        self, ax, p, gdf_list, map_crs="EPSG:3857", title=True, tight_layout=True
+    ):
+        """
+        Plot satellite ephemeris and ground footprint for a DigitalGlobe stereo pair
+        # stitched together from David's notebook: https://github.com/dshean/dgtools/blob/master/notebooks/dg_pair_geom_eph_analysis.ipynb
+        Parameters
+        ------------
+        ax: matplotlib sublot axes object
+        gdf_list: list of necessary GeoDataFrame objects
+        """
+        import contextily as ctx
+
+        poly_kw = {"alpha": 0.5, "edgecolor": "k", "linewidth": 0.5}
+        eph_kw = {"markersize": 2}
+
+        fp1_gdf, fp2_gdf, eph1_gdf, eph2_gdf = gdf_list
+
+        c_list = ["blue", "orange"]
+        fp1_gdf.to_crs(map_crs).plot(ax=ax, color=c_list[0], **poly_kw)
+        fp2_gdf.to_crs(map_crs).plot(ax=ax, color=c_list[1], **poly_kw)
+        eph1_gdf.to_crs(map_crs).plot(
+            ax=ax, label=p["id1_dict"]["id"], color=c_list[0], **eph_kw
+        )
+        eph2_gdf.to_crs(map_crs).plot(
+            ax=ax, label=p["id2_dict"]["id"], color=c_list[1], **eph_kw
+        )
+
+        start_kw = {"markersize": 5, "facecolor": "w", "edgecolor": "k"}
+        eph1_gdf.iloc[0:2].to_crs(map_crs).plot(ax=ax, **start_kw)
+        eph2_gdf.iloc[0:2].to_crs(map_crs).plot(ax=ax, **start_kw)
+
+        ctx.add_basemap(ax, crs=map_crs, attribution=False)
+
+        ax.legend(loc="best", prop={"size": 6})
+        if title:
+            ax.set_title(self.get_title(p), fontsize=7.5)
+        if tight_layout:
+            plt.tight_layout()
+
+    def dg_geom_plot(self, save_dir=None, fig_fn=None):
+        # load pair information as dict
+        p = self.get_pair_dict()
+
+        # TODO: Should store xml names in the pairdict
+        # Use r100 outputs from dg_mosaic
+        xml_list = sorted(glob.glob(os.path.join(self.directory, "*r100.[Xx][Mm][Ll]")))
+
+        eph1_gdf, eph2_gdf = [self.getEphem_gdf(xml) for xml in xml_list]
+        fp1_gdf, fp2_gdf = [self.xml2gdf(xml) for xml in xml_list]
+
+        fig = plt.figure(figsize=(10, 7.5))
+        G = gridspec.GridSpec(nrows=1, ncols=2)
+        ax0 = fig.add_subplot(G[0, 0:1], polar=True)
+        ax1 = fig.add_subplot(G[0, 1:2])
+
+        self.skyplot(ax0, p, title=False, tight_layout=False)
+
+        # map_crs = 'EPSG:3857'
+        # Use local projection to minimize distortion
+        # Get Shapely polygon and compute centroid (for local projection def)
+        p_poly = wkt.loads(p["intersection"].ExportToWkt())
+        p_int_c = np.array(p_poly.centroid.coords.xy).ravel()
+        # map_crs = '+proj=ortho +lon_0={} +lat_0={}'.format(*p_int_c)
+        # Should be OK to use transverse mercator here, usually within ~2-3 deg
+        map_crs = "+proj=tmerc +lon_0={} +lat_0={}".format(*p_int_c)
+
+        self.map_plot(
+            ax1,
+            p,
+            [fp1_gdf, fp2_gdf, eph1_gdf, eph2_gdf],
+            map_crs=map_crs,
+            title=False,
+            tight_layout=False,
+        )
+
+        plt.suptitle(self.get_title(p), fontsize=10)
+
+        if save_dir and fig_fn:
+            save_figure(fig, save_dir, fig_fn)
+
+
+class ScenePlotter(Plotter):
+    def __init__(self, directory, stereo_directory, **kwargs):
+        super().__init__(**kwargs)
+        self.directory = directory
+        self.stereo_directory = stereo_directory
+
+        try:
+            self.left_ortho_sub_fn = glob.glob(
+                os.path.join(self.directory, self.stereo_directory, "*-L_sub.tif")
+            )[0]
+            self.right_ortho_sub_fn = glob.glob(
+                os.path.join(self.directory, self.stereo_directory, "*-R_sub.tif")
+            )[0]
+        except:
+            raise ValueError(
+                "Could not find L-sub and R-sub images in stereo directory"
+            )
+
+    def plot_orthos(self, save_dir=None, fig_fn=None):
+        p = StereopairMetadataParser(self.directory).get_pair_dict()
+
+        fig, axa = plt.subplots(1, 2, figsize=(10, 5), dpi=300)
+        fig.suptitle(self.title, size=10)
+        axa = axa.ravel()
+
+        ortho_ma = Raster(self.left_ortho_sub_fn).read_array()
+        self.plot_array(ax=axa[0], array=ortho_ma, cmap="gray", add_cbar=False)
+        axa[0].set_title(
+            f"Left image\n{p['id1_dict']['id']}, {p['id1_dict']['meanproductgsd']:0.2f} m"
+        )
+
+        ortho_ma = Raster(self.right_ortho_sub_fn).read_array()
+        self.plot_array(ax=axa[1], array=ortho_ma, cmap="gray", add_cbar=False)
+        axa[1].set_title(
+            f"Right image\n{p['id2_dict']['id']}, {p['id2_dict']['meanproductgsd']:0.2f} m"
+        )
+
+        fig.tight_layout()
+        if save_dir and fig_fn:
+            save_figure(fig, save_dir, fig_fn)

asp_plot-0.2.0/asp_plot/stereopair_metadata_parser.py

@@ -0,0 +1,330 @@
+import glob
+import os
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+from datetime import datetime, timedelta
+from osgeo import ogr, osr, gdal
+from shapely import wkt
+from asp_plot.utils import get_xml_tag
+
+
+class StereopairMetadataParser:
+    def __init__(self, directory):
+        self.directory = directory
+
+    def get_pair_dict(self):
+        ids = self.get_ids()
+        id1_dict = self.get_id_dict(ids[0])
+        id2_dict = self.get_id_dict(ids[1])
+        pairname = os.path.split(self.directory.rstrip("/\\"))[-1]
+        return self.pair_dict(id1_dict, id2_dict, pairname)
+
+    def get_ids(self):
+
+        def get_id(filename):
+            import re
+
+            ids = re.findall("10[123456][0-9a-fA-F]+00", filename)
+            return list(set(ids))
+
+        image_list = glob.glob(os.path.join(self.directory, "*.[Xx][Mm][Ll]"))
+        ids = [get_id(f) for f in image_list]
+        ids = sorted(set(item for sublist in ids if sublist for item in sublist))
+        return ids
+
+    def get_id_dict(self, id):
+
+        def list_average(list):
+            return np.round(pd.Series(list, dtype=float).dropna().mean(), 2)
+
+        def geom_union(geom_list):
+            union = geom_list[0]
+            for geom in geom_list[1:]:
+                union = union.Union(geom)
+            return union
+
+        xml_list = glob.glob(os.path.join(self.directory, f"*{id:}*.[Xx][Mm][Ll]"))
+
+        attributes = {
+            "MEANSATAZ": [],
+            "MEANSATEL": [],
+            "MEANOFFNADIRVIEWANGLE": [],
+            "MEANINTRACKVIEWANGLE": [],
+            "MEANCROSSTRACKVIEWANGLE": [],
+            "MEANPRODUCTGSD": [],
+            "MEANSUNAZ": [],
+            "MEANSUNEL": [],
+            "CLOUDCOVER": [],
+            "geom": [],
+        }
+
+        for xml in xml_list:
+            for tag, lst in attributes.items():
+                if tag != "geom":
+                    lst.append(get_xml_tag(xml, tag))
+                else:
+                    lst.append(self.xml2geom(xml))
+
+        d = {
+            "id": str(id),
+            "sensor": get_xml_tag(xml_list[0], "SATID"),
+            "date": datetime.strptime(
+                get_xml_tag(xml_list[0], "FIRSTLINETIME"), "%Y-%m-%dT%H:%M:%S.%fZ"
+            ),
+            "scandir": get_xml_tag(xml_list[0], "SCANDIRECTION"),
+            "tdi": int(get_xml_tag(xml_list[0], "TDILEVEL")),
+            "geom": geom_union(attributes["geom"]),
+        }
+
+        for tag, lst in attributes.items():
+            if tag != "geom":
+                d[tag.lower()] = list_average(lst)
+
+        return d
+
+    def getEphem(self, xml):
+        e = get_xml_tag(xml, "EPHEMLIST", all=True)
+        # Could get fancy with structured array here
+        # point_num, Xpos, Ypos, Zpos, Xvel, Yvel, Zvel, covariance matrix (6 elements)
+        # dtype=[('point', 'i4'), ('Xpos', 'f8'), ('Ypos', 'f8'), ('Zpos', 'f8'), ('Xvel', 'f8') ...]
+        # All coordinates are ECF, meters, meters/sec, m^2
+        return np.array([i.split() for i in e], dtype=np.float64)
+
+    def getEphem_gdf(self, xml):
+        names = [
+            "index",
+        ]
+        names.extend(["x", "y", "z"])
+        names.extend(["dx", "dy", "dz"])
+        names.extend(["{}_cov".format(n) for n in names[1:7]])
+        e = self.getEphem(xml)
+        t0 = pd.to_datetime(get_xml_tag(xml, "STARTTIME"))
+        dt = pd.Timedelta(float(get_xml_tag(xml, "TIMEINTERVAL")), unit="s")
+        eph_df = pd.DataFrame(e, columns=names)
+        eph_df["time"] = t0 + eph_df.index * dt
+        eph_df.set_index("time", inplace=True)
+        eph_gdf = gpd.GeoDataFrame(
+            eph_df,
+            geometry=gpd.points_from_xy(eph_df["x"], eph_df["y"], eph_df["z"]),
+            crs="EPSG:4978",
+        )
+        return eph_gdf
+
+    def xml2wkt(self, xml):
+        tags = [
+            ("ULLON", "ULLAT"),
+            ("URLON", "URLAT"),
+            ("LRLON", "LRLAT"),
+            ("LLLON", "LLLAT"),
+            ("ULLON", "ULLAT"),
+        ]
+        coords = []
+        for lon_tag, lat_tag in tags:
+            lon = get_xml_tag(xml, lon_tag)
+            lat = get_xml_tag(xml, lat_tag)
+            if lon and lat:
+                coords.append(f"{lon} {lat}")
+        geom_wkt = f"POLYGON(({', '.join(coords)}))"
+        return geom_wkt
+
+    def xml2geom(self, xml):
+        geom_wkt = self.xml2wkt(xml)
+        geom = ogr.CreateGeometryFromWkt(geom_wkt)
+        wgs_srs = self.get_wgs_srs()
+        geom.AssignSpatialReference(wgs_srs)
+        return geom
+
+    def xml2gdf(self, xml, init_crs="EPSG:4326"):
+        poly = self.xml2poly(xml)
+        gdf = gpd.GeoDataFrame(
+            {"idx": [0], "geometry": poly}, geometry="geometry", crs=init_crs
+        )
+        return gdf
+
+    def xml2poly(self, xml):
+        geom_wkt = self.xml2wkt(xml)
+        return wkt.loads(geom_wkt)
+
+    def get_wgs_srs(self):
+        # Define WGS84 srs
+        # mpd = 111319.9
+        wgs_srs = osr.SpatialReference()
+        wgs_srs.SetWellKnownGeogCS("WGS84")
+        # GDAL3 hack
+        if int(gdal.__version__.split(".")[0]) >= 3:
+            wgs_srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
+        return wgs_srs
+
+    def pair_dict(self, id1_dict, id2_dict, pairname):
+        def center_date(dt_list):
+            dt_list_sort = sorted(dt_list)
+            dt_list_sort_rel = [dt - dt_list_sort[0] for dt in dt_list_sort]
+            avg_timedelta = sum(dt_list_sort_rel, timedelta()) / len(dt_list_sort_rel)
+            return dt_list_sort[0] + avg_timedelta
+
+        def get_conv(az1, el1, az2, el2):
+            conv_ang = np.rad2deg(
+                np.arccos(
+                    np.sin(np.deg2rad(el1)) * np.sin(np.deg2rad(el2))
+                    + np.cos(np.deg2rad(el1))
+                    * np.cos(np.deg2rad(el2))
+                    * np.cos(np.deg2rad(az1 - az2))
+                )
+            )
+            return np.round(conv_ang, 2)
+
+        def get_bh(conv_ang):
+            bh = 2 * np.tan(np.deg2rad(conv_ang / 2.0))
+            return np.round(bh, 2)
+
+        p = {}
+        p["id1_dict"] = id1_dict
+        p["id2_dict"] = id2_dict
+        p["pairname"] = pairname
+
+        self.get_pair_intersection(p)
+
+        cdate = center_date([p["id1_dict"]["date"], p["id2_dict"]["date"]])
+        p["cdate"] = cdate
+        dt1 = p["id1_dict"]["date"]
+        dt2 = p["id2_dict"]["date"]
+        dt = abs(dt1 - dt2)
+        p["dt"] = dt
+
+        p["conv_ang"] = get_conv(
+            p["id1_dict"]["meansataz"],
+            p["id1_dict"]["meansatel"],
+            p["id2_dict"]["meansataz"],
+            p["id2_dict"]["meansatel"],
+        )
+
+        p["bh"] = get_bh(p["conv_ang"])
+        return p
+
+    def get_pair_intersection(self, p):
+        def geom_intersection(geom_list):
+            intsect = geom_list[0]
+            valid = False
+            for geom in geom_list[1:]:
+                if intsect.Intersects(geom):
+                    valid = True
+                    intsect = intsect.Intersection(geom)
+            if not valid:
+                intsect = None
+            return intsect
+
+        def geom2localortho(geom):
+            wgs_srs = self.get_wgs_srs()
+            cx, cy = geom.Centroid().GetPoint_2D()
+            lon, lat, z = self.coordinate_transformation_helper(
+                cx, cy, 0, geom.GetSpatialReference(), wgs_srs
+            )
+            local_srs = osr.SpatialReference()
+            local_proj = f"+proj=ortho +lat_0={lat:0.7f} +lon_0={lon:0.7f} +datum=WGS84 +units=m +no_defs "
+            local_srs.ImportFromProj4(local_proj)
+            local_geom = geom_dup(geom)
+            geom_transform(local_geom, local_srs)
+            return local_geom
+
+        def geom_dup(geom):
+            g = ogr.CreateGeometryFromWkt(geom.ExportToWkt())
+            g.AssignSpatialReference(geom.GetSpatialReference())
+            return g
+
+        def geom_transform(geom, t_srs):
+            s_srs = geom.GetSpatialReference()
+            if not s_srs.IsSame(t_srs):
+                ct = osr.CoordinateTransformation(s_srs, t_srs)
+                geom.Transform(ct)
+                geom.AssignSpatialReference(t_srs)
+
+        geom1 = p["id1_dict"]["geom"]
+        geom2 = p["id2_dict"]["geom"]
+        intersection = geom_intersection([geom1, geom2])
+        p["intersection"] = intersection
+        p["intersection_poly"] = wkt.loads(intersection.ExportToWkt())
+        intersection_local = geom2localortho(intersection)
+        local_srs = intersection_local.GetSpatialReference()
+        # This recomputes for local orthographic - important for width/height calculations
+        geom1_local = geom_dup(geom1)
+        geom_transform(geom1_local, local_srs)
+        geom2_local = geom_dup(geom2)
+        geom_transform(geom2_local, local_srs)
+        if intersection is not None:
+            # Area calc shouldn't matter too much
+            intersection_area = intersection_local.GetArea()
+            p["intersection_area"] = np.round(intersection_area / 1e6, 2)
+            perc = (
+                100.0 * intersection_area / geom1_local.GetArea(),
+                100 * intersection_area / geom2_local.GetArea(),
+            )
+            perc = (np.round(perc[0], 2), np.round(perc[1], 2))
+            p["intersection_area_perc"] = perc
+        else:
+            p["intersection_area"] = None
+            p["intersection_area_perc"] = None
+
+    def coordinate_transformation_helper(self, x, y, z, in_srs, out_srs):
+        def common_mask(ma_list, apply=False):
+            a = np.ma.array(ma_list, shrink=False)
+            mask = np.ma.getmaskarray(a).any(axis=0)
+            if apply:
+                return [np.ma.array(b, mask=mask) for b in ma_list]
+            else:
+                return mask
+
+        x = np.atleast_1d(x)
+        y = np.atleast_1d(y)
+        z = np.atleast_1d(z)
+        if x.shape != y.shape:
+            sys.exit("Inconsistent number of x and y points")
+        valid_idx = None
+        # Handle case where we have x array, y array, but a constant z (e.g., 0.0)
+        if z.shape != x.shape:
+            # If a constant elevation is provided
+            if z.shape[0] == 1:
+                orig_z = z
+                z = np.zeros_like(x)
+                z[:] = orig_z
+                if np.ma.is_masked(x):
+                    z[np.ma.getmaskarray(x)] = np.ma.masked
+            else:
+                sys.exit("Inconsistent number of z and x/y points")
+        # If any of the inputs is masked, only transform points with all three coordinates available
+        if np.ma.is_masked(x) or np.ma.is_masked(y) or np.ma.is_masked(z):
+            x = np.ma.array(x)
+            y = np.ma.array(y)
+            z = np.ma.array(z)
+            valid_idx = ~(common_mask([x, y, z]))
+            # Prepare (x,y,z) tuples
+            xyz = np.array([x[valid_idx], y[valid_idx], z[valid_idx]]).T
+        else:
+            xyz = np.array([x.ravel(), y.ravel(), z.ravel()]).T
+        # Define coordinate transformation
+        coordinate_transformation = osr.CoordinateTransformation(in_srs, out_srs)
+        # Loop through each point
+        xyz2 = np.array(
+            [
+                coordinate_transformation.TransformPoint(xi, yi, zi)
+                for (xi, yi, zi) in xyz
+            ]
+        ).T
+        # If single input coordinate
+        if xyz2.shape[1] == 1:
+            xyz2 = xyz2.squeeze()
+            x2, y2, z2 = xyz2[0], xyz2[1], xyz2[2]
+        else:
+            # Fill in masked array
+            if valid_idx is not None:
+                x2 = np.zeros_like(x)
+                y2 = np.zeros_like(y)
+                z2 = np.zeros_like(z)
+                x2[valid_idx] = xyz2[0]
+                y2[valid_idx] = xyz2[1]
+                z2[valid_idx] = xyz2[2]
+            else:
+                x2 = xyz2[0].reshape(x.shape)
+                y2 = xyz2[1].reshape(y.shape)
+                z2 = xyz2[2].reshape(z.shape)
+        return x2, y2, z2

{asp_plot-0.1.0 → asp_plot-0.2.0}/asp_plot/utils.py

@@ -3,7 +3,7 @@ import numpy as np
 import rasterio as rio
 from rasterio.windows import Window
 from osgeo import gdal
-from pygeotools.lib import iolib, warplib
+import geoutils as gu
 import matplotlib.pyplot as plt
 import matplotlib.colors
 import matplotlib.image as mpimg
@@ -56,6 +56,20 @@ def compile_report(plots_directory, processing_parameters_dict, report_pdf_path)
     pdf.save(report_pdf_path)
 
 
+def get_xml_tag(xml, tag, all=False):
+    import xml.etree.ElementTree as ET
+
+    tree = ET.parse(xml)
+    if all:
+        elem = tree.findall(".//%s" % tag)
+        elem = [i.text for i in elem]
+    else:
+        elem = tree.find(".//%s" % tag)
+        elem = elem.text
+
+    return elem
+
+
 class ColorBar:
     def __init__(self, perc_range=(2, 98), symm=False):
         self.perc_range = perc_range
@@ -134,8 +148,7 @@ class Raster:
         hillshade = np.ma.masked_equal(hs_ds.ReadAsArray(), 0)
         return hillshade
 
-    def compute_difference(self, second_fn, outdir=None):
-        print(f"Computing difference map between:\n\n{self.fn}\n\nand\n\n{second_fn}")
+    def compute_difference(self, second_fn):
         fn_list = [self.fn, second_fn]
         outdir = os.path.dirname(os.path.abspath(self.fn))
 
@@ -145,17 +158,11 @@ class Raster:
             + os.path.splitext(os.path.split(second_fn)[1])[0]
         )
 
-        ds_list = warplib.memwarp_multi_fn(
-            fn_list, extent="intersection", res="max", t_srs="first", r="cubic"
-        )
-        r1_ds = ds_list[0]
-        r2_ds = ds_list[1]
-        r1 = iolib.ds_getma(r1_ds, 1)
-        r2 = iolib.ds_getma(r2_ds, 1)
-        diff = r2 - r1
+        rasters = gu.raster.load_multiple_rasters(fn_list, ref_grid=1)
+        diff = rasters[1] - rasters[0]
         dst_fn = os.path.join(outdir, outprefix + "_diff.tif")
-        iolib.writeGTiff(diff, dst_fn, r1_ds, ndv=-9999)
-        return diff
+        diff.save(dst_fn)
+        return diff.data
 
 
 class Plotter:

{asp_plot-0.1.0 → asp_plot-0.2.0}/asp_plot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: asp_plot
-Version: 0.1.0
+Version: 0.2.0
 Summary: Package for plotting outputs Ames Stereo Pipeline processing
 Author: Ben Purinton
 Author-email: Ben Purinton <purinton@uw.edu>
@@ -54,6 +54,12 @@ $ pytest
 
 ### Package and upload
 
+```
+$ rm -rf dist/
+```
+
+Then update version in `pyproject.toml` and `setup.py`, then:
+
 ```
 $ python3 -m pip install --upgrade build
 $ python3 -m build

{asp_plot-0.1.0 → asp_plot-0.2.0}/asp_plot.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ asp_plot/bundle_adjust.py
 asp_plot/processing_parameters.py
 asp_plot/scenes.py
 asp_plot/stereo.py
+asp_plot/stereopair_metadata_parser.py
 asp_plot/utils.py
 asp_plot.egg-info/PKG-INFO
 asp_plot.egg-info/SOURCES.txt

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "asp_plot"
-version = "0.1.0"
+version = "0.2.0"
 authors = [
   { name="Ben Purinton", email="purinton@uw.edu" },
 ]

{asp_plot-0.1.0 → asp_plot-0.2.0}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="asp_plot",
-    version="0.1.0",
+    version="0.2.0",
     description="Python library and client for plotting Ames Stereo Pipeline outputs",
     author="Ben Purinton",
     author_email="purinton@uw.edu",

{asp_plot-0.1.0 → asp_plot-0.2.0}/tests/__init__.py

@@ -1,4 +1,5 @@
 import asp_plot.utils
+import asp_plot.stereopair_metadata_parser
 import asp_plot.processing_parameters
 import asp_plot.scenes
 import asp_plot.bundle_adjust

asp_plot-0.2.0/tests/test_bundle_adjust.py

@@ -0,0 +1,40 @@
+import pytest
+from asp_plot.bundle_adjust import ReadBundleAdjustFiles, PlotBundleAdjustFiles
+import matplotlib
+import geopandas as gpd
+import pandas as pd
+
+matplotlib.use("Agg")
+
+
+class TestBundleAdjust:
+    @pytest.fixture
+    def ba_files(self):
+        directory = "tests/test_data"
+        ba_directory = "ba"
+        return ReadBundleAdjustFiles(directory, ba_directory)
+
+    def test_get_initial_final_residuals_gdfs(self, ba_files):
+        resid_initial, resid_final = ba_files.get_initial_final_residuals_gdfs()
+        assert isinstance(resid_initial, gpd.GeoDataFrame)
+        assert isinstance(resid_final, gpd.GeoDataFrame)
+
+    def test_get_initial_final_geodiff_gdfs(self, ba_files):
+        geodiff_initial, geodiff_final = ba_files.get_initial_final_geodiff_gdfs()
+        assert isinstance(geodiff_initial, gpd.GeoDataFrame)
+        assert isinstance(geodiff_final, gpd.GeoDataFrame)
+
+    def test_get_mapproj_residuals_gdf(self, ba_files):
+        resid_mapprojected_gdf = ba_files.get_mapproj_residuals_gdf()
+        assert isinstance(resid_mapprojected_gdf, gpd.GeoDataFrame)
+
+    def test_get_propagated_triangulation_uncert_df(self, ba_files):
+        resid_triangulation_uncert_df = ba_files.get_propagated_triangulation_uncert_df()
+        assert isinstance(resid_triangulation_uncert_df, pd.DataFrame)
+
+    def test_plot_n_gdfs(self, ba_files):
+        resid_initial, resid_final = ba_files.get_initial_final_residuals_gdfs()
+        try:
+            PlotBundleAdjustFiles([resid_initial, resid_final]).plot_n_gdfs(column_name="mean_residual")
+        except Exception as e:
+            pytest.fail(f"figure method raised an exception: {str(e)}")

{asp_plot-0.1.0 → asp_plot-0.2.0}/tests/test_imports.py

@@ -7,6 +7,7 @@ class TestImports:
 
     def test_import_asp_plot_modules(self):
         import asp_plot.utils
+        import asp_plot.stereopair_metadata_parser
         import asp_plot.scenes
         import asp_plot.processing_parameters
         import asp_plot.bundle_adjust
@@ -14,7 +15,8 @@ class TestImports:
 
     def test_import_asp_plot_classes(self):
         from asp_plot.utils import ColorBar, Raster, Plotter
-        from asp_plot.scenes import ScenePlotter
+        from asp_plot.stereopair_metadata_parser import StereopairMetadataParser
+        from asp_plot.scenes import ScenePlotter, SceneGeometryPlotter
         from asp_plot.processing_parameters import ProcessingParameters
-        from asp_plot.bundle_adjust import ReadResiduals, PlotResiduals
+        from asp_plot.bundle_adjust import ReadBundleAdjustFiles, PlotBundleAdjustFiles
         from asp_plot.stereo import StereoPlotter

{asp_plot-0.1.0 → asp_plot-0.2.0}/tests/test_scenes.py

@@ -1,5 +1,5 @@
 import pytest
-from asp_plot.scenes import ScenePlotter
+from asp_plot.scenes import ScenePlotter, SceneGeometryPlotter
 import matplotlib
 
 matplotlib.use("Agg")
@@ -15,8 +15,21 @@ class TestScenePlotter:
         )
         return scene_plotter
 
+    @pytest.fixture
+    def scene_geometry_plotter(self):
+        scene_geometry_plotter = SceneGeometryPlotter(
+            directory="tests/test_data",
+        )
+        return scene_geometry_plotter
+
     def test_plot_orthos(self, scene_plotter):
         try:
             scene_plotter.plot_orthos()
         except Exception as e:
             pytest.fail(f"figure method raised an exception: {str(e)}")
+
+    def test_dg_geom_plot(self, scene_geometry_plotter):
+        try:
+            scene_geometry_plotter.dg_geom_plot()
+        except Exception as e:
+            pytest.fail(f"figure method raised an exception: {str(e)}")

asp_plot-0.1.0/asp_plot/scenes.py

@@ -1,68 +0,0 @@
-import os
-import glob
-import matplotlib.pyplot as plt
-from dgtools.lib import dglib
-from asp_plot.utils import Raster, Plotter, save_figure
-
-
-class ScenePlotter(Plotter):
-    def __init__(self, directory, stereo_directory, **kwargs):
-        super().__init__(**kwargs)
-        self.directory = directory
-        self.stereo_directory = stereo_directory
-
-        try:
-            self.left_ortho_sub_fn = glob.glob(
-                os.path.join(self.directory, self.stereo_directory, "*-L_sub.tif")
-            )[0]
-            self.right_ortho_sub_fn = glob.glob(
-                os.path.join(self.directory, self.stereo_directory, "*-R_sub.tif")
-            )[0]
-        except:
-            raise ValueError(
-                "Could not find L-sub and R-sub images in stereo directory"
-            )
-
-    def get_names_and_gsd(self):
-        left_name, right_name = self.left_ortho_sub_fn.split("/")[-1].split("_")[2:4]
-        right_name = right_name.split("-")[0]
-
-        gsds = []
-        for image in [left_name, right_name]:
-            xml_fn = glob.glob(os.path.join(self.directory, f"{image}*.xml"))[0]
-            gsd = dglib.getTag(xml_fn, "MEANPRODUCTGSD")
-            if gsd is None:
-                gsd = dglib.getTag(xml_fn, "MEANCOLLECTEDGSD")
-            gsds.append(round(float(gsd), 2))
-
-        scene_dict = {
-            "left_name": left_name,
-            "right_name": right_name,
-            "left_gsd": gsds[0],
-            "right_gsd": gsds[1],
-        }
-
-        return scene_dict
-
-    def plot_orthos(self, save_dir=None, fig_fn=None):
-        scene_dict = self.get_names_and_gsd()
-
-        fig, axa = plt.subplots(1, 2, figsize=(10, 5), dpi=300)
-        fig.suptitle(self.title, size=10)
-        axa = axa.ravel()
-
-        ortho_ma = Raster(self.left_ortho_sub_fn).read_array()
-        self.plot_array(ax=axa[0], array=ortho_ma, cmap="gray", add_cbar=False)
-        axa[0].set_title(
-            f"Left image\n{scene_dict['left_name']}, {scene_dict['left_gsd']:0.2f} m"
-        )
-
-        ortho_ma = Raster(self.right_ortho_sub_fn).read_array()
-        self.plot_array(ax=axa[1], array=ortho_ma, cmap="gray", add_cbar=False)
-        axa[1].set_title(
-            f"Right image\n{scene_dict['right_name']}, {scene_dict['right_gsd']:0.2f} m"
-        )
-
-        fig.tight_layout()
-        if save_dir and fig_fn:
-            save_figure(fig, save_dir, fig_fn)

asp_plot-0.1.0/tests/test_bundle_adjust.py

@@ -1,35 +0,0 @@
-import pytest
-from asp_plot.bundle_adjust import ReadResiduals, PlotResiduals
-import matplotlib
-import geopandas as gpd
-import pandas as pd
-
-matplotlib.use("Agg")
-
-
-class TestBundleAdjust:
-    @pytest.fixture
-    def residual_files(self):
-        directory = "tests/test_data"
-        ba_directory = "ba"
-        return ReadResiduals(directory, ba_directory)
-
-    def test_get_init_final_residuals_gdfs(self, residual_files):
-        resid_init, resid_final = residual_files.get_init_final_residuals_gdfs()
-        assert isinstance(resid_init, gpd.GeoDataFrame)
-        assert isinstance(resid_final, gpd.GeoDataFrame)
-
-    def test_get_mapproj_residuals_gdf(self, residual_files):
-        resid_mapprojected_gdf = residual_files.get_mapproj_residuals_gdf()
-        assert isinstance(resid_mapprojected_gdf, gpd.GeoDataFrame)
-
-    def test_get_propagated_triangulation_uncert_df(self, residual_files):
-        resid_triangulation_uncert_df = residual_files.get_propagated_triangulation_uncert_df()
-        assert isinstance(resid_triangulation_uncert_df, pd.DataFrame)
-
-    def test_plot_n_residuals(self, residual_files):
-        resid_init, resid_final = residual_files.get_init_final_residuals_gdfs()
-        try:
-            PlotResiduals([resid_init, resid_final]).plot_n_residuals(column_name="mean_residual")
-        except Exception as e:
-            pytest.fail(f"figure method raised an exception: {str(e)}")