DASPy-toolbox 1.0.0__tar.gz

DASPy-toolbox-1.0.0/DASPy_toolbox.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.1
+Name: DASPy-toolbox
+Version: 1.0.0
+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
+Author-email: hmz2018@mail.ustc.edu.cn
+Maintainer: Minzhe Hu
+Maintainer-email: hmz2018@mail.ustc.edu.cn
+License: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.13
+Requires-Dist: matplotlib
+Requires-Dist: geographiclib
+Requires-Dist: pyproj
+Requires-Dist: h5py
+Requires-Dist: segyio
+Requires-Dist: nptdms
+Requires-Dist: tqdm
+
+<img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
+
+
+## DASPy
+
+DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
+
+The goal of the DASPy project is to lower the bar of DAS data processing. DASPy includes:
+* 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>.
+
+## 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.
+
+### Pip (recommanded)
+```
+pip install git+https://github.com/HMZ-03/DASPy.git
+```
+
+If you installed DASPy this way, you can upgrade DASPy with the following command:
+
+```
+pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+```
+
+### Conda
+```
+conda install -c hmz-03 daspy
+```
+
+If an error is reported, please try updating conda:
+
+```
+conda update -n base -c conda-forge conda
+```
+
+### Manual installation
+1. Install dependent packages: numpy, scipy >=1.13, matplotlib, geographiclib, pyproj, h5py, segyio, nptdms, tqdm
+
+2. Add DASPy into your Python path.
+
+## Getting started
+```
+from daspy import read
+sec = read()  # load example waveform
+sec.bandpass(1, 15)
+sec.plot()
+```
+<img src="./website/waveform.png" height="500" />
+
+### Contributing
+
+Please see details on how to contribute to the project [here](CONTRIBUTING.md) and [here](CodingStyleGuide.md).
+
+### Reference
+
+  * Minzhe Hu and Zefeng Li (2024), [DASPy: A Python Toolbox for DAS Seismology](https://pubs.geoscienceworld.org/ssa/srl/article/95/5/3055/645865/DASPy-A-Python-Toolbox-for-DAS-Seismology), *Seismological Research Letters*, 95(5), 3055–3066, doi: `https://doi.org/10.1785/0220240124`.

DASPy-toolbox-1.0.0/DASPy_toolbox.egg-info/SOURCES.txt

@@ -0,0 +1,52 @@
+LICENSE.txt
+README.md
+setup.py
+DASPy_toolbox.egg-info/PKG-INFO
+DASPy_toolbox.egg-info/SOURCES.txt
+DASPy_toolbox.egg-info/dependency_links.txt
+DASPy_toolbox.egg-info/entry_points.txt
+DASPy_toolbox.egg-info/requires.txt
+DASPy_toolbox.egg-info/top_level.txt
+daspy/__init__.py
+daspy/advanced_tools/__init__.py
+daspy/advanced_tools/channel.py
+daspy/advanced_tools/decomposition.py
+daspy/advanced_tools/denoising.py
+daspy/advanced_tools/fdct.py
+daspy/advanced_tools/strain2vel.py
+daspy/basic_tools/__init__.py
+daspy/basic_tools/filter.py
+daspy/basic_tools/freqattributes.py
+daspy/basic_tools/preprocessing.py
+daspy/basic_tools/visualization.py
+daspy/core/__init__.py
+daspy/core/collection.py
+daspy/core/dasdatetime.py
+daspy/core/example.pkl
+daspy/core/make_example.py
+daspy/core/read.py
+daspy/core/section.py
+daspy/core/write.py
+daspy/seismic_detection/__init__.py
+daspy/seismic_detection/calc_travel_time.py
+daspy/seismic_detection/core.py
+daspy/seismic_detection/detection.py
+daspy/seismic_detection/location.py
+daspy/seismic_detection/magnitude.py
+daspy/seismic_detection/phase_picking.py
+daspy/seismic_detection/gamma/__init__.py
+daspy/seismic_detection/gamma/_base.py
+daspy/seismic_detection/gamma/_bayesian_mixture.py
+daspy/seismic_detection/gamma/_gaussian_mixture.py
+daspy/seismic_detection/gamma/app.py
+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/dispersion.py
+daspy/structure_imaging/fault_zone.py
+daspy/structure_imaging/inversion.py
+daspy/traffic_monitoring/JamDetection.py
+daspy/traffic_monitoring/SpeedMeasurement.py
+daspy/traffic_monitoring/VehicleDetection.py
+daspy/traffic_monitoring/__init__.py

DASPy-toolbox-1.0.0/DASPy_toolbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

DASPy-toolbox-1.0.0/DASPy_toolbox.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+daspy = daspy.main:main

DASPy-toolbox-1.0.0/DASPy_toolbox.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy
+scipy>=1.13
+matplotlib
+geographiclib
+pyproj
+h5py
+segyio
+nptdms
+tqdm

DASPy-toolbox-1.0.0/DASPy_toolbox.egg-info/top_level.txt

@@ -0,0 +1 @@
+daspy

DASPy-toolbox-1.0.0/LICENSE.txt

@@ -0,0 +1 @@
+daspy/LICENSE.txt

DASPy-toolbox-1.0.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.1
+Name: DASPy-toolbox
+Version: 1.0.0
+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
+Author-email: hmz2018@mail.ustc.edu.cn
+Maintainer: Minzhe Hu
+Maintainer-email: hmz2018@mail.ustc.edu.cn
+License: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.13
+Requires-Dist: matplotlib
+Requires-Dist: geographiclib
+Requires-Dist: pyproj
+Requires-Dist: h5py
+Requires-Dist: segyio
+Requires-Dist: nptdms
+Requires-Dist: tqdm
+
+<img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
+
+
+## DASPy
+
+DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
+
+The goal of the DASPy project is to lower the bar of DAS data processing. DASPy includes:
+* 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>.
+
+## 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.
+
+### Pip (recommanded)
+```
+pip install git+https://github.com/HMZ-03/DASPy.git
+```
+
+If you installed DASPy this way, you can upgrade DASPy with the following command:
+
+```
+pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+```
+
+### Conda
+```
+conda install -c hmz-03 daspy
+```
+
+If an error is reported, please try updating conda:
+
+```
+conda update -n base -c conda-forge conda
+```
+
+### Manual installation
+1. Install dependent packages: numpy, scipy >=1.13, matplotlib, geographiclib, pyproj, h5py, segyio, nptdms, tqdm
+
+2. Add DASPy into your Python path.
+
+## Getting started
+```
+from daspy import read
+sec = read()  # load example waveform
+sec.bandpass(1, 15)
+sec.plot()
+```
+<img src="./website/waveform.png" height="500" />
+
+### Contributing
+
+Please see details on how to contribute to the project [here](CONTRIBUTING.md) and [here](CodingStyleGuide.md).
+
+### Reference
+
+  * Minzhe Hu and Zefeng Li (2024), [DASPy: A Python Toolbox for DAS Seismology](https://pubs.geoscienceworld.org/ssa/srl/article/95/5/3055/645865/DASPy-A-Python-Toolbox-for-DAS-Seismology), *Seismological Research Letters*, 95(5), 3055–3066, doi: `https://doi.org/10.1785/0220240124`.

DASPy-toolbox-1.0.0/README.md

@@ -0,0 +1,60 @@
+<img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
+
+
+## DASPy
+
+DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
+
+The goal of the DASPy project is to lower the bar of DAS data processing. DASPy includes:
+* 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>.
+
+## 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.
+
+### Pip (recommanded)
+```
+pip install git+https://github.com/HMZ-03/DASPy.git
+```
+
+If you installed DASPy this way, you can upgrade DASPy with the following command:
+
+```
+pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+```
+
+### Conda
+```
+conda install -c hmz-03 daspy
+```
+
+If an error is reported, please try updating conda:
+
+```
+conda update -n base -c conda-forge conda
+```
+
+### Manual installation
+1. Install dependent packages: numpy, scipy >=1.13, matplotlib, geographiclib, pyproj, h5py, segyio, nptdms, tqdm
+
+2. Add DASPy into your Python path.
+
+## Getting started
+```
+from daspy import read
+sec = read()  # load example waveform
+sec.bandpass(1, 15)
+sec.plot()
+```
+<img src="./website/waveform.png" height="500" />
+
+### Contributing
+
+Please see details on how to contribute to the project [here](CONTRIBUTING.md) and [here](CodingStyleGuide.md).
+
+### Reference
+
+  * Minzhe Hu and Zefeng Li (2024), [DASPy: A Python Toolbox for DAS Seismology](https://pubs.geoscienceworld.org/ssa/srl/article/95/5/3055/645865/DASPy-A-Python-Toolbox-for-DAS-Seismology), *Seismological Research Letters*, 95(5), 3055–3066, doi: `https://doi.org/10.1785/0220240124`.

DASPy-toolbox-1.0.0/daspy/__init__.py

@@ -0,0 +1,4 @@
+from daspy.core.section import Section
+from daspy.core.collection import Collection
+from daspy.core.read import read
+from daspy.core.dasdatetime import DASDateTime, local_tz, utc

DASPy-toolbox-1.0.0/daspy/advanced_tools/channel.py

@@ -0,0 +1,354 @@
+# Purpose: Several functions for analysis data quality and geometry of channels
+# Author: Minzhe Hu, Zefeng Li
+# Date: 2024.10.11
+# Email: hmz2018@mail.ustc.edu.cn
+import numpy as np
+from copy import deepcopy
+from geographiclib.geodesic import Geodesic
+from pyproj import Proj
+
+
+def robust_polyfit(data, deg, thresh):
+    """
+    Fit a curve with a robust weighted polynomial.
+
+    :param data: 1-dimensional array.
+    :param deg: int. Degree of the fitting polynomial
+    :param thresh: int or float. Defined MAD multiple of outliers.
+    :return: Fitting data
+    """
+    nch = len(data)
+    channels = np.arange(nch)
+    p_coef = np.polyfit(channels, data, deg)
+    p_fit = np.poly1d(p_coef)
+    old_data = p_fit(channels)
+    mse = 1
+
+    # robust fitting until the fitting curve changes < 0.1% at every point.
+    while mse > 0.001:
+        rsl = abs(data - old_data)
+        mad = np.median(rsl)
+        weights = np.zeros(nch)
+        weights[rsl < thresh * mad] = 1
+        p_coef = np.polyfit(channels, data, deg, w=weights)
+        p_fit = np.poly1d(p_coef)
+        new_data = p_fit(channels)
+        mse = np.nanmax(np.abs((new_data - old_data) / old_data))
+        old_data = new_data
+
+    return new_data, weights
+
+
+def _continuity_checking(lst1, lst2, adjacent=2, toleration=2):
+    lst1_raw = deepcopy(lst1)
+    for chn in lst1_raw:
+        discont = [a for a in lst2 if abs(a - chn) <= adjacent]
+        if len(discont) >= adjacent * 2 + 1 - toleration:
+            lst1.remove(chn)
+            lst2.append(chn)
+
+    return lst1, lst2
+
+
+def channel_checking(data, deg=10, thresh=5, continuity=True, adjacent=2,
+                     toleration=2, mode='low', verbose=False):
+    """
+    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 deg: int. Degree of the fitting polynomial
+    :param thresh: int or float. The MAD multiple of bad channel energy lower
+        than good channels.
+    :param continuity: bool. Perform continuity checks on bad channels and good
+        channels.
+    :param adjacent: int. The number of nearby channels for continuity checks.
+    :param toleration: int. The number of discontinuous channel allowed in each
+        channel (including itself) in the continuity check.
+    :param mode: str. 'low' means bad channels have low amplitude, 'high' means
+        bad channels have high amplitude, and 'both' means bad channels are
+        likely to have low or high amplitude.
+    :return: Good channels and bad channels.
+    """
+    nch = len(data)
+    energy = np.log10(np.sum(data**2, axis=1))
+
+    # Remove abnormal value by robust polynomial fitting.
+    fitted_energy, weights = robust_polyfit(energy, deg, thresh)
+    deviation = energy - fitted_energy
+
+    # Iterate eliminates outliers.
+    mad = np.median(abs(deviation[weights > 0]))
+    if mode == 'low':
+        bad_chn = np.argwhere(deviation < -thresh * mad).ravel().tolist()
+    elif mode == 'high':
+        bad_chn = np.argwhere(deviation > thresh * mad).ravel().tolist()
+    elif mode == 'high':
+        bad_chn = np.argwhere(deviation < -thresh * mad).ravel().tolist() + \
+                np.argwhere(deviation > thresh * mad).ravel().tolist()
+    good_chn = list(set(range(nch)) - set(bad_chn))
+
+    if continuity:
+        # Discontinuous normal value are part of bad channels.
+        good_chn, bad_chn = _continuity_checking(good_chn, bad_chn,
+                                                 adjacent=adjacent,
+                                                 toleration=toleration)
+
+        # Discontinuous outliers are usually not bad channels.
+        bad_chn, good_chn = _continuity_checking(bad_chn, good_chn,
+                                                 adjacent=adjacent,
+                                                 toleration=toleration)
+
+    bad_chn = np.sort(np.array(bad_chn))
+    good_chn = np.sort(np.array(good_chn))
+    if verbose:
+        return good_chn, bad_chn, energy, fitted_energy - thresh * mad
+
+    return good_chn, bad_chn
+
+
+def _channel_location(track_pt):
+    track, tn = track_pt[:, :-1], track_pt[:, -1]
+    dim = track.shape[1]
+    l_track = np.sqrt(np.sum(np.diff(track, axis=0) ** 2, axis=1))
+    l_track_cum = np.hstack(([0], np.cumsum(l_track)))
+    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])
+
+    seg_interval = []
+    for i in range(1, len(idx_kp)):
+        # calculate actual interval between known-channel points
+        istart, iend = idx_kp[i - 1], idx_kp[i]
+        n_chn_kp = tn[iend] - tn[istart]
+        d_interp = (l_track_cum[iend] - l_track_cum[istart]) / n_chn_kp
+        seg_interval.append([tn[istart], tn[iend], d_interp])
+
+        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])
+        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):
+                # 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 - \
+                    l_res  # channel distance from segment start
+
+                # interpolate the channel loc
+                t_new = np.zeros((len(l_new), dim))
+                for d in range(dim):
+                    t_new[:, d] = np.interp(l_new, [0, l_track[j]],
+                                            [track[j, d], track[j + 1, d]])
+
+                # remaining length to add to next segment
+                l_res = l_start - n_chn_tp * d_interp
+
+                # write interpolated channel loc
+                for ti in t_new:
+                    chn += 1
+                    interp_ch.append([*ti, chn])
+
+                # handle floor int problem when l_start/d_interp is near an
+                # interger
+                if (d_interp - l_res) / d_interp < 1e-6:
+                    chn += 1
+                    interp_ch.append([*track[j + 1, :], int(tn[j + 1])])
+                    l_res = 0
+                chn_res = 0
+            # if tp segment length is not enough for one interval, simply add
+            # the length to next segment
+            elif l_start < d_interp:
+                l_res = l_start
+
+    return np.array(seg_interval), np.array(interp_ch)
+
+
+def location_interpolation(known_pt, track_pt=None, dx=2, data_type='lonlat',
+                           verbose=False):
+    """
+    Interpolate to obtain the positions of all channels.
+
+    :param known_pt: np.ndarray. Points with known channel numbers. Each row
+        includes 2 or 3 coordinates and a channel number.
+    :param track_pt: np.ndarray. Optional fiber spatial track points without
+        channel numbers. Each row includes 2 or 3 coordinates. Please ensure
+        that the track points are arranged in increasing order of track number.
+        If track points is not dense enough, please insert the coordinates of
+        known points into track points in order.
+    :param dx: Known points far from the track (> dx) will be excluded.
+        Recommended setting is channel interval. The unit is m.
+    :param data_type: str. Coordinate type. 'lonlat' ('lonlatheight') for
+        longitude, latitude in degree (and height in meters), 'xy' ('xyz') for
+        x, y (and z) in meters.
+    :param verbose: bool. If True, return interpoleted channel location and
+        segment interval.
+    :return: Interpoleted channel location if verbose is False.
+    """
+    known_pt = known_pt[known_pt[:,-1].argsort()]
+    dim = known_pt.shape[1] - 1
+    if 'lonlat' in data_type:
+        zone = np.floor((max(known_pt[:,0]) + min(known_pt[:,0])) / 2 / 6)\
+            .astype(int) + 31
+        DASProj = Proj(proj='utm', zone=zone, ellps='WGS84',
+                       preserve_units=False)
+        known_pt[:, 0], known_pt[:, 1] = DASProj(known_pt[:, 0], known_pt[:, 1])
+    else:
+        assert 'xy' in data_type, ('data_type should be \'lonlat\',\''
+                                   'lonlatheight\', \'xy\' or \'xyz\'')
+
+    if track_pt is None:
+        seg_interval, interp_ch = _channel_location(known_pt)
+    else:
+        K = len(known_pt)
+        T = len(track_pt)
+        track_pt = np.c_[track_pt, np.zeros(T) - 1]
+        if 'lonlat' in data_type:
+            track_pt[:, 0], track_pt[:, 1] = DASProj(track_pt[:, 0],
+                                                     track_pt[:, 1])
+
+        # insert the known points into the fiber track data
+        matrix = [np.tile(track_pt[:, d], (K, 1)) -
+                  np.tile(known_pt[:, d], (T, 1)).T for d in range(dim)]
+
+        dist = np.sqrt(np.sum(np.array(matrix) ** 2, axis=0))
+        for k in range(K):
+            if min(dist[k]) < dx:
+                t_list = np.sort(np.where(dist[k] == min(dist[k]))[0])
+                for t in t_list:
+                    if track_pt[t, -1] == -1:
+                        track_pt[t, -1] = known_pt[k, -1]
+                        last_pt = t
+                        break
+
+        # interpolation with regular spacing along the fiber track
+        try:
+            track_pt = track_pt[:last_pt + 1]
+        except NameError:
+            print('All known points are too far away from the track points. If '
+                  'they are reliable, they can be merged in sequence as track '
+                  'points to input')
+            return None
+
+        seg_interval, interp_ch = _channel_location(track_pt)
+
+    if data_type == 'lonlat':
+        interp_ch[:, 0], interp_ch[:, 1] = \
+            DASProj(interp_ch[:, 0], interp_ch[:, 1], inverse=True)
+
+    if verbose:
+        return interp_ch, seg_interval
+    return interp_ch
+
+
+def _xcorr(x, y):
+    N = len(x)
+    meanx = np.mean(x)
+    meany = np.mean(y)
+    stdx = np.std(np.asarray(x))
+    stdy = np.std(np.asarray(y))
+    c = np.sum((y - meany) * (x - meanx)) / (N * stdx * stdy)
+    return c
+
+
+def _horizontal_angle_change(geo, gap=10):
+    nch = len(geo)
+    angle = np.zeros(nch)
+    for i in range(1, nch - 1):
+        lon, lat = geo[i]
+        lon_s, lat_s = geo[max(i - gap, 0)]
+        lon_e, lat_e = geo[min(i + gap, nch - 1)]
+        azi_s = Geodesic.WGS84.Inverse(lat_s, lon_s, lat, lon)['azi1']
+        azi_e = Geodesic.WGS84.Inverse(lat, lon, lat_e, lon_e)['azi1']
+        dazi = azi_e - azi_s
+        if abs(dazi) > 180:
+            dazi = -np.sign(dazi) * (360 - abs(dazi))
+        angle[i] = dazi
+
+    return angle
+
+
+def _vertical_angle_change(geo, gap=10):
+    nch = len(geo)
+    angle = np.zeros(nch)
+    for i in range(1, nch - 1):
+        lon, lat, dep = geo[i]
+        lon_s, lat_s, dep_s = geo[max(i - gap, 0)]
+        lon_e, lat_e, dep_e = geo[min(i + gap, nch - 1)]
+        s12_s = Geodesic.WGS84.Inverse(lat_s, lon_s, lat, lon)['s12']
+        theta_s = np.arctan((dep - dep_s) / s12_s) / np.pi * 180
+        s12_e = Geodesic.WGS84.Inverse(lat, lon, lat_e, lon_e)['s12']
+        theta_e = np.arctan((dep_e - dep) / s12_e) / np.pi * 180
+        angle[i] = theta_e - theta_s
+
+    return angle
+
+
+def _local_maximum_indexes(data, thresh):
+    idx = np.where(data > thresh)[0]
+    if len(idx):
+        i = list(np.where(np.diff(idx) > 1)[0] + 1)
+        if len(idx) - 1 not in i:
+            i.append(len(idx) - 1)
+        b = 0
+        max_idx = []
+        for e in i:
+            max_idx.append(idx[b] + np.argmax(data[idx[b]:idx[e]]))
+            b = e
+        return max_idx
+    else:
+        return []
+
+
+def turning_points(data, data_type='coordinate', thresh=5, depth_info=False,
+                   channel_gap=3):
+    """
+    Seek turning points in the DAS channel.
+
+    :param data: numpy.ndarray. Data used to seek turning points.
+    :param data_type: str. If data_type is 'coordinate', data should include
+        longitude and latitude (first two columns), and can also include depth
+        (last column). If data_type is 'waveform', data should be continuous
+        waveform, preferably containing signal with strong coherence
+        (earthquake, traffic signal, etc.).
+    :param thresh: For coordinate data, when the angle of the optical cables on
+        both sides centered on a certain point exceeds thresh, it is considered
+        an turning point. For waveform, thresh means the MAD multiple of
+        adjacent channel cross-correlation values lower than their median.
+    :param depth_info: bool. Optional if data_type is 'coordinate'. Whether
+        depth (in meters) is included in the coordinate data and need to be
+        used.
+    :param channel_gap: int. Optional if data_type is 'coordinate'. The smaller
+        the value is, the finer the segmentation will be. It is recommended to
+        set it to half the ratio of gauge length and channel interval.
+    :return: list. Channel index of turning points.
+    """
+    if data_type == 'coordinate':
+        angle = _horizontal_angle_change(data[:, :2], gap=channel_gap)
+        turning_h = _local_maximum_indexes(abs(angle), thresh)
+
+        if depth_info:
+            angle = _vertical_angle_change(data, gap=channel_gap)
+            turning_v = _local_maximum_indexes(abs(angle), thresh)
+            return turning_h, turning_v
+
+        return turning_h
+
+    elif data_type == 'waveform':
+        nch = len(data)
+        cc = np.zeros(nch - 1)
+        for i in range(nch - 1):
+            cc[i] = _xcorr(data[i], data[i + 1])
+        median = np.median(cc)
+        mad = np.median(abs(cc - median))
+
+        return np.argwhere(cc < median - thresh * mad)[0]
+
+    else:
+        raise ValueError('Data_type should be \'coordinate\' or \'waveform\'.')