Added saving in SEGY2d3d and utils for 3d prediction

Author: Ruslan

__init__.py

@@ -1,6 +1,8 @@
 import streamlit as st
+import numpy as np
 from PIL import Image
-from utils import img_to_html_custom, img_to_bytes
+from utils import img_to_html_custom, img_to_bytes, save_to_numpy, save_to_segy_2d, save_to_segy_3d
+from data_classes import Numpy3D
 import os
 
 
@@ -18,7 +20,6 @@ def footer():
 
 def sidebar():
     with st.sidebar:
-        col1, col2 = st.columns(2)
         st.markdown("""
         - **Seismic Type:** {}
         - **Seismic Name:** {}
@@ -33,3 +34,60 @@ def sidebar():
         [email protected]
         """)
 
+def crop_and_load_volume(data, converted_to_numpy3d, cropped_info):
+    with st.form("Cropping"):
+        col1, col2, col3 = st.columns(3)
+        inlines_indx = col1.slider( 'Select a range for Inlines',
+        0, data.get_n_ilines()-1, (0, data.get_n_ilines())) 
+
+        xlines_indx = col2.slider( 'Select a range for Xlines',
+        0, data.get_n_xlines()-1, (0, data.get_n_xlines())) 
+        
+        zslice_indx = col3.slider( 'Select a range for Zslice',
+        0, data.get_n_zslices()-1, (0, data.get_n_zslices())) 
+        
+        # Every form must have a submit button.
+        submitted = st.form_submit_button("Submit")
+        if submitted:
+            cropped_info = np.array([[inlines_indx[0], inlines_indx[1]], \
+                [xlines_indx[0], xlines_indx[1]], \
+                    [zslice_indx[0], zslice_indx[1]]])
+            np_data = data.cropped_numpy(inlines_indx[0], inlines_indx[1], \
+            xlines_indx[0], xlines_indx[1],\
+                zslice_indx[0], zslice_indx[1])
+            converted_to_numpy3d = Numpy3D(np_data)
+            col1, col2, col3 = st.columns(3)
+            col1.info(f"Number of Inlines [{inlines_indx[1]-inlines_indx[0]}]")
+            col2.info(f"Number of Xlines [{xlines_indx[1] - xlines_indx[0]}]")
+            col3.info(f"Time [{zslice_indx[1]-zslice_indx[0]}]")
+            st.success('Volume is loaded')
+    return converted_to_numpy3d, cropped_info
+
+def save_data_form(session_state, seismic, numpy_data, status):
+    with st.form("save_data"):
+        col1, col2, col3 = st.columns(3)
+        path = col1.text_input("Path to Folder")
+        file_name = col2.text_input("File Name")
+        file_format = col3.radio( "What format? ", ('SEGY', 'NUMPY_SUBSET'))
+        submitted = st.form_submit_button("Save")
+        if submitted:
+            if file_format == "SEGY":
+                if seismic.get_str_format() == "SEGY":
+                    if seismic.get_str_dim() == "2D":
+                        save_to_segy_2d(seismic, path+file_name, numpy_data, session_state)
+                    else:
+                        save_to_segy_3d(seismic, path+file_name, numpy_data, session_state)
+                    status = "Saving SEGY complete"
+                else:
+                    status = "Error: you can not save a SEGY file since the initial seismic was not SEGY."
+            else:
+                save_to_numpy(path+file_name, numpy_data)
+                status = "Saving NUMPY complete"
+                # option = st.radio( "Option", ('Save subset', 'Save in original dimensions - It will create the volume in RAM. Are you sure?'))
+                # if st.form_submit_button("Save "):
+                #     if option == 'Save subset':
+                #         status = None
+                #         save_to_numpy(path+file_name, numpy_data)
+                #     else:
+                #         status = "Save in original dimensions"
+    return status

custom_blocks.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from unittest import result
 import segyio
 import numpy as np
 import random
@@ -47,19 +48,21 @@ def get_sample_rate(self):
 
     @abstractmethod
     def get_vm(self):
-        return self.vm
-
-
+        pass
 
 class SegyIO3D(SeismicData):
 
     def __init__(self, file_name, iline_byte=189, xline_byte=193):
+        super().__init__()
         self._segyfile = segyio.open(file_name, iline=int(iline_byte), xline=int(xline_byte))
 
         # get statistics for visualization
         n_slices = 10
         seis = [self.get_iline(random.randint(0, self.get_n_ilines()-1)) for i in range(n_slices)]
         self.vm = np.percentile(seis, 95)
+        self.file_name = file_name
+        self.iline_byte = iline_byte
+        self.xline_byte = xline_byte
 
     def __del__(self):
         self._segyfile.close()
@@ -93,9 +96,43 @@ def get_sample_rate(self):
     def get_vm(self):
         return self.vm
 
+    def get_file_name(self):
+        return self.file_name
+
+    def cropped_numpy(self, min_il, max_il, min_xl, max_xl, min_z, max_z):
+        """ Reads cropped seismic and returns numpy array
+
+        Args:
+            min_il (_type_): min inline
+            max_il (_type_): max inline
+            min_xl (_type_): min crossline
+            max_xl (_type_): max crossline
+            min_z (_type_): min timeslice
+            max_z (_type_): max timeslice
+        """
+        assert max_il>min_il, f"max_il must be greater than {min_il}, got: {max_il}"
+        assert max_xl>min_xl, f"max_il must be greater than {min_xl}, got: {max_xl}"
+        assert max_z>min_z,   f"max_il must be greater than {min_z}, got: {max_z}"
+
+        return np.array([self.get_iline(i)[min_xl:max_xl, min_z:max_z] for i in range(min_il, max_il)])
+
+    def get_xline_byte(self):
+        return self.xline_byte
+
+    def get_iline_byte(self):
+        return self.iline_byte
+
+    def get_str_format(self):
+        return "SEGY"
+
+    def get_str_dim(self):
+        return "2D"
+
+
 class SegyIO2D(SeismicData):
 
     def __init__(self, file_name):
+        super().__init__()
         seismic_type = "2D"
         try: 
             with segyio.open(file_name, strict=True) as segyfile:
@@ -108,10 +145,15 @@ def __init__(self, file_name):
                 self._data = np.stack(list((_.copy() for _ in segyfile.trace[:])))
                 self._dt = segyio.tools.dt(segyfile)
                 self.vm = np.percentile(self._data, 95)
+                self.file_name = file_name
+
 
     def __del__(self):
         pass
 
+    def get_file_name(self):
+        return self.file_name
+
     def get_iline(self):
         return self._data.T
 
@@ -124,11 +166,11 @@ def get_zslice(self,):
 
     # get total number of ilines
     def get_n_ilines(self):
-        return self._data.shape[0]
+        pass
 
     # get total number of xlines
     def get_n_xlines(self):
-        pass
+        return self._data.shape[0]
 
     # get total number of zslices
     def get_n_zslices(self):
@@ -144,10 +186,24 @@ def make_axis_devisable_by(self, factor):
         xlim = self._data.shape[0]//int(factor)*int(factor)
         ylim = self._data.shape[1]//int(factor)*int(factor)
         self._data = self._data[:xlim, :ylim]
+    
+    def get_xline_byte(self):
+        return self.xline_byte
+
+    def get_iline_byte(self):
+        return self.iline_byte
+
+    def get_str_format(self):
+        return "SEGY"
+
+    def get_str_dim(self):
+        return "2D"
+
 
 class Numpy2D(SeismicData):
 
     def __init__(self, file_name):
+        super().__init__()
         self._data = np.load(file_name)
 
         # get statistics for visualization
@@ -167,11 +223,11 @@ def get_zslice(self):
         pass
 
     def get_n_ilines(self):
-        return self._data.shape[0]
+        pass
 
     # get total number of xlines
     def get_n_xlines(self):
-        pass
+        return self._data.shape[0]
 
     def get_n_zslices(self):
         return self._data.shape[1]
@@ -185,4 +241,67 @@ def get_vm(self):
     def make_axis_devisable_by(self, factor):
         xlim = self._data.shape[0]//int(factor)*int(factor)
         ylim = self._data.shape[1]//int(factor)*int(factor)
-        self._data = self._data[:xlim, :ylim]
+        self._data = self._data[:xlim, :ylim]
+
+    def get_str_format(self):
+        return "NUMPY"
+
+    def get_str_dim(self):
+        return "2D"
+
+class Numpy3D(SeismicData):
+
+    def __init__(self, data):
+        super().__init__()
+        if isinstance(data, str):
+            self._data = np.load(data)
+        elif isinstance(data, np.ndarray):
+            self._data = data
+
+        # get statistics for visualization
+        if self._data is not None:
+            n_slices = 10
+            seis = [self.get_iline(random.randint(0, self.get_n_ilines()-1)) for i in range(n_slices)]
+            self.vm = np.percentile(seis, 95)
+
+    def __del__(self):
+        pass
+
+    def get_iline(self, indx):
+        return self._data[indx,:,:]
+
+    def get_xline(self, indx):
+        return self._data[:,indx,:]
+
+    def get_zslice(self, indx):
+        return self._data[:,:,indx]
+
+    def get_n_ilines(self):
+        return self._data.shape[0]
+
+    # get total number of xlines
+    def get_n_xlines(self):
+        return self._data.shape[1]
+
+    def get_n_zslices(self):
+        return self._data.shape[2]
+
+    def get_sample_rate(self):
+        return 1000
+
+    def get_vm(self):
+        return self.vm
+
+    def get_cube(self):
+        return self._data
+
+    def make_axis_devisable_by(self, factor):
+        xlim = self._data.shape[0]//int(factor)*int(factor)
+        ylim = self._data.shape[1]//int(factor)*int(factor)
+        self._data = self._data[:xlim, :ylim, :]
+
+    def get_str_format(self):
+        return "NUMPY"
+    
+    def get_str_dim(self):
+        return "3D"