From e93aa60c6a1321a6c7861f648bc230d320faa8fd Mon Sep 17 00:00:00 2001 From: Ben Purinton Date: Sun, 7 Jul 2024 17:31:43 -0700 Subject: [PATCH] Internal dg_geom_plot functionality (#24) Previously, a system call was being made to dg_geom_plot.py, which is a command line function contained in the dgtools library. We are trying to move away from this library, so the functionality is ported here. Largely this was just copying over methods and imposing some structure on them. This PR removes any existing dgtools dependency from the asp_plot package. --- README.md | 2 + asp_plot/__init__.py | 1 + asp_plot/cli/asp_plot.py | 15 +- asp_plot/scenes.py | 198 +++++++++++-- asp_plot/stereopair_metadata_parser.py | 330 ++++++++++++++++++++++ asp_plot/utils.py | 14 + environment.yml | 1 - notebooks/dg_stereo_geometry.ipynb | 108 ------- notebooks/scene_plots.ipynb | 40 ++- tests/__init__.py | 1 + tests/test_data/10300100D0772D00.r100.xml | 198 +++++++++++++ tests/test_data/10300100D12D7400.r100.xml | 198 +++++++++++++ tests/test_data/left.r100.xml | 40 --- tests/test_data/right.r100.xml | 40 --- tests/test_imports.py | 4 +- tests/test_scenes.py | 15 +- 16 files changed, 975 insertions(+), 230 deletions(-) create mode 100644 asp_plot/stereopair_metadata_parser.py delete mode 100644 notebooks/dg_stereo_geometry.ipynb create mode 100644 tests/test_data/10300100D0772D00.r100.xml create mode 100644 tests/test_data/10300100D12D7400.r100.xml delete mode 100644 tests/test_data/left.r100.xml delete mode 100644 tests/test_data/right.r100.xml diff --git a/README.md b/README.md index 09c86ad..ace93fd 100644 --- a/README.md +++ b/README.md @@ -39,6 +39,8 @@ $ pytest ### Package and upload +Update version in `pyproject.toml` and `setup.py`, then: + ``` $ python3 -m pip install --upgrade build $ python3 -m build diff --git a/asp_plot/__init__.py b/asp_plot/__init__.py index 5200333..cf0275b 100644 --- a/asp_plot/__init__.py +++ b/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 diff --git a/asp_plot/cli/asp_plot.py b/asp_plot/cli/asp_plot.py index f5ab66d..7ab1f5f 100644 --- a/asp_plot/cli/asp_plot.py +++ b/asp_plot/cli/asp_plot.py @@ -4,7 +4,7 @@ import click import contextily as ctx from asp_plot.processing_parameters import ProcessingParameters -from asp_plot.scenes import ScenePlotter +from asp_plot.scenes import ScenePlotter, SceneGeometryPlotter from asp_plot.bundle_adjust import ReadResiduals, PlotResiduals from asp_plot.stereo import StereoPlotter from asp_plot.utils import compile_report @@ -69,16 +69,9 @@ def main( report_pdf_path = os.path.join(directory, report_filename) # 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="00_geometry.png") # Scene plot plotter = ScenePlotter(directory, stereo_directory, title="Mapprojected Scenes") diff --git a/asp_plot/scenes.py b/asp_plot/scenes.py index d8d53d7..9fdbeb0 100644 --- a/asp_plot/scenes.py +++ b/asp_plot/scenes.py @@ -1,8 +1,177 @@ import os import glob +import numpy as np import matplotlib.pyplot as plt -from dgtools.lib import dglib +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): @@ -23,29 +192,8 @@ def __init__(self, directory, stereo_directory, **kwargs): "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() + p = StereopairMetadataParser(self.directory).get_pair_dict() fig, axa = plt.subplots(1, 2, figsize=(10, 5), dpi=300) fig.suptitle(self.title, size=10) @@ -54,13 +202,13 @@ def plot_orthos(self, save_dir=None, fig_fn=None): 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" + 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{scene_dict['right_name']}, {scene_dict['right_gsd']:0.2f} m" + f"Right image\n{p['id2_dict']['id']}, {p['id2_dict']['meanproductgsd']:0.2f} m" ) fig.tight_layout() diff --git a/asp_plot/stereopair_metadata_parser.py b/asp_plot/stereopair_metadata_parser.py new file mode 100644 index 0000000..6456ca0 --- /dev/null +++ b/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 diff --git a/asp_plot/utils.py b/asp_plot/utils.py index e6ec5df..a34611c 100644 --- a/asp_plot/utils.py +++ b/asp_plot/utils.py @@ -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 diff --git a/environment.yml b/environment.yml index df11a35..a607e85 100644 --- a/environment.yml +++ b/environment.yml @@ -17,4 +17,3 @@ dependencies: - click - pip: - markdown-pdf - - git+https://github.com/dshean/dgtools.git diff --git a/notebooks/dg_stereo_geometry.ipynb b/notebooks/dg_stereo_geometry.ipynb deleted file mode 100644 index 3a8a9fd..0000000 --- a/notebooks/dg_stereo_geometry.ipynb +++ /dev/null @@ -1,108 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import glob\n", - "from asp_plot.utils import show_existing_figure" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "directory = \"/Users/ben/Dropbox/UW_Shean/WV/2022/WV03_20220417_1040010074793300_1040010075633C00/\"\n", - "\n", - "plots_directory = os.path.join(directory, \"stereo_report_plots\")\n", - "os.makedirs(plots_directory, exist_ok=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting pair dictionary from xml within directory\n", - "{'id1_dict': {'id': '1040010074793300', 'sensor': 'WV03', 'date': datetime.datetime(2022, 4, 17, 22, 51, 49, 53175), 'alt': -99999.0, 'az': 350.5, 'el': 67.4, 'sunaz': 187.3, 'sunel': 29.4, 'gsd': 0.35, 'scandir': 'Forward', 'tdi': 32, 'offnadir': 20.6, 'intrack': 15.9, 'crosstrack': -13.3, 'cloudcover': 0.0, 'geom': >, 'geom_poly': , 'stereopair': None}, 'id2_dict': {'id': '1040010075633C00', 'sensor': 'WV03', 'date': datetime.datetime(2022, 4, 17, 22, 52, 47, 937775), 'alt': -99999.0, 'az': 244.3, 'el': 63.9, 'sunaz': 187.6, 'sunel': 29.4, 'gsd': 0.36, 'scandir': 'Forward', 'tdi': 32, 'offnadir': 23.5, 'intrack': -19.1, 'crosstrack': -14.0, 'cloudcover': 0.0, 'geom': >, 'geom_poly': , 'stereopair': None}, 'intersection': >, 'intersection_poly': , 'int_w': 13.91, 'int_h': 14.33, 'intersection_area': 194.13, 'intersection_area_perc': (97.95, 86.48), 'pairtype': 'coincident', 'cdate': datetime.datetime(2022, 4, 17, 22, 52, 18, 495475), 'pairname': 'WV03_20220417_1040010074793300_1040010075633C00', 'dt': datetime.timedelta(seconds=58, microseconds=884600), 'conv_ang': 38.57, 'bh_ratio': 0.7}\n", - "Creating figure\n", - "Saving figure\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n", - "swig/python detected a memory leak of type 'OSRSpatialReferenceShadow *', no destructor found.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "try:\n", - " filename = glob.glob(os.path.join(plots_directory, \"00_stereo_geom.png\"))[0]\n", - "except:\n", - " !dg_geom_plot.py $directory/\n", - " !mv $directory/*stereo_geom.png $plots_directory/00_stereo_geom.png\n", - " filename = glob.glob(os.path.join(plots_directory, \"00_stereo_geom.png\"))[0]\n", - "\n", - "show_existing_figure(filename)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "asp_plot", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/scene_plots.ipynb b/notebooks/scene_plots.ipynb index 02618db..f031250 100644 --- a/notebooks/scene_plots.ipynb +++ b/notebooks/scene_plots.ipynb @@ -8,7 +8,7 @@ "source": [ "import os\n", "import glob\n", - "from asp_plot.scenes import ScenePlotter" + "from asp_plot.scenes import ScenePlotter, SceneGeometryPlotter" ] }, { @@ -21,7 +21,7 @@ "\n", "stereo_directory = \"stereo_ba_50ips_10matches_dg_weight_image__ortho_0.35m_mode_asp_mgm_spm_9_corr_7_rfne_15_cost_4_refdem_COP30/\"\n", "\n", - "plots_directory = os.path.join(directory, \"stereo_report_plots\")\n", + "plots_directory = os.path.join(directory, \"asp_plots\")\n", "os.makedirs(plots_directory, exist_ok=True)" ] }, @@ -34,7 +34,41 @@ "name": "stdout", "output_type": "stream", "text": [ - "Figure saved to /Users/ben/Dropbox/UW_Shean/WV/2022/WV03_20220417_1040010074793300_1040010075633C00/stereo_report_plots/01_orthos.png\n" + "Figure saved to /Users/ben/Dropbox/UW_Shean/WV/2022/WV03_20220417_1040010074793300_1040010075633C00/asp_plots/00_geometry.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "geometry_plotter = SceneGeometryPlotter(\n", + " directory\n", + ")\n", + "\n", + "geometry_plotter.dg_geom_plot(\n", + " save_dir=plots_directory,\n", + " fig_fn=\"00_geometry.png\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure saved to /Users/ben/Dropbox/UW_Shean/WV/2022/WV03_20220417_1040010074793300_1040010075633C00/asp_plots/01_orthos.png\n" ] }, { diff --git a/tests/__init__.py b/tests/__init__.py index 5200333..cf0275b 100644 --- a/tests/__init__.py +++ b/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 diff --git a/tests/test_data/10300100D0772D00.r100.xml b/tests/test_data/10300100D0772D00.r100.xml new file mode 100644 index 0000000..1b204b9 --- /dev/null +++ b/tests/test_data/10300100D0772D00.r100.xml @@ -0,0 +1,198 @@ + + + + 28.3 + 2022-04-20T00:39:58.000000Z + 506307115010_01_P001 + A030014EDF270900 + 2100014EDF278900 + Stereo1B + P + None + 27648 + 35840 + Stereo 1B + Stereo + 2 + Corrected + 16 + JPEG2000 + nga_npje_pan_vl + NITF21NCDRD + + -156.96728186 + 71.3905794 + 7.0 + -156.26933237 + 71.41487852 + 7.0 + -156.26960335 + 71.27367568 + 7.0 + -156.96663244 + 71.25047932 + 7.0 + 5.671181000000000e-02 + 2.846000000000000e-01 + 32 + + + WV02 + FullSwath + Forward + 10300100D0772D00 + 2022-04-19T23:22:03.016375Z + 2 + + 0.0 0.000000000000000e+00 + 27128.0 1.356400000000000e+00 + + 2022-04-19T23:22:03.016375Z + 20000.0 + 0.0016 + 0.578 + 0.579 + 0.578 + 0.708 + 0.712 + 0.71 + 0.641 + 0.644 + 196.0 + 29.6 + 253.0 + 52.7 + -25.8 + -20.8 + 32.7 + 0.000000000000000e+00 + CC + R + R + 65749 + + + + WV02 + 65749 + D0772D + R + A + 2022-04-20T00:10:10.000000Z + 2022-04-19T23:21:50.802462Z + 1290 + 2.000000000000000e-02 + + 1.000000000000000e+00 -2.376734445581231e+06 -4.937899117823490e+05 6.710656000512007e+06 -6.894866257666830e+03 2.062603586427500e+03 -2.286176158765002e+03 5.604397619800000e-03 -1.181622198400000e-03 1.592937903700000e-03 1.961012851100000e-03 -3.520967390600000e-04 1.625537506400000e-03 + 2.000000000000000e+00 -2.376872341863499e+06 -4.937486595295612e+05 6.710610275671840e+06 -6.894808481897408e+03 2.062634504180985e+03 -2.286323359653352e+03 5.604397619800000e-03 -1.181622198400000e-03 1.592937903700000e-03 1.961012851100000e-03 -3.520967390600000e-04 1.625537506400000e-03 + 3.000000000000000e+00 -2.377010236991019e+06 -4.937074066582139e+05 6.710564547887411e+06 -6.894750702831720e+03 2.062665420516381e+03 -2.286470560417582e+03 5.604397619800000e-03 -1.181622198400000e-03 1.592937903700000e-03 1.961012851100000e-03 -3.520967390600000e-04 1.625537506400000e-03 + + + + WV02 + 65749 + D0772D + R + A + 2022-04-20T00:27:50.000000Z + 2022-04-19T23:21:50.802462Z + 1290 + 2.000000000000000e-02 + + 1.000000000000000e+00 1.826478404723776e-01 -9.001226150190798e-01 2.219204422829834e-01 -3.273688464086277e-01 1.427870000000000e-11 1.824600000000000e-12 -2.973700000000000e-12 -1.066000000000000e-13 2.094600000000000e-12 3.387100000000000e-12 -2.492000000000000e-12 1.660730000000000e-11 2.087400000000000e-12 9.294700000000000e-12 + 2.000000000000000e+00 1.826222614675276e-01 -9.001336099005433e-01 2.219734064990893e-01 -3.273169729040842e-01 1.427870000000000e-11 1.824600000000000e-12 -2.973700000000000e-12 -1.066000000000000e-13 2.094600000000000e-12 3.387100000000000e-12 -2.492000000000000e-12 1.660730000000000e-11 2.087400000000000e-12 9.294700000000000e-12 + 3.000000000000000e+00 1.825966732690519e-01 -9.001445998884704e-01 2.220263634188459e-01 -3.272651037762860e-01 1.427870000000000e-11 1.824600000000000e-12 -2.973700000000000e-12 -1.066000000000000e-13 2.094600000000000e-12 3.387100000000000e-12 -2.492000000000000e-12 1.660730000000000e-11 2.087400000000000e-12 9.294700000000000e-12 + + + + 2009-10-08T00:00:00.000000Z + 2010-10-26T00:00:00.000000Z + WV02 + LV1B + + 2010-01-28T00:00:00.000000Z + 1.324613900000000e+04 + + + 2009-09-10T00:00:00.000000Z + -1 + + + + + 2009-09-10T00:00:00.000000Z + 0.000000000000000e+00 + 0.000000000000000e+00 + 0.000000000000000e+00 + + + 2009-09-10T00:00:00.000000Z + 0.000000000000000e+00 + 0.000000000000000e+00 + 0.000000000000000e+00 + 1.000000000000000e+00 + + + 2010-10-26T00:00:00.000000Z + + P + + 1 + -2.590000000000001e-01 + 1.407276907149051e+02 + 0.000000000000000e+00 + 0.008 + + + + + + 1 + + 22APR19232034-P1BS-506307115010_01_P001.NTF + 22APR19232202-P1BS-506307115010_01_P001.NTF + 6.980000000000000e-01 + 7.140142600000000e+01 + -1.568797290000000e+02 + 7.126170900000000e+01 + -1.563603880000000e+02 + 4.291000000000000e+01 + 4.277000000000000e+01 + 8.470000000000001e+00 + 8.240000000000000e+00 + 6.534999999999999e+01 + 6.478000000000000e+01 + + + + WV02 + P + RPC00B + + 8.410000000000000e+00 + 3.200000000000000e-01 + 13824.0 + 17920.0 + 71.33267892000001 + -156.618307115 + 7 + 17920.0 + 17920.0 + 0.0821996000000027 + 0.3489747450000067 + 501 + + -0.01608403330989685 0.1278015971712731 -0.8845003952671775 -0.007032982714128716 -0.0004712363497408858 4.220341745091084e-07 4.633192838646099e-08 -0.003262496700858184 -6.864997871211526e-05 5.673985311957565e-07 -1.491394379053945e-07 -2.960022805580296e-06 -1.398232393389854e-06 -9.313185567381118e-08 2.003702834923838e-05 -4.38341976382432e-05 8.337830185510923e-07 4.242179879130293e-08 -4.39330391664543e-07 -2.714358696275648e-08 + + + 1 0.004331084055991852 0.0004091934143404496 -0.0002980211911275577 -2.363273674940127e-05 -5.532528125602867e-07 -1.381590394939722e-06 1.000003781289928e-05 -0.0001569214625748407 -1.042789517252769e-06 -9.602039917846832e-07 -7.213531970517786e-06 3.472773707234433e-05 -1.643623005600691e-08 -6.10769030718506e-05 -0.0001310197369550905 2.760071436271236e-08 7.456432394809586e-07 -1.762293623106321e-06 -1.060750346270357e-07 + + + -0.008101942244412304 0.982079341851438 0.0001979268390718782 0.02877791191006262 2.620066324177147e-06 1.770607586961862e-07 -7.759874558770311e-05 -8.422468613132101e-08 -8.618403109137009e-05 -5.278611713836964e-06 7.36139807746915e-07 -2.59029128991767e-06 -1.49017552596928e-05 -8.281739626686404e-09 9.145759482247212e-06 9.66022154895798e-05 -1.006215438944686e-07 -6.661233494930264e-08 1.842605952064673e-06 2.078004484932883e-08 + + + 1 0.009094960359569174 0.0007571469909184535 -0.0005914066630781094 -3.594266309965652e-05 2.334180686033043e-07 -3.544701254605367e-06 1.020012855286929e-05 5.721850615230705e-05 -3.541599716931164e-08 8.721378697366242e-07 -6.779325762355219e-07 8.853862218976234e-06 -3.570234064912608e-10 -1.878344541066307e-06 -7.990271238040052e-06 1.315056946156253e-07 6.503003285745334e-07 -3.794159656216442e-07 3.3440076497975e-08 + + + + diff --git a/tests/test_data/10300100D12D7400.r100.xml b/tests/test_data/10300100D12D7400.r100.xml new file mode 100644 index 0000000..6dd7e56 --- /dev/null +++ b/tests/test_data/10300100D12D7400.r100.xml @@ -0,0 +1,198 @@ + + + + 28.3 + 2022-04-20T00:38:13.000000Z + 506307115010_01_P001 + A030014EDF270900 + 2100014EDF270800 + Stereo1B + P + None + 27648 + 35840 + Stereo 1B + Stereo + 2 + Corrected + 16 + JPEG2000 + nga_npje_pan_vl + NITF21NCDRD + + -156.87974399 + 71.40722267 + 7.0 + -156.36038847 + 71.39378212 + 7.0 + -156.360567 + 71.25421657 + 7.0 + -156.87959011 + 71.26869213 + 7.0 + 5.671181000000000e-02 + 2.846000000000000e-01 + 32 + + + WV02 + FullSwath + Forward + 10300100D12D7400 + 2022-04-19T23:20:34.923175Z + 2 + + 0.0 0.000000000000000e+00 + 27332.0 1.366600000000000e+00 + + 2022-04-19T23:20:34.923175Z + 20000.0 + 0.0016 + 0.565 + 0.571 + 0.568 + 0.525 + 0.529 + 0.527 + 0.547 + 0.55 + 195.6 + 29.6 + 338.2 + 63.3 + 12.2 + -20.4 + 23.7 + 0.000000000000000e+00 + CC + R + R + 65749 + + + + WV02 + 65749 + D12D74 + R + A + 2022-04-20T00:10:10.000000Z + 2022-04-19T23:20:22.752948Z + 1290 + 2.000000000000000e-02 + + 1.000000000000000e+00 -1.759360021976431e+06 -6.691316312747350e+05 6.883225000419904e+06 -7.118430399017976e+03 1.916827638102612e+03 -1.630566091323703e+03 5.867859879600000e-03 -1.159054263900000e-03 1.207242283900000e-03 1.908124658300000e-03 -2.243363043900000e-04 1.360424675000000e-03 + 2.000000000000000e+00 -1.759502390030533e+06 -6.690932943971527e+05 6.883192387614862e+06 -7.118386494969652e+03 1.916863025817213e+03 -1.630717062635078e+03 5.867859879600000e-03 -1.159054263900000e-03 1.207242283900000e-03 1.908124658300000e-03 -2.243363043900000e-04 1.360424675000000e-03 + 3.000000000000000e+00 -1.759644757206878e+06 -6.690549568117290e+05 6.883159771790296e+06 -7.118342587486475e+03 1.916898412486282e+03 -1.630868034293499e+03 5.867859879600000e-03 -1.159054263900000e-03 1.207242283900000e-03 1.908124658300000e-03 -2.243363043900000e-04 1.360424675000000e-03 + + + + WV02 + 65749 + D12D74 + R + A + 2022-04-20T00:27:39.000000Z + 2022-04-19T23:20:22.752948Z + 1290 + 2.000000000000000e-02 + + 1.000000000000000e+00 1.849074292980253e-01 -9.812146922520021e-01 5.419905928324220e-02 9.456863751593800e-03 1.533310000000000e-11 2.281200000000000e-12 -3.859900000000000e-12 -5.264000000000000e-13 4.693000000000000e-13 7.182000000000000e-13 2.389000000000000e-13 1.487480000000000e-11 2.396000000000000e-13 9.650199999999999e-12 + 2.000000000000000e+00 1.848859988350837e-01 -9.812148872985612e-01 5.426243118648380e-02 9.492151503096000e-03 1.533310000000000e-11 2.281200000000000e-12 -3.859900000000000e-12 -5.264000000000000e-13 4.693000000000000e-13 7.182000000000000e-13 2.389000000000000e-13 1.487480000000000e-11 2.396000000000000e-13 9.650199999999999e-12 + 3.000000000000000e+00 1.848645540230430e-01 -9.812150793193367e-01 5.432580032617040e-02 9.527444627508199e-03 1.533310000000000e-11 2.281200000000000e-12 -3.859900000000000e-12 -5.264000000000000e-13 4.693000000000000e-13 7.182000000000000e-13 2.389000000000000e-13 1.487480000000000e-11 2.396000000000000e-13 9.650199999999999e-12 + + + + 2009-10-08T00:00:00.000000Z + 2010-10-26T00:00:00.000000Z + WV02 + LV1B + + 2010-01-28T00:00:00.000000Z + 1.324613900000000e+04 + + + 2009-09-10T00:00:00.000000Z + -1 + + + + + 2009-09-10T00:00:00.000000Z + 0.000000000000000e+00 + 0.000000000000000e+00 + 0.000000000000000e+00 + + + 2009-09-10T00:00:00.000000Z + 0.000000000000000e+00 + 0.000000000000000e+00 + 0.000000000000000e+00 + 1.000000000000000e+00 + + + 2010-10-26T00:00:00.000000Z + + P + + 1 + -2.590000000000001e-01 + 1.407276907149051e+02 + 0.000000000000000e+00 + 0.008 + + + + + + 1 + + 22APR19232034-P1BS-506307115010_01_P001.NTF + 22APR19232202-P1BS-506307115010_01_P001.NTF + 6.980000000000000e-01 + 7.140142600000000e+01 + -1.568797290000000e+02 + 7.126170900000000e+01 + -1.563603880000000e+02 + 4.291000000000000e+01 + 4.277000000000000e+01 + 8.470000000000001e+00 + 8.240000000000000e+00 + 6.534999999999999e+01 + 6.478000000000000e+01 + + + + WV02 + P + RPC00B + + 6.410000000000000e+00 + 2.500000000000000e-01 + 13824.0 + 17920.0 + 71.33071962 + -156.62006623 + 7 + 17920.0 + 17920.0 + 0.07650304999999946 + 0.2596777600000024 + 501 + + -0.003175756688916184 -0.07657398621194678 -0.8390868101804762 0.02219910977090155 0.0002043422286894441 3.794411566437453e-06 -3.949538353781803e-07 -0.002236788541784655 -1.876888223086877e-05 -1.861257133660986e-06 -3.890981468558874e-08 -5.702362728143263e-07 -5.525474126560074e-06 -3.197931977570498e-08 4.200612835362325e-06 5.608407735877983e-06 4.403825063012478e-07 3.007545380833038e-07 -1.094392209000623e-06 1.632441163483781e-08 + + + 1 0.003238973305533706 -0.003154984596761906 -0.0002548743933169129 -1.496591789433037e-05 -5.817574528773926e-08 -3.879769566284449e-06 1.500779909775009e-06 1.723936917196592e-05 -4.207292631142281e-07 -4.41607976633997e-06 -4.29915110102948e-07 5.510836930222256e-05 -1.00448526343609e-07 -4.016867713971299e-05 0.0001115838395508618 4.924819089422789e-07 2.673064472407797e-07 -1.435531379137987e-05 5.454479368974449e-08 + + + -0.01519677405446854 0.9818756923581996 -3.412902366968686e-05 0.009886861873441575 2.162254878877333e-06 -6.343526411110305e-08 -0.0002099740595962228 1.356217983097315e-08 0.0002126292813514599 5.706934916385812e-06 2.52834432060274e-07 3.928020525413844e-07 -8.640846821069213e-06 8.472167650408908e-09 8.909714827557085e-06 -4.17396027615384e-05 -4.41096887378806e-08 -3.750934388105186e-07 1.472491584166942e-06 -2.214869324957485e-08 + + + 1 0.001983956645182093 0.0002841659015304777 -0.0005919136531327441 -3.495002088246505e-05 1.466042255492093e-06 -4.2051494087243e-06 -1.533586923618053e-06 3.727199366769946e-05 4.677531100269256e-09 3.32512555326629e-06 -2.682877706572529e-07 2.125352069425973e-06 -1.211549331970363e-07 3.854371694281459e-07 4.157676044151139e-05 4.71995847721125e-08 1.680360448716378e-07 -3.789727095908074e-06 3.057238930160978e-08 + + + + diff --git a/tests/test_data/left.r100.xml b/tests/test_data/left.r100.xml deleted file mode 100644 index 7e42510..0000000 --- a/tests/test_data/left.r100.xml +++ /dev/null @@ -1,40 +0,0 @@ - - - - - WV02 - FullSwath - Forward - 10300100D12D7400 - 2022-04-19T23:20:34.923175Z - 2 - - 0.0 0.000000000000000e+00 - 27332.0 1.366600000000000e+00 - - 2022-04-19T23:20:34.923175Z - 20000.0 - 0.0016 - 0.565 - 0.571 - 0.568 - 0.525 - 0.529 - 0.527 - 0.547 - 0.55 - 195.6 - 29.6 - 338.2 - 63.3 - 12.2 - -20.4 - 23.7 - 0.000000000000000e+00 - CC - R - R - 65749 - - - diff --git a/tests/test_data/right.r100.xml b/tests/test_data/right.r100.xml deleted file mode 100644 index 2247924..0000000 --- a/tests/test_data/right.r100.xml +++ /dev/null @@ -1,40 +0,0 @@ - - - - - WV02 - FullSwath - Forward - 10300100D0772D00 - 2022-04-19T23:22:03.016375Z - 2 - - 0.0 0.000000000000000e+00 - 27128.0 1.356400000000000e+00 - - 2022-04-19T23:22:03.016375Z - 20000.0 - 0.0016 - 0.578 - 0.579 - 0.578 - 0.708 - 0.712 - 0.71 - 0.641 - 0.644 - 196.0 - 29.6 - 253.0 - 52.7 - -25.8 - -20.8 - 32.7 - 0.000000000000000e+00 - CC - R - R - 65749 - - - diff --git a/tests/test_imports.py b/tests/test_imports.py index 17b4352..14596af 100644 --- a/tests/test_imports.py +++ b/tests/test_imports.py @@ -7,6 +7,7 @@ def test_import(self): 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 @@ def test_import_asp_plot_modules(self): 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.stereo import StereoPlotter diff --git a/tests/test_scenes.py b/tests/test_scenes.py index 748d612..1426b4a 100644 --- a/tests/test_scenes.py +++ b/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 @@ def scene_plotter(self): ) 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)}")