insardev-toolkit 2025.2.20.dev0__tar.gz

insardev_toolkit-2025.2.20.dev0/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Alexey Pechnikov, https://orcid.org/0000-0001-9626-8615 (ORCID)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

insardev_toolkit-2025.2.20.dev0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.2
+Name: insardev_toolkit
+Version: 2025.2.20.dev0
+Summary: InSAR.dev (Python InSAR): Geospatial Processing Toolkit
+Home-page: https://github.com/AlexeyPechnikov/pygmtsar
+Author: Alexey Pechnikov
+Author-email: alexey@pechnikov.dev
+License: BSD-3-Clause
+Keywords: satellite interferometry,InSAR,remote sensing,geospatial analysis,Sentinel-1,SBAS,PSI
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: xarray>=2024.1.0
+Requires-Dist: numpy
+Requires-Dist: numba
+Requires-Dist: pandas>=2.2
+Requires-Dist: geopandas
+Requires-Dist: distributed>=2024.1.0
+Requires-Dist: dask[complete]>=2024.4.1
+Requires-Dist: opencv-python
+Requires-Dist: joblib
+Requires-Dist: tqdm
+Requires-Dist: ipywidgets
+Requires-Dist: scipy
+Requires-Dist: shapely>=2.0.2
+Requires-Dist: xmltodict
+Requires-Dist: rioxarray
+Requires-Dist: tifffile
+Requires-Dist: h5netcdf>=1.3.0
+Requires-Dist: netCDF4
+Requires-Dist: nc-time-axis
+Requires-Dist: remotezip
+Requires-Dist: asf_search
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![View on GitHub](https://img.shields.io/badge/GitHub-View%20on%20GitHub-blue)](https://github.com/AlexeyPechnikov/pygmtsar)
+[![Available on pypi](https://img.shields.io/pypi/v/pygmtsar.svg)](https://pypi.python.org/pypi/pygmtsar/)
+[![Docker](https://badgen.net/badge/icon/docker?icon=docker&label)](https://hub.docker.com/r/pechnikov/pygmtsar)
+[![DOI](https://zenodo.org/badge/398018212.svg)](https://zenodo.org/badge/latestdoi/398018212)
+[![Support on Patreon](https://img.shields.io/badge/Patreon-Support-orange.svg)](https://www.patreon.com/pechnikov)
+[![ChatGPT Assistant](https://img.shields.io/badge/ChatGPT-Assistant-green?logo=openai)](https://insar.dev/ai)
+
+## PyGMTSAR (Python InSAR): Powerful, Accessible Satellite Interferometry
+
+<img src="assets/logo.jpg" width="15%" />
+
+PyGMTSAR (Python InSAR) is designed for both occasional users and experts working with Sentinel-1 satellite interferometry. It supports a wide range of features, including SBAS, PSI, PSI-SBAS, and more. In addition to the examples below, you’ll find more Jupyter notebook use cases on [Patreon](https://www.patreon.com/pechnikov) and updates on [LinkedIn](https://www.linkedin.com/in/alexey-pechnikov/).
+
+## About PyGMTSAR
+
+PyGMTSAR offers reproducible, high-performance Sentinel-1 interferometry accessible to everyone—whether you prefer Google Colab, cloud servers, or local processing. It automatically retrieves Sentinel-1 SLC scenes and bursts, DEMs, and orbits; computes interferograms and correlations; performs time-series analysis; and provides 3D visualization. This single library enables users to build a fully integrated InSAR project with minimal hassle. Whether you need a single interferogram or a multi-year analysis involving thousands of datasets, PyGMTSAR can handle the task efficiently, even on standard commodity hardware.
+
+## PyGMTSAR Live Examples on Google Colab
+
+Google Colab is a free service that lets you run interactive notebooks directly in your browser—no powerful computer, extensive disk space, or special installations needed. You can even do InSAR processing from a smartphone. These notebooks automate every step: installing PyGMTSAR library and its dependencies on a Colab host (Ubuntu 22, Python 3.10), downloading Sentinel-1 SLCs, orbit files, SRTM DEM data (automatically converted to ellipsoidal heights via EGM96), land mask data, and then performing complete interferometry with final mapping. You can also modify scene  or bursts names to analyze your own area of interest, and each notebook includes instant interactive 3D maps.
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1TARVTB7z8goZyEVDRWyTAKJpyuqZxzW2?usp=sharing) **Central Türkiye Earthquakes (2023).** The area is large, covering two consecutive Sentinel-1 scenes or a total of 56 bursts.
+
+<img src="assets/turkie_2023a.jpg" width="40%" /><img src="assets/turkie_2023b.jpg" width="40%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1dDFG8BoF4WfB6tOF5sAi5mjdBKRbhxHo?usp=sharing) **Pico do Fogo Volcano Eruption, Fogo Island, Cape Verde (2014).** The interferogram for this event is compared to the study *The 2014–2015 eruption of Fogo volcano: Geodetic modeling of Sentinel-1 TOPS interferometry* (*Geophysical Research Letters*, DOI: [10.1002/2015GL066003](https://doi.org/10.1002/2015GL066003)).
+
+<img src="assets/pico_2014a.jpg" width="40%" /><img src="assets/pico_2014b.jpg" width="40%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1d9RcqBmWIKQDEwJYo8Dh6M4tMjJtvseC?usp=sharing) **La Cumbre Volcano Eruption, Ecuador (2020).** The results compare with the report from Instituto Geofísico, Escuela Politécnica Nacional (IG-EPN) (InSAR software unspecified).
+
+<img src="assets/la_cumbre_2020a.jpg" width="40%" /><img src="assets/la_cumbre_2020b.jpg" width="40%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1shNGvUlUiXeyV7IcTmDbWaEM6XrB0014?usp=sharing) **Iran–Iraq Earthquake (2017).** The event has been well investigated, and the results compared to outputs from GMTSAR, SNAP, and GAMMA software.
+
+<img src="assets/iran_iraq_2017a.jpg" width="40%" /><img src="assets/iran_iraq_2017b.jpg" width="40%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1h4XxJZwFfm7EC8NUzl34cCkOVUG2uJr4?usp=sharing) **Imperial Valley Subsidence, CA USA (2015).**  This example is provided in the [GMTSAR project](https://topex.ucsd.edu/gmtsar/downloads/) in the archive file [S1A_Stack_CPGF_T173.tar.gz](http://topex.ucsd.edu/gmtsar/tar/S1A_Stack_CPGF_T173.tar.gz), titled 'Sentinel-1 TOPS Time Series'.
+
+The resulting InSAR velocity map is available as a self-contained web page at: [Imperial_Valley_2015.html](https://insar.dev/ui/Imperial_Valley_2015.html)
+
+<img src="assets/imperial_valley_2015a.jpg" width="40%" /> <img src="assets/imperial_valley_2015b.jpg" width="40%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1aqAr9KWKzGx9XpVie1M000C3vUxzNDxu?usp=sharing) **Kalkarindji Flooding, NT Australia (2024).** Correlation loss serves to identify flooded areas.
+
+<img src="assets/kalkarindji_2024.jpg" width="80%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1ipiQGbvUF8duzjZER8v-_R48DSpSmgvQ?usp=sharing) **Golden Valley Subsidence, CA USA (2021).** This example demonstrates the case study 'Antelope Valley Freeway in Santa Clarita, CA,' as detailed in [SAR Technical Series Part 4 Sentinel-1 global velocity layer: Using global InSAR at scale](https://blog.descarteslabs.com/using-global-insar-at-scale) and [Sentinel-1 Technical Series Part 5 Targeted Analysis](https://blog.descarteslabs.com/sentinel-1-targeted-analysis) with a significant subsidence rate 'exceeding 5cm/year in places'.
+
+<img src="assets/golden_valley_2021.jpg" width="80%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1O3aZtZsTrQIldvCqlVRel13wJRLhmTJt?usp=sharing) **Lake Sarez Landslides, Tajikistan (2017).** The example reproduces the findings shared in the following paper: [Integration of satellite SAR and optical acquisitions for the characterization of the Lake Sarez landslides in Tajikistan](https://www.google.com/url?q=https%3A%2F%2Fwww.researchgate.net%2Fpublication%2F378176884_Integration_of_satellite_SAR_and_optical_acquisitions_for_the_characterization_of_the_Lake_Sarez_landslides_in_Tajikistan).
+
+<img src="assets/lake_sarez_2017.jpg" width="80%" />
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/19PLuebOZ4gaYX5ym1H7SwUbJKfl23qPr?usp=sharing) **Erzincan Elevation, Türkiye (2019).** This example reproduces 29-page ESA document [DEM generation with Sentinel-1 IW](https://step.esa.int/docs/tutorials/S1TBX%20DEM%20generation%20with%20Sentinel-1%20IW%20Tutorial.pdf).
+
+<img src="assets/erzincan_2019.jpg" width="80%" />
+
+## More PyGMTSAR Live Examples on Google Colab
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1yuuA1ES2ly4QG3hyPg8YYT0nnpGDiQDw?usp=sharing) **Mexico City Subsidence, Mexico (2016).** This example replicates the 29-page ESA manual [TRAINING KIT – HAZA03. LAND SUBSIDENCE WITH SENTINEL-1 using SNAP](https://eo4society.esa.int/wp-content/uploads/2022/01/HAZA03_Land-Subsidence_Mexico-city.pdf).
+
+## PyGMTSAR Live Examples on Google Colab Pro
+
+I share additional InSAR projects on Google Colab Pro through my [Patreon page](https://www.patreon.com/pechnikov). These are ideal for InSAR learners, researchers, and industry professionals tackling challenging projects with large areas, big stacks of interferograms, low-coherence regions, or significant atmospheric delays. You can run these privately shared notebooks online with Colab Pro or locally/on remote servers.
+
+## Projects and Publications Using PyGMTSAR
+
+See the [Projects and Publications](/pubs/README.md) page for real-world projects and academic research applying PyGMTSAR. This is not an exhaustive list—contact me if you’d like your project or publication included.
+
+## Resources
+
+**PyGMTSAR projects and e-books**
+Available on [Patreon](https://www.patreon.com/c/pechnikov/shop). Preview versions can be found in this GitHub repo:
+
+- [PyGMTSAR Introduction Preview](https://github.com/AlexeyPechnikov/pygmtsar/blob/pygmtsar2/book/PyGMTSAR_preview.pdf)  
+- [PyGMTSAR Gaussian Filtering Preview](https://github.com/AlexeyPechnikov/pygmtsar/blob/pygmtsar2/book/Gaussian_preview.pdf)
+
+<img src="assets/listing.jpg" width="40%" />
+
+**Video Lessons and Notebooks**
+Find PyGMTSAR (Python InSAR) video lessons and educational notebooks on [Patreon](https://www.patreon.com/collection/12458) and [YouTube](https://www.youtube.com/channel/UCSEeXKAn9f_bDiTjT6l87Lg).
+
+**PyGMTSAR AI Assistant**
+The [PyGMTSAR AI Assistant](https://insar.dev/ai), powered by OpenAI ChatGPT, can explain InSAR theory, guide you through examples, help build an InSAR processing pipeline, and troubleshoot.
+
+<img width="40%" alt="PyGMTSAR AI Assistant" src="assets/ai.jpg" />
+
+**PyGMTSAR on DockerHub**
+Run InSAR processing on macOS, Linux, or Windows via [Docker images](https://hub.docker.com/r/pechnikov/pygmtsar).
+
+**PyGMTSAR on PyPI**
+Install the library from [PyPI](https://pypi.python.org/pypi/pygmtsar).
+
+**PyGMTSAR Previous Versions**
+2023 releases are still on GitHub, PyPI, DockerHub, and Google Colab. Compare PyGMTSAR InSAR with other software by checking out the [PyGMTSAR 2023 Repository](https://github.com/AlexeyPechnikov/pygmtsar/tree/pygmtsar).
+
+© Alexey Pechnikov, 2025

insardev_toolkit-2025.2.20.dev0/insardev_toolkit/ASF.py

@@ -0,0 +1,468 @@
+# ----------------------------------------------------------------------------
+# InSAR.dev
+# 
+# This file is part of the InSAR.dev project: https://InSAR.dev
+# 
+# Copyright (c) 2025, Alexey Pechnikov
+# 
+# Licensed under the BSD 3-Clause License (see LICENSE for details)
+# ----------------------------------------------------------------------------
+from .tqdm_joblib import tqdm_joblib
+#from .S1 import S1
+
+class ASF(tqdm_joblib):
+    import pandas as pd
+    from datetime import timedelta
+
+    # check for downloaded burst files
+    # like S1_370328_IW1_20150121T134421_VV_DBBE-BURST
+    template_burst = '{burstId}/*/{burst}.*'
+
+    def __init__(self, username=None, password=None):
+        import asf_search
+        import getpass
+        if username is None:
+            username = getpass.getpass('Please enter your ASF username and press Enter key:')
+        if password is None:
+            password = getpass.getpass('Please enter your ASF password and press Enter key:')
+        self.username = username
+        self.password = password
+
+    def _get_asf_session(self):
+        import asf_search
+        return asf_search.ASFSession().auth_with_creds(self.username, self.password)
+
+    # https://asf.alaska.edu/datasets/data-sets/derived-data-sets/sentinel-1-bursts/
+    def download(self, basedir, bursts, session=None, n_jobs=8, joblib_backend='loky', skip_exist=True,
+                        retries=30, timeout_second=3, debug=False):
+        """
+        Downloads the specified bursts extracted from Sentinel-1 SLC scenes.
+
+        Parameters
+        ----------
+        basedir : str
+            The directory where the downloaded bursts will be saved.
+        bursts : list of str
+            List of burst identifiers to download.
+        session : asf_search.ASFSession, optional
+            The session object for authentication. If None, a new session is created.
+        n_jobs : int, optional
+            The number of concurrent download jobs. Default is 8.
+        joblib_backend : str, optional
+            The backend for parallel processing. Default is 'loky'.
+        skip_exist : bool, optional
+            If True, skips downloading bursts that already exist. Default is True.
+        debug : bool, optional
+            If True, prints debugging information. Default is False.
+
+        Returns
+        -------
+        pandas.DataFrame
+            A DataFrame containing the list of downloaded bursts.
+        """
+        import rioxarray as rio
+        from tifffile import TiffFile
+        import xmltodict
+        from xml.etree import ElementTree
+        import pandas as pd
+        import asf_search
+        import joblib
+        from tqdm.auto import tqdm
+        import os
+        import glob
+        from datetime import datetime, timedelta
+        import time
+        import warnings
+        # supress asf_search 'UserWarning: File already exists, skipping download'
+        warnings.filterwarnings("ignore", category=UserWarning)
+
+        def filter_azimuth_time(items, start_utc_dt, stop_utc_dt, delta=3):
+            return [item for item in items if
+                 datetime.strptime(item['azimuthTime'], '%Y-%m-%dT%H:%M:%S.%f') >= start_utc_dt - timedelta(seconds=delta) and
+                 datetime.strptime(item['azimuthTime'], '%Y-%m-%dT%H:%M:%S.%f') <= stop_utc_dt + timedelta(seconds=delta)]
+
+        if isinstance(bursts, str):
+            bursts = list(filter(None, map(str.strip, bursts.split('\n'))))
+
+        # create the directory if needed
+        os.makedirs(basedir, exist_ok=True)
+
+        # skip existing bursts
+        if skip_exist:
+            bursts_missed = []
+            for burst in bursts:
+                #print (burst)
+                # orbital path is not included into burst
+                fakeBurstId = '_'.join(['*'] + burst.split('_')[1:3])
+                template = self.template_burst.format(burstId=fakeBurstId, burst=burst)
+                #print ('template', template)
+                files = glob.glob(template, root_dir=basedir)
+                #print ('files', files)
+                exts =[ os.path.splitext(file)[-1] for file in files]
+                #print ('exts', exts)
+                if '.tiff' in exts and '.xml' in exts and len(exts)==4:
+                    #print ('pass')
+                    pass
+                else:
+                    bursts_missed.append(burst)
+        else:
+            # process all the defined scenes
+            bursts_missed = bursts
+        #print ('bursts_missed', len(bursts_missed))
+        # do not use internet connection, work offline when all the scenes already available
+        if len(bursts_missed) == 0:
+            return
+
+        def download_burst(result, basedir, session):
+            properties = result.geojson()['properties']
+            #print ('result properties', properties)
+            burst = properties['fileID']
+            burstId = properties['burst']['fullBurstID']
+            burstIndex = properties['burst']['burstIndex']
+            platform = properties['platform'][-2:]
+            polarization = properties['polarization']
+            #print ('polarization', polarization)
+            subswath = properties['burst']['subswath']
+
+            # create the directories if needed
+            burst_dir = os.path.join(basedir, burstId)
+            tif_dir = os.path.join(burst_dir, 'measurement')
+            xml_annot_dir = os.path.join(burst_dir, 'annotation')
+            xml_noise_dir = os.path.join(burst_dir, 'noise')
+            xml_calib_dir = os.path.join(burst_dir, 'calibration')
+            # save annotation using the burst and scene names
+            xml_file = os.path.join(xml_annot_dir, f'{burst}.xml')
+            xml_noise_file = os.path.join(xml_noise_dir, f'{burst}.xml')
+            xml_calib_file = os.path.join(xml_calib_dir, f'{burst}.xml')
+            #rint ('xml_file', xml_file)
+            tif_file = os.path.join(tif_dir, f'{burst}.tiff')
+            #print ('tif_file', tif_file)
+            for dirname in [burst_dir, tif_dir, xml_annot_dir, xml_noise_dir, xml_calib_dir]:
+                os.makedirs(dirname, exist_ok=True)
+
+            # download tif
+            # properties['bytes'] is not an accurate file size but it looks about 40 kB smaller
+            if os.path.exists(tif_file) and os.path.getsize(tif_file) >= int(properties['bytes']):
+                #print (f'pass {tif_file}')
+                pass
+            else:
+                #print ('YYY', os.path.getsize(tif_file), properties['bytes'])
+                # remove potentially incomplete file if needed
+                if os.path.exists(tif_file):
+                    os.remove(tif_file)
+                # check if we can open the downloaded file without errors
+                tmp_file = os.path.join(burst_dir, os.path.basename(tif_file))
+                # remove potentially incomplete data file if needed
+                if os.path.exists(tmp_file):
+                    os.remove(tmp_file)
+                result.download(burst_dir, filename=os.path.basename(tif_file), session=session)
+                if not os.path.exists(tmp_file):
+                    raise Exception(f'ERROR: TiFF file is not downloaded: {tmp_file}')
+                if os.path.getsize(tmp_file) == 0:
+                    raise Exception(f'ERROR: TiFF file is empty: {tmp_file}')
+                # check TiFF file validity opening it
+                with TiffFile(tmp_file) as tif:
+                    # get TiFF file information
+                    page = tif.pages[0]
+                    tags = page.tags
+                    data = page.asarray()
+                # attention: rasterio can crash the interpreter on a corrupted TIFF file
+                # perform this check as the final step
+                with rio.open_rasterio(tmp_file) as raster:
+                    raster.load()
+                # TiFF file is well loaded
+                if not os.path.exists(tmp_file):
+                    raise Exception(f'ERROR: TiFF file is missed: {tmp_file}')
+                # move to persistent name
+                if os.path.exists(tmp_file):
+                    os.rename(tmp_file, tif_file)
+
+            # download xml
+            if os.path.exists(xml_file) and os.path.getsize(xml_file) > 0 \
+                and os.path.exists(xml_noise_file) and os.path.getsize(xml_noise_file) > 0 \
+                and os.path.exists(xml_calib_file) and os.path.getsize(xml_calib_file) > 0:
+                #print (f'pass {xml_file}')
+                pass
+            else:
+                # get TiFF file information
+                with TiffFile(tif_file) as tif:
+                    page = tif.pages[0]
+                    offset = page.dataoffsets[0]
+                #print ('offset', offset)
+                # get the file name
+                basename = os.path.basename(properties['additionalUrls'][0])
+                #print ('basename', '=>', basename)
+                manifest_file = os.path.join(burst_dir, basename)
+                # remove potentially incomplete manifest file if needed
+                if os.path.exists(manifest_file):
+                    os.remove(manifest_file)
+                asf_search.download_urls(urls=properties['additionalUrls'], path=burst_dir, session=session)
+                if not os.path.exists(manifest_file):
+                    raise Exception(f'ERROR: manifest file is not downloaded: {manifest_file}')
+                if os.path.getsize(manifest_file) == 0:
+                    raise Exception(f'ERROR: manifest file is empty: {manifest_file}')
+                # check XML file validity parsing it
+                with open(manifest_file, 'r') as file:
+                    xml_content = file.read()
+                    _ = ElementTree.fromstring(xml_content)
+                # xml file is well parsed
+                if not os.path.exists(manifest_file):
+                    raise Exception(f'ERROR: manifest file is missed: {manifest_file}')
+                # parse xml
+                with open(manifest_file, 'r') as file:
+                    xml_content = file.read()
+                # remove manifest file
+                if os.path.exists(manifest_file):
+                    os.remove(manifest_file)
+
+                subswathidx = int(subswath[-1:]) - 1
+                content = xmltodict.parse(xml_content)['burst']['metadata']['product'][subswathidx]
+                assert polarization == content['polarisation'], 'ERROR: XML polarization differs from burst polarization'
+                annotation = content['content']
+
+                annotation_burst = annotation['swathTiming']['burstList']['burst'][burstIndex]
+                start_utc = annotation_burst['azimuthTime']
+                start_utc_dt = datetime.strptime(start_utc, '%Y-%m-%dT%H:%M:%S.%f')
+                #print ('start_utc', start_utc, start_utc_dt)
+
+                length = int(annotation['swathTiming']['linesPerBurst'])
+                #print (f'length={length}, burstIndex={burstIndex}')
+                azimuth_time_interval = annotation['imageAnnotation']['imageInformation']['azimuthTimeInterval']
+                burst_time_interval = timedelta(seconds=(length - 1) * float(azimuth_time_interval))
+                stop_utc_dt = start_utc_dt + burst_time_interval
+                stop_utc = stop_utc_dt.strftime('%Y-%m-%dT%H:%M:%S.%f')
+                #print ('stop_utc', stop_utc, stop_utc_dt)
+
+                # output xml
+                product = {}
+
+                adsHeader = annotation['adsHeader']
+                adsHeader['startTime'] = start_utc
+                adsHeader['stopTime'] = stop_utc
+                adsHeader['imageNumber'] = '001'
+                product = product   | {'adsHeader': adsHeader}
+
+                qualityInformation = {'productQualityIndex': annotation['qualityInformation']['productQualityIndex']} |\
+                                      {'qualityDataList':     annotation['qualityInformation']['qualityDataList']}
+                product = product   | {'qualityInformation': qualityInformation}
+
+                generalAnnotation = annotation['generalAnnotation']
+                # filter annotation['generalAnnotation']['replicaInformationList'] by azimuthTime
+                product = product   | {'generalAnnotation': generalAnnotation}
+
+                imageAnnotation = annotation['imageAnnotation']
+                imageAnnotation['imageInformation']['productFirstLineUtcTime'] = start_utc
+                imageAnnotation['imageInformation']['productLastLineUtcTime'] = stop_utc
+                imageAnnotation['imageInformation']['productComposition'] = 'Assembled'
+                imageAnnotation['imageInformation']['sliceNumber'] = '0'
+                imageAnnotation['imageInformation']['sliceList'] = {'@count': '0'}
+                imageAnnotation['imageInformation']['numberOfLines'] = str(length)
+                # imageStatistics and inputDimensionsList are not updated
+                product = product   | {'imageAnnotation': imageAnnotation}
+
+                dopplerCentroid = annotation['dopplerCentroid']
+                items = filter_azimuth_time(dopplerCentroid['dcEstimateList']['dcEstimate'], start_utc_dt, stop_utc_dt)
+                dopplerCentroid['dcEstimateList'] = {'@count': len(items), 'dcEstimate': items}
+                product = product   | {'dopplerCentroid': dopplerCentroid}
+
+                antennaPattern = annotation['antennaPattern']
+                items = filter_azimuth_time(antennaPattern['antennaPatternList']['antennaPattern'], start_utc_dt, stop_utc_dt)
+                antennaPattern['antennaPatternList'] = {'@count': len(items), 'antennaPattern': items}
+                product = product   | {'antennaPattern': antennaPattern}
+
+                swathTiming = annotation['swathTiming']
+                items = filter_azimuth_time(swathTiming['burstList']['burst'], start_utc_dt, start_utc_dt, 1)
+                assert len(items) == 1, 'ERROR: unexpected bursts count, should be 1'
+                # add TiFF file information
+                items[0]['byteOffset'] = offset
+                swathTiming['burstList'] = {'@count': len(items), 'burst': items}
+                product = product   | {'swathTiming': swathTiming}
+
+                geolocationGrid = annotation['geolocationGrid']
+                items = filter_azimuth_time(geolocationGrid['geolocationGridPointList']['geolocationGridPoint'], start_utc_dt, stop_utc_dt, 1)
+                # re-numerate line numbers for the burst
+                for item in items: item['line'] = str(int(item['line']) - (length * burstIndex))
+                geolocationGrid['geolocationGridPointList'] = {'@count': len(items), 'geolocationGridPoint': items}
+                product = product   | {'geolocationGrid': geolocationGrid}
+
+                product = product   | {'coordinateConversion': annotation['coordinateConversion']}
+                product = product   | {'swathMerging': annotation['swathMerging']}
+
+                with open(xml_file, 'w') as file:
+                    file.write(xmltodict.unparse({'product': product}, pretty=True, indent='  '))
+
+                # output noise xml
+                content = xmltodict.parse(xml_content)['burst']['metadata']['noise'][subswathidx]
+                assert polarization == content['polarisation'], 'ERROR: XML polarization differs from burst polarization'
+                annotation = content['content']
+
+                noise = {}
+
+                adsHeader = annotation['adsHeader']
+                adsHeader['startTime'] = start_utc
+                adsHeader['stopTime'] = stop_utc
+                adsHeader['imageNumber'] = '001'
+                noise = noise   | {'adsHeader': adsHeader}
+
+                if 'noiseVectorList' in annotation:
+                    noiseRangeVector = annotation['noiseVectorList']
+                    items = filter_azimuth_time(noiseRangeVector['noiseVector'], start_utc_dt, stop_utc_dt)
+                    # re-numerate line numbers for the burst
+                    for item in items: item['line'] = str(int(item['line']) - (length * burstIndex))
+                    noiseRangeVector = {'@count': len(items), 'noiseVector': items}
+                    noise = noise   | {'noiseVectorList': noiseRangeVector}
+
+                if 'noiseRangeVectorList' in annotation:
+                    noiseRangeVector = annotation['noiseRangeVectorList']
+                    items = filter_azimuth_time(noiseRangeVector['noiseRangeVector'], start_utc_dt, stop_utc_dt)
+                    # re-numerate line numbers for the burst
+                    for item in items: item['line'] = str(int(item['line']) - (length * burstIndex))
+                    noiseRangeVector = {'@count': len(items), 'noiseRangeVector': items}
+                    noise = noise   | {'noiseRangeVectorList': noiseRangeVector}
+
+                if 'noiseAzimuthVectorList' in annotation:
+                    noiseAzimuthVector = annotation['noiseAzimuthVectorList']
+                    items = noiseAzimuthVector['noiseAzimuthVector']['line']['#text'].split(' ')
+                    items = [int(item) for item in items]
+                    lowers = [item for item in items if item <= burstIndex * length] or items[0]
+                    uppers = [item for item in items if item >= (burstIndex + 1) * length - 1] or items[-1]
+                    mask = [True if item>=lowers[-1] and item<=uppers[0] else False for item in items]
+                    items = [item - burstIndex * length for item, m in zip(items, mask) if m]
+                    noiseAzimuthVector['noiseAzimuthVector']['firstAzimuthLine'] = lowers[-1] - burstIndex * length
+                    noiseAzimuthVector['noiseAzimuthVector']['lastAzimuthLine'] = uppers[0] - burstIndex * length
+                    noiseAzimuthVector['noiseAzimuthVector']['line'] = {'@count': len(items), '#text': ' '.join([str(item) for item in items])}
+                    items = noiseAzimuthVector['noiseAzimuthVector']['noiseAzimuthLut']['#text'].split(' ')
+                    items = [item for item, m in zip(items, mask) if m]
+                    noiseAzimuthVector['noiseAzimuthVector']['noiseAzimuthLut'] = {'@count': len(items), '#text': ' '.join(items)}
+                    noise = noise   | {'noiseAzimuthVectorList': noiseAzimuthVector}
+
+                with open(xml_noise_file, 'w') as file:
+                    file.write(xmltodict.unparse({'noise': noise}, pretty=True, indent='  '))
+
+                # output calibration xml
+                content = xmltodict.parse(xml_content)['burst']['metadata']['calibration'][subswathidx]
+                assert polarization == content['polarisation'], 'ERROR: XML polarization differs from burst polarization'
+                annotation = content['content']
+
+                calibration = {}
+
+                adsHeader = annotation['adsHeader']
+                adsHeader['startTime'] = start_utc
+                adsHeader['stopTime'] = stop_utc
+                adsHeader['imageNumber'] = '001'
+                calibration = calibration   | {'adsHeader': adsHeader}
+
+                calibration = calibration   | {'calibrationInformation': annotation['calibrationInformation']}
+
+                calibrationVector = annotation['calibrationVectorList']
+                items = filter_azimuth_time(calibrationVector['calibrationVector'], start_utc_dt, stop_utc_dt)
+                # re-numerate line numbers for the burst
+                for item in items: item['line'] = str(int(item['line']) - (length * burstIndex))
+                calibrationVector = {'@count': len(items), 'calibrationVector': items}
+                calibration = calibration   | {'calibrationVectorList': calibrationVector}
+
+                with open(xml_calib_file, 'w') as file:
+                    file.write(xmltodict.unparse({'calibration': calibration}, pretty=True, indent='  '))
+
+        # prepare authorized connection
+        if session is None:
+            session = self._get_asf_session()
+
+        with tqdm(desc=f'ASF Downloading Bursts Catalog', total=1) as pbar:
+            results = asf_search.granule_search(bursts_missed)
+            pbar.update(1)
+
+        if n_jobs is None or debug == True:
+            print ('Note: sequential joblib processing is applied when "n_jobs" is None or "debug" is True.')
+            joblib_backend = 'sequential'
+
+        def download_burst_with_retry(result, basedir, session, retries, timeout_second):
+            for retry in range(retries):
+                try:
+                    download_burst(result, basedir, session)
+                    return True
+                except Exception as e:
+                    print(f'ERROR: download attempt {retry+1} failed for {result}: {e}')
+                    if retry + 1 == retries:
+                        return False
+                time.sleep(timeout_second)
+
+        # download bursts
+        with self.tqdm_joblib(tqdm(desc='ASF Downloading Sentinel-1 SLC Bursts', total=len(bursts_missed))) as progress_bar:
+            statuses = joblib.Parallel(n_jobs=n_jobs, backend=joblib_backend)(joblib.delayed(download_burst_with_retry)\
+                                    (result, basedir, session, retries=retries, timeout_second=timeout_second) for result in results)
+
+        failed_count = statuses.count(False)
+        if failed_count > 0:
+            raise Exception(f'Bursts downloading failed for {failed_count} items.')
+        # parse processed bursts and convert to dataframe
+        bursts_downloaded = pd.DataFrame(bursts_missed, columns=['burst'])
+        # return the results in a user-friendly dataframe
+        return bursts_downloaded
+
+    @staticmethod
+    def search(geometry, startTime=None, stopTime=None, flightDirection=None,
+               platform='SENTINEL-1', processingLevel='auto', polarization='VV', beamMode='IW'):
+        import geopandas as gpd
+        import asf_search
+        import shapely
+
+        # cover defined time interval
+        if len(startTime)==10:
+            startTime=f'{startTime} 00:00:01'
+        if len(stopTime)==10:
+            stopTime=f'{stopTime} 23:59:59'
+
+        if flightDirection == 'D':
+            flightDirection = 'DESCENDING'
+        elif flightDirection == 'A':
+            flightDirection = 'ASCENDING'
+
+        # convert to a single geometry
+        if isinstance(geometry, (gpd.GeoDataFrame, gpd.GeoSeries)):
+            geometry = geometry.geometry.union_all()
+        # convert closed linestring to polygon
+        if geometry.type == 'LineString' and geometry.coords[0] == geometry.coords[-1]:
+            geometry = shapely.geometry.Polygon(geometry.coords)
+        if geometry.type == 'Polygon':
+            # force counterclockwise orientation.
+            geometry = shapely.geometry.polygon.orient(geometry, sign=1.0)
+        #print ('wkt', geometry.wkt)
+
+        if isinstance(processingLevel, str) and processingLevel=='auto' and platform == 'SENTINEL-1':
+            processingLevel = asf_search.PRODUCT_TYPE.BURST
+
+        # search bursts
+        results = asf_search.search(
+            start=startTime,
+            end=stopTime,
+            flightDirection=flightDirection,
+            intersectsWith=geometry.wkt,
+            platform=platform,
+            processingLevel=processingLevel,
+            polarization=polarization,
+            beamMode=beamMode,
+        )
+        return gpd.GeoDataFrame.from_features([product.geojson() for product in results], crs="EPSG:4326")
+
+    @staticmethod
+    def plot(bursts):
+        import pandas as pd
+        import matplotlib
+        import matplotlib.pyplot as plt
+
+        bursts['date'] = pd.to_datetime(bursts['startTime']).dt.strftime('%Y-%m-%d')
+        bursts['label'] = bursts.apply(lambda rec: f"{rec['flightDirection'].replace('E','')[:3]} {rec['date']} [{rec['pathNumber']}]", axis=1)
+        unique_labels = sorted(bursts['label'].unique())
+        unique_paths = sorted(bursts['pathNumber'].astype(str).unique())
+        colors = {label[-4:-1]: 'orange' if label[0] == 'A' else 'cyan' for i, label in enumerate(unique_labels)}
+        fig, ax = plt.subplots(figsize=(10, 8))
+        for label, group in bursts.groupby('label'):
+            group.plot(ax=ax, edgecolor=colors[label[-4:-1]], facecolor='none', linewidth=1, alpha=1, label=label)
+        burst_handles = [matplotlib.lines.Line2D([0], [0], color=colors[label[-4:-1]], lw=1, label=label) for label in unique_labels]
+        aoi_handle = matplotlib.lines.Line2D([0], [0], color='red', lw=1, label='AOI')
+        handles = burst_handles + [aoi_handle]
+        ax.legend(handles=handles, loc='upper right')
+        ax.set_title('Sentinel-1 Burst Footprints')
+        ax.set_xlabel('Longitude')
+        ax.set_ylabel('Latitude')