d3dtools 0.1.0__py3-none-any.whl

d3dtools/__init__.py

@@ -0,0 +1,10 @@
+"""
+D3DTOOLS - A collection of tools for working with shapefiles and converting them for Delft3D modeling.
+"""
+
+__version__ = '0.1.0'
+
+from . import ncrain
+from . import shpbc2pli
+from . import shpblock2pol
+from . import shpdike2pliz

d3dtools/ncrain.py

@@ -0,0 +1,267 @@
+"""
+Generate a NetCDF file from rainfall data and thiessen polygon shapefile.
+"""
+import os
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+import rasterio as rio
+import shutil
+from osgeo import gdal
+from netCDF4 import Dataset
+import pyproj
+from datetime import datetime
+
+
+def generate(
+    input_shp_folder='SHP',
+    input_tab_folder='TAB',
+    output_nc_folder='NC',
+    intermediate_ras_folder='RAS_RAIN',
+    intermediate_shp_folder='SHP_RAIN',
+    clean_intermediate=True,
+    raster_resolution=320):
+    """
+    Generate a NetCDF file from rainfall data and thiessen polygon shapefile.
+
+    Parameters:
+    -----------
+    input_shp_folder : str
+        Path to the folder containing input shapefiles (default: 'SHP')
+    input_tab_folder : str
+        Path to the folder containing input tabular data (CSV files) (default: 'TAB')
+    output_nc_folder : str
+        Path to the folder where NetCDF output will be saved (default: 'NC')
+    intermediate_ras_folder : str
+        Path to the folder where intermediate raster files will be saved (default: 'RAS_RAIN')
+    intermediate_shp_folder : str
+        Path to the folder where intermediate shapefile files will be saved (default: 'SHP_RAIN')
+    clean_intermediate : bool
+        Whether to clean up intermediate files after processing (default: True)
+    raster_resolution : float
+        Resolution of the raster in meters (default: 320)
+
+    Returns:
+    --------
+    str
+        Path to the generated NetCDF file
+    """
+
+    # Create output directories if they don't exist
+    if not os.path.exists(intermediate_ras_folder):
+        os.makedirs(intermediate_ras_folder)
+
+    if not os.path.exists(intermediate_shp_folder):
+        os.makedirs(intermediate_shp_folder)
+
+    if not os.path.exists(output_nc_folder):
+        os.makedirs(output_nc_folder)
+
+    # Read THIESSEN POLYGON shp file
+    thiessen = gpd.read_file(f'{input_shp_folder}/THIESSEN.shp')
+
+    # Add field rainfall to thiessen with datatype float
+    thiessen['rainfall'] = 0.0
+
+    # Read the rainfall data
+    # Search folder and get the first file name ending with '.csv', without the extension
+    for file in os.listdir(input_tab_folder):
+        if file.endswith('.csv'):
+            rainfall_ts = file[:-4]
+            break
+
+    rainfall = pd.read_csv(f'{input_tab_folder}/{rainfall_ts}.csv')
+
+    # Convert 'time' filed to datetime
+    rainfall['time'] = pd.to_datetime(rainfall['time'])
+
+    # List the stations
+    stations = rainfall.columns[1:].to_list()
+
+    # Assign rainfall at time steps to the thiessen polygons
+    # when the 'Station' field matches the station name
+    for i, timestep in enumerate(rainfall['time']):
+        for station in stations:
+            for j in range(len(thiessen)):
+                if thiessen.iloc[j, 1] == station:
+                    # thiessen['rainfall'][j] = rainfall[station][i]
+                    thiessen.loc[j, 'rainfall'] = rainfall[station][i]
+                    # Save the rainfall data to the shapefile
+                    thiessen.to_file(
+                        f'{intermediate_shp_folder}/THIESSEN_{i}.shp')
+                    # Open the shapefile
+                    thiessen = gpd.read_file(
+                        f'{intermediate_shp_folder}/THIESSEN_{i}.shp')
+                    # Get the extent of the shapefile
+                    xmin, ymin, xmax, ymax = thiessen.total_bounds
+                    # Get the resolution of the raster
+                    res = raster_resolution
+                    # Create the raster
+                    raster = f'{intermediate_ras_folder}/THIESSEN_{i}.tif'
+                    # Create the raster, set nodata value to -9999
+                    gdal.Rasterize(raster,
+                                   f'{intermediate_shp_folder}/THIESSEN_{i}.shp',
+                                   format='GTiff',
+                                   outputType=gdal.GDT_Float32,
+                                   xRes=res,
+                                   yRes=res,
+                                   attribute='rainfall',
+                                   outputSRS=thiessen.crs,
+                                   noData=-9999)
+
+    # Get timestamps, including hours, minutes, and seconds
+    timestamps = rainfall['time'].dt.strftime('%Y-%m-%d %H:%M:%S').to_list()
+
+    # Read the raster file
+    with rio.open(f'{intermediate_ras_folder}/THIESSEN_0.tif') as src:
+        # get the resolution of the raster
+        res = src.res[0]
+        # get the extent of the raster
+        xmin, ymin, xmax, ymax = src.bounds
+        # Find bounds for extend without bounding elements
+        xmin = xmin + res
+        ymin = ymin + res
+        xmax = xmax - res
+        ymax = ymax - res
+
+    # Get X coordinates of the raster
+    x = np.arange(xmin, xmax, res)
+    # Get Y coordinates of the raster
+    y = np.arange(ymin, ymax, res)
+
+    # Shift x, y by half of the resolution
+    x = x + res / 2
+    y = y + res / 2
+
+    lonList = []
+    latList = []
+
+    project = pyproj.Transformer.from_crs("epsg:3826", "epsg:4326")
+
+    # convert x to lat
+    for i in x:
+        lat, lon = project.transform(i, 0)
+        lonList.append(lon)
+
+    # convert y to lon
+    for i in y:
+        lat, lon = project.transform(0, i)
+        latList.append(lat)
+
+    # Create mesh grids
+    lonM, latM = np.meshgrid(lonList, latList)
+    X, Y = np.meshgrid(x, y)
+
+    # Create netcdf file
+    try:
+        # just to be safe, make sure dataset is not already open.
+        ncfile.close()
+    except:
+        pass
+
+    nc_file_path = f'{output_nc_folder}/{rainfall_ts}.nc'
+    ncFile = Dataset(nc_file_path, 'w', format='NETCDF4')
+
+    # Create the dimensions
+    x_dim = ncFile.createDimension('x', len(lonList))
+    y_dim = ncFile.createDimension('y', len(latList))
+    lat_dim = ncFile.createDimension('lat', len(latList))
+    lon_dim = ncFile.createDimension('lon', len(lonList))
+    time_dim = ncFile.createDimension('time', None)
+
+    # Creating variables
+    x2 = ncFile.createVariable('x', np.float64, ('x', ), fill_value=9.96921E36)
+    x2.standard_name = "projection_x_coordinate"
+    x2.long_name = "x coordinate according to TWD 1997"
+    x2.units = "m"
+    x2.axis = "X"
+    x2[:] = x
+
+    y2 = ncFile.createVariable('y', np.float64, ('y', ), fill_value=9.96921E36)
+    y2.standard_name = "projection_y_coordinate"
+    y2.long_name = "y coordinate according to TWD 1997"
+    y2.units = "m"
+    y2.axis = "Y"
+    y2[:] = y
+
+    lat2 = ncFile.createVariable('lat',
+                                 np.float64, ('y', 'x'),
+                                 fill_value=9.96921E36)
+    lat2.standard_name = "latitude"
+    lat2.long_name = "latitude"
+    lat2.units = "degrees_north"
+    lat2[:] = latM
+
+    lon2 = ncFile.createVariable('lon',
+                                 np.float64, ('y', 'x'),
+                                 fill_value=9.96921E36)
+    lon2.standard_name = "longitude"
+    lon2.long_name = "longitude"
+    lon2.units = "degrees_east"
+    lon2[:] = lonM
+
+    time = ncFile.createVariable('time', np.float64, ('time', ))
+    time.standard_name = "time"
+    time.long_name = "time"
+    time.units = "minutes since 1970-01-01 08:00:00.0 +0800"
+    time.axis = "T"
+
+    # Convert timestamp to minutes since 1970-01-01 08:00:00.0 +0800
+    timestamp = [datetime.strptime(i, '%Y-%m-%d %H:%M:%S') for i in timestamps]
+    time[:] = [(i - datetime(1970, 1, 1, 8, 0, 0)).total_seconds() / 60
+               for i in timestamp]
+
+    # CRS
+    crs = ncFile.createVariable('crs', np.int32)
+    crs.long_name = "coordinate reference system"
+    crs.crs_wkt = "PROJCS[\"TWD97 / TM2 zone 121\", \r\n  GEOGCS[\"TWD97\", \r\n    DATUM[\"Taiwan Datum 1997\", \r\n      SPHEROID[\"GRS 1980\", 6378137.0, 298.257222101, AUTHORITY[\"EPSG\",\"7019\"]], \r\n      TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \r\n      AUTHORITY[\"EPSG\",\"1026\"]], \r\n    PRIMEM[\"Greenwich\", 0.0, AUTHORITY[\"EPSG\",\"8901\"]], \r\n    UNIT[\"degree\", 0.017453292519943295], \r\n    AXIS[\"Geodetic longitude\", EAST], \r\n    AXIS[\"Geodetic latitude\", NORTH], \r\n    AUTHORITY[\"EPSG\",\"3824\"]], \r\n  PROJECTION[\"Transverse_Mercator\"], \r\n  PARAMETER[\"central_meridian\", 121.00000000000001], \r\n  PARAMETER[\"latitude_of_origin\", 0.0], \r\n  PARAMETER[\"scale_factor\", 0.9999], \r\n  PARAMETER[\"false_easting\", 250000.0], \r\n  PARAMETER[\"false_northing\", 0.0], \r\n  UNIT[\"m\", 1.0], \r\n  AXIS[\"Easting\", EAST], \r\n  AXIS[\"Northing\", NORTH], \r\n  AUTHORITY[\"EPSG\",\"3826\"]]"
+    crs.epsg_code = "EPSG:3826"
+    # set crs value to 0
+    crs[:] = 0
+
+    # Create the grid mapping variable
+    rainfall = ncFile.createVariable('rainfall',
+                                     np.float32, ('time', 'y', 'x'),
+                                     fill_value=-999.0)
+    rainfall.long_name = "rainfall"
+    rainfall.units = "mm"
+    rainfall.coordinates = "lat lon"
+    rainfall.grid_mapping = "crs"
+
+    # Write rainfall data to the netcdf file
+    data_arr = np.zeros((len(timestamp), len(latList), len(lonList)))
+
+    for i in range(len(timestamp)):
+        with rio.open(f'{intermediate_ras_folder}/THIESSEN_{i}.tif') as src:
+            data_arr_tmp = src.read(1)
+            # Get raster data without bounding elements
+            data_arr_tmp = data_arr_tmp[1:-1, 1:-1]
+            # flip in y direction
+            data_arr[i, :, :] = np.flipud(data_arr_tmp)
+
+    rainfall[:] = data_arr
+
+    # Close the netcdf file
+    ncFile.close()
+
+    # Remove intermediate files if requested
+    if clean_intermediate:
+        try:
+            shutil.rmtree(intermediate_ras_folder)
+            shutil.rmtree(intermediate_shp_folder)
+        except Exception as e:
+            print(f"Warning: Could not clean up intermediate files: {e}")
+
+    return nc_file_path
+
+
+def main():
+    """
+    Command line entry point
+    """
+    output_path = generate()
+    print(f"NetCDF file generated at: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

d3dtools/shpbc2pli.py

@@ -0,0 +1,83 @@
+"""
+Convert boundary line shapefile to *.pli file
+"""
+import os
+import glob
+import geopandas as gpd
+
+
+def convert(input_folder='SHP_BC', output_folder='PLI_BC'):
+    """
+    Convert boundary line shapefile to *.pli file
+    Attribute table must contain 'Id' or 'id' field for boundary name
+
+    Parameters:
+    -----------
+    input_folder : str
+        Path to the folder containing shapefiles with MultiLineString geometry (default: 'SHP_BC')
+    output_folder : str
+        Path to the output folder for PLI files (default: 'PLI_BC')
+    """
+    # Specify file source
+    fileList = glob.glob(f'{input_folder}/*.shp')
+    print(f"Found {len(fileList)} shapefiles in {input_folder}")
+
+    gdfs = []
+    for i, item in enumerate(fileList):
+        gdf = gpd.read_file(item)
+        gdfs.append(gdf)
+
+    # Read wkt
+    ref_wkts = []
+    for i, gdf in enumerate(gdfs):
+        ref_wkt = [g.wkt for g in gdf['geometry'].values]
+        ref_wkts.append(ref_wkt)
+
+    print(f"Total features: {len(ref_wkts)}")
+
+    # Get boundary names
+    bcNames = []
+    for i, gdf in enumerate(gdfs):
+        try:
+            bcName = [name for name in gdf['Id'].values]
+        except:
+            bcName = [name for name in gdf['id'].values]
+        bcNames.append(bcName)
+
+    # Create output folder if not exist
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+        print(f"Created output folder: {output_folder}")
+
+    # For loop gdfs, create a .pli file with id as its name
+    file_count = 0
+    for i, ref_wkt in enumerate(ref_wkts):
+        for j, item in enumerate(ref_wkt):
+            with open(f'{output_folder}/{bcNames[i][j]}.pli', 'w',
+                    encoding='utf-8') as f:
+                f.write('{}\n'.format(bcNames[i][j]))
+                points = [
+                    point.split() for point in item.replace(
+                        "LINESTRING (", "").replace(")", "").split(',')
+                ]
+                f.write('{} {}\n'.format(len(points), 2))
+                for k, ktem in enumerate(points):
+                    f.write(
+                        f'{float(ktem[0]):.6f} {float(ktem[1]):.6f} {bcNames[i][j]}_{k+1:0>4}\n'
+                    )
+                f.write('\n')
+            file_count += 1
+
+    print(f'Done! Generated {file_count} PLI files in {output_folder}')
+    return file_count
+
+
+def main():
+    """
+    Command line entry point
+    """
+    convert()
+
+
+if __name__ == "__main__":
+    main()

d3dtools/shpblock2pol.py

@@ -0,0 +1,78 @@
+"""
+Convert shapefile blocks to *.pol files
+"""
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+from glob import glob
+import os
+import shapely.wkt
+import matplotlib.pyplot as plt
+from shapely.geometry import Point, LineString
+
+
+def convert(input_folder='SHP_BLOCK', output_folder='POL_BLOCK'):
+    """
+    Convert shapefile blocks to *.pol files
+
+    Parameters:
+    -----------
+    input_folder : str
+        Path to the folder containing shapefiles (default: 'SHP_BLOCK')
+    output_folder : str
+        Path to the folder where .pol files will be saved (default: 'POL_BLOCK')
+    """
+    # Read shapefile data
+    blockList = glob(f'{input_folder}/*.shp')
+    blockNameList = [os.path.basename(block).split('.')[0]
+                     for block in blockList]
+
+    # Extract wkt from blocks and convert to pol
+    for i, block in enumerate(blockList):
+        # Read block
+        blockGdf = gpd.read_file(block)
+        # Remove data without geometry
+        blockGdf = blockGdf[blockGdf['geometry'].notnull()]
+        # Assign id (serial number) to each feature in block
+        blockGdf['id'] = range(1, len(blockGdf) + 1)
+        # Get blockName
+        blockName = blockGdf['id'].values
+        # Get wkt
+        ref_wkt = [g.wkt for g in blockGdf['geometry'].values]
+        print('Processing block: {}'.format(blockNameList[i]))
+
+        # If output folder does not exist, create it
+        if not os.path.exists(output_folder):
+            os.makedirs(output_folder)
+
+        try:
+            with open(f'{output_folder}/{blockNameList[i]}.pol', 'w') as f:
+                for j, wkt in enumerate(ref_wkt):
+                    points = [
+                        point.split() for point in wkt.replace("POLYGON ((", "").replace(
+                            "))", "").split(',')
+                    ]
+                    # Write to *.pol
+                    # Write blockName
+                    f.write('{}\n'.format(blockName[j]))
+                    f.write('{} {}\n'.format(len(points), 2))
+
+                    for point in points:
+                        # convert string to float and format
+                        f.write(
+                            f'{float(point[0]):.3f} {float(point[1]):.3f}\n')
+        except:
+            print('Error in block: {}'.format(blockNameList[i]))
+
+    return len(blockList)
+
+
+def main():
+    """
+    Command line entry point
+    """
+    convert()
+
+
+if __name__ == "__main__":
+    main()

d3dtools/shpdike2pliz.py

@@ -0,0 +1,89 @@
+"""
+Convert bankline shapefile to PLIZ file
+"""
+import os
+import glob
+import geopandas as gpd
+
+
+def convert(input_folder='SHP_DIKE',
+            output_folder='PLIZ_DIKE',
+            output_filename='Dike'):
+    """
+    Convert shapefile to DIKE PLIZ file
+    
+    Parameters:
+    -----------
+    input_folder : str
+        Path to the folder containing dike shapefiles with MultiLineStringZ geometry (default: 'SHP_DIKE')
+    output_folder : str
+        Output folder path (default: 'PLIZ_DIKE')
+    output_filename : str
+        Name of the output file without extension (default: 'Dike')
+        
+    Returns:
+    --------
+    str
+        Path to the created PLIZ file
+    """
+    # Specify file source
+    fileList = glob.glob(f'{input_folder}/*.shp')
+    print(f"Found {len(fileList)} files: {fileList}")
+    
+    # Read files
+    gdfs = []
+    for i, item in enumerate(fileList):
+        gdf = gpd.read_file(item)
+        gdfs.append(gdf)
+        
+    # Read wkt
+    ref_wkts = []
+    for i, gdf in enumerate(gdfs):
+        ref_wkt = [g.wkt for g in gdf['geometry'].values]
+        ref_wkts.append(ref_wkt)
+        
+    # Get dike name
+    dikeNames = []
+    for i, gdf in enumerate(gdfs):
+        try:
+            dikeName = [name for name in gdf['Id'].values]
+        except:
+            dikeName = [name for name in gdf['id'].values]
+        dikeNames.append(dikeName)
+        
+    # Create output folder if not exist
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+        
+    # Write to .pliz
+    output_path = os.path.join(output_folder, f"{output_filename}.pliz")
+    with open(output_path, 'w', encoding='utf-8') as f:
+        for k in range(len(gdfs)):
+            for i, item in enumerate(ref_wkts[k]):
+                f.write('{}\n'.format(dikeNames[k][i]))
+                # Remove heading "LINESTRING Z (" and trailing ")" characters using replace
+                points = [
+                    point.split() for point in item.replace(
+                        "LINESTRING Z (", "").replace(")", "").split(',')
+                ]
+                f.write('{} {}\n'.format(len(points), 5))
+                for j, jtem in enumerate(points):
+                    f.write('{:.6f} {:.6f} {} {} {}\n'.format(float(jtem[0]),
+                                                            float(jtem[1]),
+                                                            float(jtem[2]),
+                                                            float(jtem[2]),
+                                                            float(jtem[2])))
+                f.write('\n')
+    print(f'Done! PLIZ file created at: {output_path}')
+    return output_path
+
+
+def main():
+    """
+    Command line entry point
+    """
+    convert()
+
+
+if __name__ == "__main__":
+    main()

d3dtools-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Chih-Hung Hsu
+
+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.

d3dtools-0.1.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.2
+Name: d3dtools
+Version: 0.1.0
+Summary: A collection of tools for working with shapefiles and converting them for Delft3D modeling
+Home-page: https://github.com/AaronOET/d3dtools
+Author: aaronchh
+Author-email: aaronhsu219@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: geopandas>=0.10.0
+Requires-Dist: rasterio>=1.2.0
+Requires-Dist: netCDF4>=1.5.0
+Requires-Dist: pyproj>=3.0.0
+Requires-Dist: shapely>=1.8.0
+Requires-Dist: matplotlib>=3.4.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# D3DTOOLS
+
+A collection of Python tools for working with shapefiles and converting them for Delft3D modeling.
+
+## Installation
+
+```bash
+pip install d3dtools
+```
+
+## Features
+
+This package provides several utilities for converting shapefiles to various formats used in Delft3D modeling:
+
+- **ncrain**: Generate a NetCDF file from rainfall data and thiessen polygon shapefiles
+- **shpbc2pli**: Convert boundary line shapefiles to PLI files
+- **shpblock2pol**: Convert shapefile blocks to POL files
+- **shpdike2pliz**: Convert bankline shapefiles to PLIZ files
+
+## Usage Examples
+
+### Generate NetCDF from rainfall data
+
+```python
+from d3dtools import ncrain
+
+# Default usage
+output_path = ncrain.generate()
+print(f"NetCDF file generated at: {output_path}")
+
+# With custom parameters
+output_path = ncrain.generate(
+    input_shp_folder='custom/SHP',
+    input_tab_folder='custom/TAB',
+    output_nc_folder='custom/NC',
+    intermediate_ras_folder='custom/RAS_RAIN',
+    intermediate_shp_folder='custom/SHP_RAIN',
+    clean_intermediate=True,
+    raster_resolution=360
+)
+```
+
+### Convert boundary shapefiles to PLI
+
+```python
+from d3dtools import shpbc2pli
+
+# Default usage
+shpbc2pli.convert()
+
+# With custom parameters
+shpbc2pli.convert(
+    input_folder='custom/SHP_BC',
+    output_folder='custom/PLI_BC'
+)
+```
+
+### Convert block shapefiles to POL
+
+```python
+from d3dtools import shpblock2pol
+
+# Default usage
+shpblock2pol.convert()
+
+# With custom parameters
+shpblock2pol.convert(
+    input_folder='custom/SHP_BLOCK',
+    output_folder='custom/POL_BLOCK'
+)
+```
+
+### Convert dike shapefiles to PLIZ
+
+```python
+from d3dtools import shpdike2pliz
+
+# Default usage
+shpdike2pliz.convert()
+
+# With custom parameters
+shpdike2pliz.convert(
+    input_folder='custom/SHP_DIKE',
+    output_folder='custom/PLIZ_DIKE',
+    output_filename='CustomDike'
+)
+```
+
+## Command-line Usage
+
+The package also provides command-line utilities:
+
+```bash
+# Generate NetCDF from rainfall data
+ncrain
+
+# Convert boundary shapefiles to PLI
+shpbc2pli
+
+# Convert block shapefiles to POL
+shpblock2pol
+
+# Convert dike shapefiles to PLIZ
+shpdike2pliz
+```
+
+## Requirements
+
+- numpy>=1.20.0
+- pandas>=1.3.0
+- geopandas>=0.10.0
+- rasterio>=1.2.0
+- netCDF4>=1.5.0
+- pyproj>=3.0.0
+- shapely>=1.8.0
+- matplotlib>=3.4.0
+
+## License
+
+MIT

d3dtools-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+d3dtools/__init__.py,sha256=FHIt7wSDhSLqCW2XyjAU6ovedC-3jKGjrMNzbsmT134,242
+d3dtools/ncrain.py,sha256=NASYyddLn9T2YrrKvRZSBWLvgZ1LWK1TBGTUgtiexyE,10251
+d3dtools/shpbc2pli.py,sha256=xMzv3fAGEsx16UmJvuf4-zW8Iz1ovci8jUkFqD87NSM,2546
+d3dtools/shpblock2pol.py,sha256=qMVRdMJSX2F32mkBJlXAEbhn1ENDRzimt-JFfNJWHXk,2530
+d3dtools/shpdike2pliz.py,sha256=d7bQncHdqOhXZ0mOQ2zlgyP1HDn9v7apzgRJFV4gVck,2878
+d3dtools-0.1.0.dist-info/LICENSE,sha256=Y4E4BtkoFh6GfTSIMn7HvnEJfg5ITZldXCIjESEOaTE,1089
+d3dtools-0.1.0.dist-info/METADATA,sha256=-TGMaeU7qh9v_wIv_DZl1rITQr_RdOj6qY7R71LTZK4,3370
+d3dtools-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+d3dtools-0.1.0.dist-info/entry_points.txt,sha256=XmpphWSk1AUh7ISlOACKT_u94ZLeVu3eeK1OJZqdsEE,181
+d3dtools-0.1.0.dist-info/top_level.txt,sha256=1FjGJxUu_zw__xOPcdP599x1LtGJDY22zLTjfuzSc7c,9
+d3dtools-0.1.0.dist-info/RECORD,,

d3dtools-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

d3dtools-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+ncrain = d3dtools.ncrain:generate
+shpbc2pli = d3dtools.shpbc2pli:convert
+shpblock2pol = d3dtools.shpblock2pol:convert
+shpdike2pliz = d3dtools.shpdike2pliz:convert

d3dtools-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+d3dtools