Changes to seismic access and router and layer framework

Author: rubenthoms

backend_py/primary/primary/routers/_shared/schemas.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class BoundingBox3d(BaseModel):
+    """Bounding box for a 3D grid geometry"""
+
+    xmin: float
+    ymin: float
+    zmin: float
+    xmax: float
+    ymax: float
+    zmax: float

backend_py/primary/primary/routers/grid3d/schemas.py

@@ -3,6 +3,8 @@
 from pydantic import BaseModel
 from webviz_pkg.core_utils.b64 import B64FloatArray, B64UintArray
 
+from .._shared.schemas import BoundingBox3d
+
 
 # Rename?
 class Grid3dGeometry(BaseModel):
@@ -26,17 +28,6 @@ class Grid3dMappedProperty(BaseModel):
     max_grid_prop_value: float
 
 
-class BoundingBox3d(BaseModel):
-    """Bounding box for a 3D grid geometry"""
-
-    xmin: float
-    ymin: float
-    zmin: float
-    xmax: float
-    ymax: float
-    zmax: float
-
-
 class Grid3dZone(BaseModel):
     """Named subset of 3D grid layers (Zone)"""
 

backend_py/primary/primary/routers/seismic/converters.py

@@ -1,50 +1,66 @@
-from typing import List
-
-import orjson
 import numpy as np
-import xtgeo
+from numpy.typing import NDArray
+from webviz_pkg.core_utils.b64 import b64_encode_float_array_as_float32
 
+from primary.services.vds_access.response_types import VdsSliceMetadata
+from primary.services.sumo_access.seismic_types import SeismicCubeMeta
 from . import schemas
 
 
-def surface_to_float32_array(values: np.ndarray) -> List[float]:
-    values = values.astype(np.float32)
-    np.ma.set_fill_value(values, np.nan)
-    values = np.ma.filled(values)
-
-    # Rotate 90 deg left.
-    # This will cause the width of to run along the X axis
-    # and height of along Y axis (starting from bottom.)
-    values = np.rot90(values)
+def to_api_vds_cube_meta(seismic_meta: SeismicCubeMeta) -> schemas.SeismicCubeMeta:
+    """
+    Create API SeismicCubeMeta from VdsSliceMetadata
+    """
 
-    return values.flatten().tolist()
+    return schemas.SeismicCubeMeta(
+        seismicAttribute=seismic_meta.seismic_attribute,
+        unit=seismic_meta.unit,
+        isoDateOrInterval=seismic_meta.iso_date_or_interval,
+        isObservation=seismic_meta.is_observation,
+        isDepth=seismic_meta.is_depth,
+        bbox=schemas.BoundingBox3d(
+            xmin=seismic_meta.bbox.xmin,
+            ymin=seismic_meta.bbox.ymin,
+            zmin=seismic_meta.bbox.zmin,
+            xmax=seismic_meta.bbox.xmax,
+            ymax=seismic_meta.bbox.ymax,
+            zmax=seismic_meta.bbox.zmax,
+        ),
+        spec=schemas.SeismicCubeSpec(
+            numCols=seismic_meta.spec.num_cols,
+            numRows=seismic_meta.spec.num_rows,
+            numLayers=seismic_meta.spec.num_layers,
+            xOrigin=seismic_meta.spec.x_origin,
+            yOrigin=seismic_meta.spec.y_origin,
+            zOrigin=seismic_meta.spec.z_origin,
+            xInc=seismic_meta.spec.x_inc,
+            yInc=seismic_meta.spec.y_inc,
+            zInc=seismic_meta.spec.z_inc,
+            yFlip=seismic_meta.spec.y_flip,
+            zFlip=seismic_meta.spec.z_flip,
+            rotation=seismic_meta.spec.rotation,
+        ),
+    )
 
 
-def to_api_surface_data(
-    xtgeo_surf: xtgeo.RegularSurface, property_values: np.ndarray
-) -> schemas.SurfaceMeshAndProperty:
+def to_api_vds_slice_data(
+    flattened_slice_traces_array: NDArray[np.float32], metadata: VdsSliceMetadata
+) -> schemas.SeismicSliceData:
     """
-    Create API SurfaceData from xtgeo regular surface
+    Create API SeismicCrosslineData from VdsSliceMetadata and flattened slice traces array
     """
-    float32_mesh = surface_to_float32_array(xtgeo_surf.values)
-    float32_property = surface_to_float32_array(property_values)
 
-    return schemas.SurfaceMeshAndProperty(
-        x_ori=xtgeo_surf.xori,
-        y_ori=xtgeo_surf.yori,
-        x_count=xtgeo_surf.ncol,
-        y_count=xtgeo_surf.nrow,
-        x_inc=xtgeo_surf.xinc,
-        y_inc=xtgeo_surf.yinc,
-        x_min=xtgeo_surf.xmin,
-        x_max=xtgeo_surf.xmax,
-        y_min=xtgeo_surf.ymin,
-        y_max=xtgeo_surf.ymax,
-        mesh_value_min=xtgeo_surf.values.min(),
-        mesh_value_max=xtgeo_surf.values.max(),
-        property_value_min=property_values.min(),
-        property_value_max=property_values.max(),
-        rot_deg=xtgeo_surf.rotation,
-        mesh_data=orjson.dumps(float32_mesh).decode("utf-8"),  # pylint: disable=maybe-no-member
-        property_data=orjson.dumps(float32_property).decode("utf-8"),  # pylint: disable=maybe-no-member
+    return schemas.SeismicSliceData(
+        slice_traces_b64arr=b64_encode_float_array_as_float32(flattened_slice_traces_array),
+        bbox_utm=metadata.geospatial,
+        u_min=metadata.x["min"],
+        u_max=metadata.x["max"],
+        u_num_samples=metadata.x["samples"],
+        u_unit=metadata.x["unit"],
+        v_min=metadata.y["min"],
+        v_max=metadata.y["max"],
+        v_num_samples=metadata.y["samples"],
+        v_unit=metadata.y["unit"],
+        value_min=np.nanmin(flattened_slice_traces_array),
+        value_max=np.nanmax(flattened_slice_traces_array),
     )

backend_py/primary/primary/routers/seismic/router.py

@@ -10,8 +10,8 @@
 from primary.services.vds_access.request_types import VdsCoordinates, VdsCoordinateSystem
 from primary.services.vds_access.response_types import VdsMetadata
 from primary.services.vds_access.vds_access import VdsAccess
-
 from . import schemas
+from . import converters
 
 LOGGER = logging.getLogger(__name__)
 
@@ -32,11 +32,128 @@ async def get_seismic_cube_meta_list(
     )
     seismic_cube_meta_list = await access.get_seismic_cube_meta_list_async()
     try:
-        return [schemas.SeismicCubeMeta(**meta.__dict__) for meta in seismic_cube_meta_list]
+        return [converters.to_api_vds_cube_meta(meta) for meta in seismic_cube_meta_list]
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
 
+@router.get("/get_inline_slice/")
+async def get_inline_slice(
+    authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+    case_uuid: str = Query(description="Sumo case uuid"),
+    ensemble_name: str = Query(description="Ensemble name"),
+    realization_num: int = Query(description="Realization number"),
+    seismic_attribute: str = Query(description="Seismic cube attribute"),
+    time_or_interval_str: str = Query(description="Timestamp or timestep"),
+    observed: bool = Query(description="Observed or simulated"),
+    inline_no: int = Query(description="Inline number"),
+) -> schemas.SeismicSliceData:
+    """Get a seismic inline from a seismic cube."""
+    seismic_access = await SeismicAccess.from_case_uuid_async(
+        authenticated_user.get_sumo_access_token(), case_uuid, ensemble_name
+    )
+
+    vds_handle: Optional[VdsHandle] = None
+    try:
+        vds_handle = await seismic_access.get_vds_handle_async(
+            realization=realization_num,
+            seismic_attribute=seismic_attribute,
+            time_or_interval_str=time_or_interval_str,
+            observed=observed,
+        )
+    except ValueError as err:
+        raise HTTPException(status_code=404, detail=str(err)) from err
+
+    if vds_handle is None:
+        raise HTTPException(status_code=404, detail="Vds handle not found")
+
+    vds_access = VdsAccess(sas_token=vds_handle.sas_token, vds_url=vds_handle.vds_url)
+
+    flattened_slice_traces_array, metadata = await vds_access.get_inline_slice(line_no=inline_no)
+
+    return converters.to_api_vds_slice_data(
+        flattened_slice_traces_array=flattened_slice_traces_array, metadata=metadata
+    )
+
+
+@router.get("/get_crossline_slice/")
+async def get_crossline_slice(
+    authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+    case_uuid: str = Query(description="Sumo case uuid"),
+    ensemble_name: str = Query(description="Ensemble name"),
+    realization_num: int = Query(description="Realization number"),
+    seismic_attribute: str = Query(description="Seismic cube attribute"),
+    time_or_interval_str: str = Query(description="Timestamp or timestep"),
+    observed: bool = Query(description="Observed or simulated"),
+    crossline_no: int = Query(description="Crossline number"),
+) -> schemas.SeismicSliceData:
+    """Get a seismic crossline from a seismic cube."""
+    seismic_access = await SeismicAccess.from_case_uuid_async(
+        authenticated_user.get_sumo_access_token(), case_uuid, ensemble_name
+    )
+
+    vds_handle: Optional[VdsHandle] = None
+    try:
+        vds_handle = await seismic_access.get_vds_handle_async(
+            realization=realization_num,
+            seismic_attribute=seismic_attribute,
+            time_or_interval_str=time_or_interval_str,
+            observed=observed,
+        )
+    except ValueError as err:
+        raise HTTPException(status_code=404, detail=str(err)) from err
+
+    if vds_handle is None:
+        raise HTTPException(status_code=404, detail="Vds handle not found")
+
+    vds_access = VdsAccess(sas_token=vds_handle.sas_token, vds_url=vds_handle.vds_url)
+
+    flattened_slice_traces_array, metadata = await vds_access.get_crossline_slice(line_no=crossline_no)
+
+    return converters.to_api_vds_slice_data(
+        flattened_slice_traces_array=flattened_slice_traces_array, metadata=metadata
+    )
+
+
+@router.get("/get_depth_slice/")
+async def get_depth_slice(
+    authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+    case_uuid: str = Query(description="Sumo case uuid"),
+    ensemble_name: str = Query(description="Ensemble name"),
+    realization_num: int = Query(description="Realization number"),
+    seismic_attribute: str = Query(description="Seismic cube attribute"),
+    time_or_interval_str: str = Query(description="Timestamp or timestep"),
+    observed: bool = Query(description="Observed or simulated"),
+    depth: int = Query(description="depth"),
+) -> schemas.SeismicSliceData:
+    """Get a seismic depth slice from a seismic cube."""
+    seismic_access = await SeismicAccess.from_case_uuid_async(
+        authenticated_user.get_sumo_access_token(), case_uuid, ensemble_name
+    )
+
+    vds_handle: Optional[VdsHandle] = None
+    try:
+        vds_handle = await seismic_access.get_vds_handle_async(
+            realization=realization_num,
+            seismic_attribute=seismic_attribute,
+            time_or_interval_str=time_or_interval_str,
+            observed=observed,
+        )
+    except ValueError as err:
+        raise HTTPException(status_code=404, detail=str(err)) from err
+
+    if vds_handle is None:
+        raise HTTPException(status_code=404, detail="Vds handle not found")
+
+    vds_access = VdsAccess(sas_token=vds_handle.sas_token, vds_url=vds_handle.vds_url)
+
+    flattened_slice_traces_array, metadata = await vds_access.get_depth_slice(depth=depth)
+
+    return converters.to_api_vds_slice_data(
+        flattened_slice_traces_array=flattened_slice_traces_array, metadata=metadata
+    )
+
+
 @router.post("/get_seismic_fence/")
 async def post_get_seismic_fence(
     authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
@@ -86,8 +203,8 @@ async def post_get_seismic_fence(
         coordinates=VdsCoordinates(polyline.x_points, polyline.y_points),
         coordinate_system=VdsCoordinateSystem.CDP,
     )
-
     meta: VdsMetadata = await vds_access.get_metadata_async()
+
     if len(meta.axis) != 3:
         raise ValueError(f"Expected 3 axes, got {len(meta.axis)}")
     depth_axis_meta = meta.axis[2]

backend_py/primary/primary/routers/seismic/schemas.py

@@ -3,12 +3,40 @@
 from pydantic import BaseModel
 from webviz_pkg.core_utils.b64 import B64FloatArray
 
+from .._shared.schemas import BoundingBox3d
+
+
+class SeismicCubeSpec(BaseModel):
+    """
+    Specification for a seismic cube.
+    """
+
+    numCols: int
+    numRows: int
+    numLayers: int
+    xOrigin: float
+    yOrigin: float
+    zOrigin: float
+    xInc: float
+    yInc: float
+    zInc: float
+    yFlip: int
+    zFlip: int
+    rotation: float
+
 
 class SeismicCubeMeta(BaseModel):
-    seismic_attribute: str
-    iso_date_or_interval: str
-    is_observation: bool
-    is_depth: bool
+    """
+    Metadata for a seismic cube.
+    """
+
+    seismicAttribute: str
+    unit: str
+    isoDateOrInterval: str
+    isObservation: bool
+    isDepth: bool
+    bbox: BoundingBox3d
+    spec: SeismicCubeSpec
 
 
 class SeismicFencePolyline(BaseModel):
@@ -60,21 +88,16 @@ class SeismicFenceData(BaseModel):
     max_fence_depth: float
 
 
-class SurfaceMeshAndProperty(BaseModel):
-    x_ori: float
-    y_ori: float
-    x_count: int
-    y_count: int
-    x_inc: float
-    y_inc: float
-    x_min: float
-    x_max: float
-    y_min: float
-    y_max: float
-    mesh_value_min: float
-    mesh_value_max: float
-    property_value_min: float
-    property_value_max: float
-    rot_deg: float
-    mesh_data: str
-    property_data: str
+class SeismicSliceData(BaseModel):
+    slice_traces_b64arr: B64FloatArray
+    bbox_utm: List[List[float]]
+    u_min: int
+    u_max: int
+    u_num_samples: int
+    u_unit: str
+    v_min: float
+    v_max: float
+    v_num_samples: int
+    v_unit: str
+    value_min: float
+    value_max: float