DASPy-toolbox 1.0.0__tar.gz → 1.1.1__tar.gz

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/DASPy_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DASPy-toolbox
-Version: 1.0.0
+Version: 1.1.1
 Summary: DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing, which comprises classic seismic data processing techniques and Specialized algorithms for DAS applications.
 Home-page: https://github.com/HMZ-03/DASPy
 Author: Minzhe Hu, Zefeng Li
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-License-File: LICENSE.txt
+License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy>=1.13
 Requires-Dist: matplotlib
@@ -25,8 +25,14 @@ Requires-Dist: tqdm
 
 <img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
 
+# DASPy
 
-## DASPy
+[![Supported Python versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)](https://pypi.org/project/DASPy-toolbox/)
+[![License](https://img.shields.io/pypi/l/daspy-toolbox.svg)](https://opensource.org/license/mit)
+[![PyPI Version](https://img.shields.io/pypi/v/daspy-toolbox.svg)](https://pypi.org/project/DASPy-toolbox/)
+[![DOI](https://img.shields.io/badge/DOI-10.1785/0220240124-blue.svg)](https://doi.org/10.1785/0220240124)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/daspy-toolbox.svg?label=pypi)](https://pypi.org/project/DASPy-toolbox/)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/daspy-toolbox?label=conda)](https://anaconda.org/conda-forge/daspy-toolbox)
 
 DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
 
@@ -34,32 +40,32 @@ The goal of the DASPy project is to lower the bar of DAS data processing. DASPy
 * Classic seismic data processing techniques, including preprocessing, filter, spectrum analysis, and visualization
 * Specialized algorithms for DAS applications, including denoising, waveform decomposition, channel attribute analysis, and strain-velocity conversion. 
 
-DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [the DASPy paper](document/srl-2024124.1.pdf) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
+DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [an example of Jupyter notebook](document/example.ipynb) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
 
 ## Installation
-DASPy is currently running on Linux, Windows and Mac OS.
-DASPy runs on Python 3.9 and up. We recommend you use the latest version of python 3 if possible.
+DASPy runs on Linux, Windows and Mac OS and on Python 3.9 and up.
 
-### Pip (recommanded)
+### Pip
 ```
-pip install git+https://github.com/HMZ-03/DASPy.git
+pip install daspy-toolbox
 ```
 
-If you installed DASPy this way, you can upgrade DASPy with the following command:
+Install the latest version from GitHub:
 
 ```
-pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+pip install git+https://github.com/HMZ-03/DASPy.git
 ```
 
 ### Conda
+
 ```
-conda install -c hmz-03 daspy
+conda install daspy-toolbox
 ```
 
-If an error is reported, please try updating conda:
+or
 
 ```
-conda update -n base -c conda-forge conda
+conda install conda-forge::daspy-toolbox
 ```
 
 ### Manual installation

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/DASPy_toolbox.egg-info/SOURCES.txt

@@ -1,4 +1,4 @@
-LICENSE.txt
+LICENSE
 README.md
 setup.py
 DASPy_toolbox.egg-info/PKG-INFO
@@ -43,6 +43,7 @@ daspy/seismic_detection/gamma/seismic_ops.py
 daspy/seismic_detection/gamma/utils.py
 daspy/structure_imaging/__init__.py
 daspy/structure_imaging/ambient_noise.py
+daspy/structure_imaging/core.py
 daspy/structure_imaging/dispersion.py
 daspy/structure_imaging/fault_zone.py
 daspy/structure_imaging/inversion.py

DASPy-toolbox-1.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 University of Science and Technology of China
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DASPy-toolbox
-Version: 1.0.0
+Version: 1.1.1
 Summary: DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing, which comprises classic seismic data processing techniques and Specialized algorithms for DAS applications.
 Home-page: https://github.com/HMZ-03/DASPy
 Author: Minzhe Hu, Zefeng Li
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-License-File: LICENSE.txt
+License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy>=1.13
 Requires-Dist: matplotlib
@@ -25,8 +25,14 @@ Requires-Dist: tqdm
 
 <img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
 
+# DASPy
 
-## DASPy
+[![Supported Python versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)](https://pypi.org/project/DASPy-toolbox/)
+[![License](https://img.shields.io/pypi/l/daspy-toolbox.svg)](https://opensource.org/license/mit)
+[![PyPI Version](https://img.shields.io/pypi/v/daspy-toolbox.svg)](https://pypi.org/project/DASPy-toolbox/)
+[![DOI](https://img.shields.io/badge/DOI-10.1785/0220240124-blue.svg)](https://doi.org/10.1785/0220240124)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/daspy-toolbox.svg?label=pypi)](https://pypi.org/project/DASPy-toolbox/)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/daspy-toolbox?label=conda)](https://anaconda.org/conda-forge/daspy-toolbox)
 
 DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
 
@@ -34,32 +40,32 @@ The goal of the DASPy project is to lower the bar of DAS data processing. DASPy
 * Classic seismic data processing techniques, including preprocessing, filter, spectrum analysis, and visualization
 * Specialized algorithms for DAS applications, including denoising, waveform decomposition, channel attribute analysis, and strain-velocity conversion. 
 
-DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [the DASPy paper](document/srl-2024124.1.pdf) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
+DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [an example of Jupyter notebook](document/example.ipynb) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
 
 ## Installation
-DASPy is currently running on Linux, Windows and Mac OS.
-DASPy runs on Python 3.9 and up. We recommend you use the latest version of python 3 if possible.
+DASPy runs on Linux, Windows and Mac OS and on Python 3.9 and up.
 
-### Pip (recommanded)
+### Pip
 ```
-pip install git+https://github.com/HMZ-03/DASPy.git
+pip install daspy-toolbox
 ```
 
-If you installed DASPy this way, you can upgrade DASPy with the following command:
+Install the latest version from GitHub:
 
 ```
-pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+pip install git+https://github.com/HMZ-03/DASPy.git
 ```
 
 ### Conda
+
 ```
-conda install -c hmz-03 daspy
+conda install daspy-toolbox
 ```
 
-If an error is reported, please try updating conda:
+or
 
 ```
-conda update -n base -c conda-forge conda
+conda install conda-forge::daspy-toolbox
 ```
 
 ### Manual installation

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/README.md

@@ -1,7 +1,13 @@
 <img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
 
+# DASPy
 
-## DASPy
+[![Supported Python versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)](https://pypi.org/project/DASPy-toolbox/)
+[![License](https://img.shields.io/pypi/l/daspy-toolbox.svg)](https://opensource.org/license/mit)
+[![PyPI Version](https://img.shields.io/pypi/v/daspy-toolbox.svg)](https://pypi.org/project/DASPy-toolbox/)
+[![DOI](https://img.shields.io/badge/DOI-10.1785/0220240124-blue.svg)](https://doi.org/10.1785/0220240124)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/daspy-toolbox.svg?label=pypi)](https://pypi.org/project/DASPy-toolbox/)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/daspy-toolbox?label=conda)](https://anaconda.org/conda-forge/daspy-toolbox)
 
 DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
 
@@ -9,32 +15,32 @@ The goal of the DASPy project is to lower the bar of DAS data processing. DASPy
 * Classic seismic data processing techniques, including preprocessing, filter, spectrum analysis, and visualization
 * Specialized algorithms for DAS applications, including denoising, waveform decomposition, channel attribute analysis, and strain-velocity conversion. 
 
-DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [the DASPy paper](document/srl-2024124.1.pdf) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
+DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [an example of Jupyter notebook](document/example.ipynb) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
 
 ## Installation
-DASPy is currently running on Linux, Windows and Mac OS.
-DASPy runs on Python 3.9 and up. We recommend you use the latest version of python 3 if possible.
+DASPy runs on Linux, Windows and Mac OS and on Python 3.9 and up.
 
-### Pip (recommanded)
+### Pip
 ```
-pip install git+https://github.com/HMZ-03/DASPy.git
+pip install daspy-toolbox
 ```
 
-If you installed DASPy this way, you can upgrade DASPy with the following command:
+Install the latest version from GitHub:
 
 ```
-pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+pip install git+https://github.com/HMZ-03/DASPy.git
 ```
 
 ### Conda
+
 ```
-conda install -c hmz-03 daspy
+conda install daspy-toolbox
 ```
 
-If an error is reported, please try updating conda:
+or
 
 ```
-conda update -n base -c conda-forge conda
+conda install conda-forge::daspy-toolbox
 ```
 
 ### Manual installation

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/daspy/advanced_tools/channel.py

@@ -1,6 +1,6 @@
 # Purpose: Several functions for analysis data quality and geometry of channels
 # Author: Minzhe Hu, Zefeng Li
-# Date: 2024.10.11
+# Date: 2024.11.18
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from copy import deepcopy
@@ -55,8 +55,8 @@ def channel_checking(data, deg=10, thresh=5, continuity=True, adjacent=2,
     """
     Use the energy of each channel to determine which channels are bad.
 
-    :param data: 2-dimensional np.ndarray. Axis 0 is channel number and axis 1 is
-        time series
+    :param data: 2-dimensional np.ndarray. Axis 0 is channel number and axis 1
+        is time series.
     :param deg: int. Degree of the fitting polynomial
     :param thresh: int or float. The MAD multiple of bad channel energy lower
         than good channels.
@@ -72,6 +72,7 @@ def channel_checking(data, deg=10, thresh=5, continuity=True, adjacent=2,
     """
     nch = len(data)
     energy = np.log10(np.sum(data**2, axis=1))
+    energy[energy == -np.inf] = -308
 
     # Remove abnormal value by robust polynomial fitting.
     fitted_energy, weights = robust_polyfit(energy, deg, thresh)
@@ -115,9 +116,10 @@ def _channel_location(track_pt):
     idx_kp = np.where(tn >= 0)[0]
 
     interp_ch = []
-    chn = np.floor(tn[idx_kp[0]])
-    if abs(chn - tn[idx_kp[0]]) < 1e-6:
-        interp_ch.append([*track[idx_kp[0]], chn])
+    chn = np.floor(tn[idx_kp[0]]).astype(int)
+    interp_ch.append([*track[idx_kp[0]], chn])
+    if abs(chn - tn[idx_kp[0]]) > 1e-6:
+        chn += 1
 
     seg_interval = []
     for i in range(1, len(idx_kp)):
@@ -130,12 +132,17 @@ def _channel_location(track_pt):
         l_res = 0  # remaining fiber length before counting the next segment
         # consider if the given channelnumber is not an integer
         chn_res = tn[istart] - int(tn[istart])
+        if d_interp == 0:
+            while chn < int(tn[iend]):
+                chn += 1
+                interp_ch.append([*track[istart, :], chn])
+            continue
         for j in range(istart, iend):
             l_start = l_track[j] + l_res
 
             # if tp segment length is large for more than one interval, get the
             # channel loc
-            if l_start >= d_interp * (1 - chn_res):
+            if l_start >= d_interp * (1 - chn_res - 1e-6):
                 # floor int, num of channel available
                 n_chn_tp = int(l_start / d_interp + chn_res)
                 l_new = (np.arange(n_chn_tp) + 1 - chn_res) * d_interp - \
@@ -167,6 +174,10 @@ def _channel_location(track_pt):
             elif l_start < d_interp:
                 l_res = l_start
 
+    if abs(tn[iend] - int(tn[iend])) > 1e-6:
+        chn += 1
+        interp_ch.append([*track[iend, :], chn])
+
     return np.array(seg_interval), np.array(interp_ch)
 
 
@@ -352,3 +363,136 @@ def turning_points(data, data_type='coordinate', thresh=5, depth_info=False,
 
     else:
         raise ValueError('Data_type should be \'coordinate\' or \'waveform\'.')
+
+
+def _equally_spacing(channels, dist, dx):
+    if len(channels) > 20:
+        return _equally_spacing_2(channels, dist, dx)
+    else:
+        return _equally_spacing_1(channels, dist, dx)
+
+
+def _equally_spacing_1(channels, dist, dx):
+    nch = len(channels)
+    residual = np.inf
+    for i in range(2 ** (nch - 2)):
+        state = bin(i)[2:].rjust(nch - 2, '0')
+        dist_new = [dist[0]]
+        channels_new = [channels[0]]
+        idx = 0
+        for j, s in enumerate(state):
+            if s == '0':
+                dist_new[idx] += dist[j+1]
+            else:
+                dist_new.append(dist[j+1])
+                channels_new.append(channels[j+1])
+                idx += 1
+        res = sum([abs(d - dx) for d in dist_new])    
+        if res < residual:
+            residual = res
+            dist_equal = dist_new
+            channels_equal = channels_new
+    channels_equal.append(channels[-1])
+    return channels_equal, dist_equal
+
+
+def _equally_spacing_2(channels, dist, dx):
+    channels_equal = [channels[0]]
+    dist_equal = []
+    i = 0
+    while i < len(dist):
+        d = dist[i]
+        if d < dx and i < len(dist) - 1:
+            d1 = d + dist[i + 1]
+            while d1 < dx and i < len(dist) - 2:
+                d = d1
+                i += 1
+                d1 += dist[i + 1]
+            if abs(d - dx) <= abs(d1 - dx):
+                channels_equal.append(channels[i + 1])
+                dist_equal.append(d)
+            else:
+                i += 1
+                channels_equal.append(channels[i + 1])
+                dist_equal.append(d1)
+        else:
+            channels_equal.append(channels[i + 1])
+            dist_equal.append(d)
+        i += 1
+
+    return channels_equal, dist_equal
+
+
+def equally_spaced_channels(geometry, dx, depth_info=False, verbose=False):
+    """
+    Find equally spaced channel numbers based on known DAS latitude and
+    longitude.
+
+    :param geometry: numpy.ndarray. DAS geometry used to filter equally spaced
+        channels. It needs to consist of longitude, latitude (and depth) or
+        channel number, longitude, latitude (and depth).
+    :param dx: Channel interval.
+    :param depth_info: bool. Whether depth (in meters) is included in the
+        geometry and needed to be used.
+    :param verbose: bool. If True, return channel numbers for equally spaced
+        channels and channel intervals.
+    :return: Channel numbers for equally spaced channels if verbose is False.
+    """
+    nch = len(geometry)
+    if geometry.shape[1] == 2 + int(depth_info):
+        channels = np.arange(nch).astype(int)
+    else:
+        geometry = geometry[geometry[:, 0].argsort()]
+        channels = geometry[:, 0].astype(int)
+        geometry = geometry[:, 1:]
+
+    dist = np.zeros(nch - 1)
+    for i in range(nch - 1):
+        lon0, lat0 = geometry[i, :2]
+        lon1, lat1 = geometry[i+1, :2]
+        d = Geodesic.WGS84.Inverse(lat0, lon0, lat1, lon1)['s12']
+        if depth_info:
+            dist[i] = np.sqrt(d**2 + (geometry[i+1, 2] - geometry[i, 2]) ** 2)
+        else:
+            dist[i] = d
+
+    channels_equal = [channels[0]]
+    dist_equal = []
+    channels_seg = []
+    dist_seg = []
+    flag = False
+    for i in range(1, nch-1):
+        if dist[i-1] + dist[i] <= dx * 1.5:
+            channels_seg.append(channels[i-1])
+            dist_seg.append(dist[i-1])
+        else:
+            if len(channels_seg):
+                channels_seg.extend(channels[i-1:i+1])
+                dist_seg.append(dist[i-1])
+                channels_seg, dist_seg = _equally_spacing(channels_seg,
+                                                          dist_seg, dx)
+                dist_equal.extend(dist_seg)
+                channels_equal.extend(channels_seg[1:])
+                channels_seg = []
+                dist_seg = []
+                flag = False
+            else:
+                if flag:
+                    channels_equal.append(channels[i-1])
+                    dist_equal.append(dist[i-1])
+                else:
+                    flag = True
+
+    if len(channels_seg):
+        channels_seg.extend(channels[i:i+2])
+        dist_seg.append(dist[i])
+        channels_seg, dist_seg = _equally_spacing(channels_seg, dist_seg, dx)
+        dist_equal.extend(dist_seg)
+        channels_equal.extend(channels_seg[1:])
+    else:
+        channels_equal.extend(channels[-2:])
+        dist_equal.extend(dist[-2:])
+
+    if verbose:
+        return channels_equal, dist_equal
+    return channels_equal

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/daspy/advanced_tools/decomposition.py

@@ -59,7 +59,7 @@ def fk_fan_mask(f, k, fmin=None, fmax=None, kmin=None, kmax=None, vmin=None,
     return mask
 
 
-def fk_filter(data, dx, fs, taper=(0.02, 0.05), pad='default', mode='decompose', 
+def fk_filter(data, dx, fs, taper=(0.02, 0.05), pad='default', mode='decompose',
               fmin=None, fmax=None, kmin=None, kmax=None, vmin=None, vmax=None,
               edge=0.1, flag=None, verbose=False):
     """

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/daspy/advanced_tools/denoising.py

@@ -172,7 +172,7 @@ def curvelet_denoising(data, choice=0, pad=0.3, noise=None, noise_perc=95,
                        flag=0, dx=None, fs=None, mode='remove',
                        scale_begin=3, nbscales=None, nbangles=16, finest=2):
     """
-    Use curevelet transform to filter stochastic or/and cooherent noise.
+    Use curevelet transform to filter stochastic or/and coherent noise.
     Modified from
     https://github.com/atterholt/curvelet-denoising/blob/main/CurveletDenoising.m
     {Atterholt et al., 2022 , Geophys. J. Int.}

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/daspy/basic_tools/preprocessing.py

@@ -23,7 +23,7 @@ def phase2strain(data, lam, e, n, gl):
     return data * (lam * 1e-9) / (e * 4 * np.pi * n * gl)
 
 
-def normalization(data, method='z-score'):
+def normalization(data, method='z-score', **kwargs):
     """
     Normalize for each individual channel using Z-score method.
 
@@ -46,6 +46,9 @@ def normalization(data, method='z-score'):
         mean = np.mean(data, axis=1, keepdims=True)
         std = np.std(data, axis=1, keepdims=True)
         std[std == 0] = std[std > 0].min()
+        if 'p' in kwargs.keys():
+            thresh = np.percentile(std, kwargs['p'])
+            std[std > thresh] = thresh
         return (data - mean) / std
 
     if method == 'one-bit':
@@ -72,7 +75,7 @@ def detrending(data):
     return detrend(data, type='linear')
 
 
-def stacking(data: np.ndarray, N: int, step: int = None, average: bool = False):
+def stacking(data: np.ndarray, N: int, step: int = None, average: bool = True):
     """
     Stack several channels to increase the signal-noise ratio(SNR).
 
@@ -98,7 +101,7 @@ def stacking(data: np.ndarray, N: int, step: int = None, average: bool = False):
     return data_stacked
 
 
-def cosine_taper(data, p=0.1):
+def cosine_taper(data, p=0.1, side='both'):
     """
     Taper using Tukey window.
 
@@ -107,18 +110,23 @@ def cosine_taper(data, p=0.1):
         of Tukey taper for corresponding dimension (ranging from 0 to 1).
         Default is 0.1 which tapers 5% from the beginning and 5% from the end.
         If only one float is given, it only do for time dimension.
+    :param side: str. 'both', 'left', or 'right'.
     :return: Tapered data.
     """
-    if len(data.shape) == 1:
-        return data * tukey(len(data), p)
+    if data.ndim == 1:
+        data = data.reshape(1, -1)
     nch, nt = data.shape
-    win = np.ones_like(data)
     if not isinstance(p, (tuple, list, np.ndarray)):
-        p = (0, p)
-
-    win *= np.tile(tukey(nch, p[0]), (nt, 1)).T
-    win *= np.tile(tukey(nt, p[1]), (nch, 1))
-    return data * win
+        win = tukey(nt, p)
+        if side == 'left':
+            win[round(nch/2):] = 1
+        elif side == 'right':
+            win[:round(len(win)/2)] = 1
+        return data * np.tile(win, (nch, 1))
+    else:
+        if p[0] > 0:
+            data = data * np.tile(tukey(nch, p[0]), (nt, 1)).T
+        return cosine_taper(data, p[1], side=side)
 
 
 def downsampling(data, xint=None, tint=None, stack=True, lowpass_filter=True):

{DASPy-toolbox-1.0.0 → DASPy-toolbox-1.1.1}/daspy/basic_tools/visualization.py

@@ -1,19 +1,19 @@
 # Purpose: Plot data
 # Author: Minzhe Hu
-# Date: 2024.10.17
+# Date: 2024.11.8
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 import matplotlib.pyplot as plt
-from copy import deepcopy
 from collections.abc import Sequence
 
 
 def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=150,
          title=None, transpose=False, t0=0, x0=0, pick=None, f=None, k=None,
-         t=None, c=None, cmap=None, vmin=None, vmax=None, xmode='distance',
-         tmode='time', xlim=None, ylim=None, xlog=False, ylog=False, xinv=False,
-         yinv=False, xlabel=True, ylabel=True, xticklabels=True,
-         yticklabels=True, colorbar=True, colorbar_label=None, savefig=None):
+         t=None, c=None, cmap=None, vmin=None, vmax=None, dB=False,
+         xmode='distance', tmode='time', xlim=None, ylim=None, xlog=False,
+         ylog=False, xinv=False, yinv=False, xlabel=True, ylabel=True,
+         xticklabels=True, yticklabels=True, colorbar=True, colorbar_label=None,
+         savefig=None):
     """
     Plot several types of 2-D seismological data.
 
@@ -38,6 +38,7 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=150,
     :param cmap: str or Colormap. The Colormap instance or registered colormap
         name used to map scalar data to colors.
     :param vmin, vmax: Define the data range that the colormap covers.
+    :param dB: bool. Transfer data unit to dB and take 1 as the reference value.
     :param xmode: str. 'distance' or 'channel'.
     :param tmode: str. 'time' or 'sampling'.
     :param xlim, ylim: Set the x-axis and y-axis view limits.
@@ -93,6 +94,8 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=150,
     elif obj in ['spectrum', 'spectrogram', 'fk', 'dispersion']:
         if isinstance(data[0,0], (complex, np.complex64)):
             data = abs(data)
+        if dB:
+            data = 20 * np.log10(data)
         cmap = 'jet' if cmap is None else cmap
         vmax = np.percentile(abs(data), 80) if vmax is None else vmax
         vmin = np.percentile(abs(data), 20) if vmin is None else vmin
@@ -120,7 +123,7 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=150,
             data = data.T
             origin = 'lower'
             xlabel_default = 'Frequency (Hz)'
-            ylabel_default = 'Phase Velocity (m/s)'
+            ylabel_default = 'Velocity (m/s)'
             extent = [min(f), max(f), min(c), max(c)]
 
     if transpose: