diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..dd84ea7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,38 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: '' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. iOS] + - Browser [e.g. chrome, safari] + - Version [e.g. 22] + +**Smartphone (please complete the following information):** + - Device: [e.g. iPhone6] + - OS: [e.g. iOS8.1] + - Browser [e.g. stock browser, safari] + - Version [e.g. 22] + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/custom.md b/.github/ISSUE_TEMPLATE/custom.md new file mode 100644 index 0000000..48d5f81 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/custom.md @@ -0,0 +1,10 @@ +--- +name: Custom issue template +about: Describe this issue template's purpose here. +title: '' +labels: '' +assignees: '' + +--- + + diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..bbcbbe7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: '' +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml new file mode 100644 index 0000000..138a902 --- /dev/null +++ b/.github/workflows/build-docs.yml @@ -0,0 +1,63 @@ +name: Publish Docs + +on: + push: + branches: + - 'main' + +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.ref }} + cancel-in-progress: true + +env: + SM_FRAMEWORK: "tf.keras" + +jobs: + docs: + name: Publish Docs + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + with: + persist-credentials: false + + - name: Setup Conda + uses: s-weigand/setup-conda@v1 + with: + python-version: 3.9 + conda-channels: conda-forge + + - name: Install and Build + shell: bash + run: | + conda config --prepend channels conda-forge + conda config --set channel_priority strict + conda create -n docs python=3.9 rasterio xarray scipy pyproj pandoc sphinx sphinx-autodoc-typehints jupyter_sphinx sphinx_rtd_theme sphinx-click nbsphinx autodocsumm + source activate docs + python -m pip install -e .[doc] + sphinx-build -b html docs/ docs/_build/ + #cd docs/ + #make html + + - name: Deploy 🚀 + uses: JamesIves/github-pages-deploy-action@v4 + if: ${{ github.event_name == 'release' }} + with: + token: ${{ secrets.GITHUB_TOKEN }} + branch: gh-pages + folder: docs/_build/ + #folder: docs/_build/html + clean: false + target-folder: ${{ github.ref }} + + - name: Deploy 🚀 + uses: JamesIves/github-pages-deploy-action@v4 + if: ${{ github.event_name == 'push' }} + with: + token: ${{ secrets.GITHUB_TOKEN }} + branch: gh-pages + folder: docs/_build/ + #folder: docs/_build/html + clean: false + target-folder: latest diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..0836d34 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,40 @@ +name: CI Regression + +on: [push, pull_request] + +env: + SM_FRAMEWORK: "tf.keras" + +jobs: + + test: + runs-on: ubuntu-latest + strategy: + max-parallel: 4 + matrix: + # 3.6 will reach EoL in December 2021 + # https://devguide.python.org/#status-of-python-branches + python-version: [ "3.8", "3.9" ] + steps: + - uses: actions/checkout@v2 + - name: Setup python + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + architecture: x64 + - name: Install test dependencies + run: | + sudo add-apt-repository ppa:ubuntugis/ubuntugis-unstable + sudo apt-get update + sudo apt-get install -y gdal-bin libgdal-dev build-essential + python -m pip install --upgrade pip + pip install https://github.com/rasterio/rasterio/archive/master.zip + pip install .[test] + pip install coveralls + - name: Run tests + run: coverage run -m pytest -v + - name: Submit coveralls + if: github.event_name != 'pull_request' + run: coveralls --service=github + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml new file mode 100644 index 0000000..49f8c01 --- /dev/null +++ b/.github/workflows/codeql-analysis.yml @@ -0,0 +1,74 @@ +# For most projects, this workflow file will not need changing; you simply need +# to commit it to your repository. +# +# You may wish to alter this file to override the set of languages analyzed, +# or to provide custom queries or build logic. +# +# ******** NOTE ******** +# We have attempted to detect the languages in your repository. Please check +# the `language` matrix defined below to confirm you have the correct set of +# supported CodeQL languages. +# +name: "CodeQL" + +on: + push: + branches: [ "main" ] + pull_request: + # The branches below must be a subset of the branches above + branches: [ "main" ] + schedule: + - cron: '29 15 * * 2' + +jobs: + analyze: + name: Analyze + runs-on: ubuntu-latest + permissions: + actions: read + contents: read + security-events: write + + strategy: + fail-fast: false + matrix: + language: [ 'python' ] + # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ] + # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support + + steps: + - name: Checkout repository + uses: actions/checkout@v3 + + # Initializes the CodeQL tools for scanning. + - name: Initialize CodeQL + uses: github/codeql-action/init@v2 + with: + languages: ${{ matrix.language }} + # If you wish to specify custom queries, you can do so here or in a config file. + # By default, queries listed here will override any specified in a config file. + # Prefix the list here with "+" to use these queries and those in the config file. + + # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs + # queries: security-extended,security-and-quality + + + # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). + # If this step fails, then you should remove it and run the build manually (see below) + - name: Autobuild + uses: github/codeql-action/autobuild@v2 + + # ℹī¸ Command-line programs to run using the OS shell. + # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun + + # If the Autobuild fails above, remove it and uncomment the following three lines. + # modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance. + + # - run: | + # echo "Run, Build Application using script" + # ./location_of_script_within_repo/buildscript.sh + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v2 + with: + category: "/language:${{matrix.language}}" diff --git a/.github/workflows/dockerhub-dev.yml b/.github/workflows/dockerhub-dev.yml new file mode 100644 index 0000000..54d93a8 --- /dev/null +++ b/.github/workflows/dockerhub-dev.yml @@ -0,0 +1,45 @@ +name: Dev - CI to Docker Hub + +on: + push: + branches: + - 'develop' + schedule: + - cron: '30 5 * * 1,3' + +jobs: + docker: + runs-on: ubuntu-latest + steps: + - + name: Checkout + uses: actions/checkout@v3 + - + name: Set up QEMU + uses: docker/setup-qemu-action@v2 + - + name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + - + name: Login to Docker Hub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - + name: Lower github-runner storage + run: | + sudo rm -rf /usr/share/dotnet + sudo rm -rf /opt/ghc + sudo rm -rf "/usr/local/share/boost" + sudo rm -rf "$AGENT_TOOLSDIRECTORY" + + - + name: Build and push + uses: docker/build-push-action@v4 + with: + context: . + file: ./requirements/Dockerfile.dev + push: true + tags: nasanccs/vhr-cloudmask:dev diff --git a/.github/workflows/dockerhub.yml b/.github/workflows/dockerhub.yml new file mode 100644 index 0000000..0e08459 --- /dev/null +++ b/.github/workflows/dockerhub.yml @@ -0,0 +1,45 @@ +name: Prod - CI to Docker Hub + +on: + push: + branches: + - 'main' + schedule: + - cron: '30 5 * * 1,3' + +jobs: + docker: + runs-on: ubuntu-latest + steps: + - + name: Checkout + uses: actions/checkout@v3 + - + name: Set up QEMU + uses: docker/setup-qemu-action@v2 + - + name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + - + name: Login to Docker Hub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - + name: Lower github-runner storage + run: | + sudo rm -rf /usr/share/dotnet + sudo rm -rf /opt/ghc + sudo rm -rf "/usr/local/share/boost" + sudo rm -rf "$AGENT_TOOLSDIRECTORY" + + - + name: Build and push + uses: docker/build-push-action@v4 + with: + context: . + file: ./requirements/Dockerfile + push: true + tags: nasanccs/vhr-cloudmask:latest diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..cf8f071 --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,18 @@ +name: Code style - PEP8 + +on: [push, pull_request] + +jobs: + + flake8-lint: + runs-on: ubuntu-latest + name: Lint + steps: + - name: Check out source repository + uses: actions/checkout@v2 + - name: Set up Python environment + uses: actions/setup-python@v2 + with: + python-version: "3.8" + - name: flake8 Lint + uses: py-actions/flake8@v2 diff --git a/.github/workflows/pypi-publish.yml b/.github/workflows/pypi-publish.yml new file mode 100644 index 0000000..b656d5e --- /dev/null +++ b/.github/workflows/pypi-publish.yml @@ -0,0 +1,18 @@ +name: Publish to PyPI.org +on: + workflow_dispatch: + release: + types: [published] +jobs: + pypi: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + with: + fetch-depth: 0 + - run: python3 -m pip install --upgrade build && python3 -m build + - name: Publish package + uses: pypa/gh-action-pypi-publish@release/v1 + with: + password: ${{ secrets.PYPI_API_TOKEN }} \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..778a602 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.DS_Store/ +.ipynb_checkpoints/ +__pycache__/ +.DS_Store diff --git a/.ipynb_checkpoints/Postprocessing-checkpoint.py b/.ipynb_checkpoints/Postprocessing-checkpoint.py deleted file mode 100644 index 8f23dd0..0000000 --- a/.ipynb_checkpoints/Postprocessing-checkpoint.py +++ /dev/null @@ -1,243 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Thu Apr 7 18:55:07 2022 - -@author: amullen -""" -import sys -sys.path.append("..") -sys.path -from utils.gs_utils import get_shapes -import os -import rioxarray as rxr -from rasterio import features -import geopandas as gpd -import pandas as pd -import shapely -import seaborn as sns -import numpy as np -from matplotlib import pyplot as plt -from rasterio.mask import mask -import rasterio as rio -import utils -import ast - -# This script takes the u-net output (single-band raster with values ranging from 0-1), binarizes it, filters water body objects using a slope threshold and nodata filter, and outputs a shapefile containing the resulting water body objects. - -#path to image directory that predictions were generated from -images_dir = '' - -#path_to_predictions -predictions_dir = '' - -#path to output postprocessed shapefiles -out_shapefiles_dir = '' -out_geotiffs_dir = '' - -#image descriptor -image_descriptor = '_masked.tif' - -#path to slope raster to use for slope filtering -path_to_slope = '' - -NODATA_FILTER = True -SLOPE_FILTER = False -SLOPE_THRESHOLD = 7 - - -def get_gradients(gdf, buffer_sizes): - - gdf['geometry'] = gdf['geometry'].buffer(0) - - gdf['ndwi_water'] = np.zeros(len(gdf)) - gdf['ndvi_water'] = np.zeros(len(gdf)) - - distance_counter = 0 - sum_buffer = 0 - - for i in range(0, len(buffer_sizes)): - - distance_counter+=buffer_sizes[i] - - gdf['ndwi_{}m'.format(distance_counter)] = np.zeros(len(gdf)) - gdf['ndvi_{}m'.format(distance_counter)] = np.zeros(len(gdf)) - - buffered_gdf = gdf.buffer(distance_counter) - buffered_area = buffered_gdf.difference(gdf.buffer(sum_buffer)) - gdf['{}m_geometry'.format(distance_counter)] = buffered_area - - sum_buffer+=buffer_sizes[i] - - return gdf - -def calc_buffer_stats(image, gdf, buffer_field, stats_field): - - for index, row in gdf.iterrows(): - - masked_raster, masked_raster_transform = mask(image, [row[buffer_field]], invert=False, nodata = 0) - masked_raster = masked_raster.astype(np.float32) - masked_raster[masked_raster==0] = np.nan - - ndvi = (masked_raster[3]-masked_raster[2]) / (masked_raster[3]+masked_raster[2]) - ndwi = (masked_raster[1]-masked_raster[3]) / (masked_raster[1]+masked_raster[3]) - - if 'ndwi' in stats_field: - gdf.at[index,stats_field] = np.nanmean(ndwi) - - if 'ndvi' in stats_field: - gdf.at[index,stats_field] = np.nanmean(ndvi) - - return gdf - -def run_postprocessing(path_to_image, path_to_prediction, path_to_out_shapefile, path_to_output_geotiff, slope = None): - """ - Run postprocessing procedure - :param path_to_image: path to .h5 model file. - :type shape: `str` representing the path to .h5 model file. - :param path_to_prediction: path to .h5 model file. - :type shape: `str` representing the path to .h5 model file. - :param path_to_out_shapefile: path to .h5 model file. - :type shape: `str` representing the path to .h5 model file. - :param slope: path to .h5 model file. - :type shape: `str` representing the path to .h5 model file. - - :return: u-net model - :rtype: 'tf.keras.Model' - """ - #get shapes from prediction - with rio.open(path_to_prediction) as src_pred: - - #read prediction band - prediction = src_pred.read(1) - - #set every pixel >= 0.5 to water, everything < 0.5 to not water - prediction[prediction<0.5] = 0 - prediction[prediction>=0.5] = 1 - - #get geotransform and crs - t_prediction = src_pred.transform - proj_prediction = src_pred.crs - - #get shapes from raster - gdf_pred = get_shapes(prediction, t_prediction, proj_prediction) - #open image in "read + mode" - - - if SLOPE_FILTER == True: - #reproject/resample slope raster to match extent, resolution, and projection of image - image_match = rxr.open_rasterio(path_to_prediction) - slope_res = slope.rio.reproject_match(image_match) - slope_res = slope_res.assign_coords({ - "x": image_match.x, - "y": image_match.y, - }) - - with rio.open(path_to_image, 'r+') as src: - - #iterate through predicted water body shapes - for index, row in gdf_pred.iterrows(): - - #optional nodata filter - if NODATA_FILTER == True: - - #set image nodata to 255 (this only changes metadata value, does not affect raster values) - src.nodata = 65535 - - masked_water_body = rio.mask.mask(src, [row['geometry'].buffer(10)], crop = True)[0] - - #Planet imagery comes with nodata value of 0, so if a water body contains 0 in the corresponding image, remove it - if 0 in masked_water_body: - - masked_water_body = rio.mask.mask(src, [row['geometry'].buffer(10)], crop = False)[0] - gdf_pred = gdf_pred.drop(index) - prediction[masked_water_body[0]!=65535] = 0 - - src.nodata = 0 #set metadata nodata value back to zero - - continue - - else: - - src.nodata = 0 #set metadata nodata value back to zero - - #optional slope filter - if SLOPE_FILTER == True: - - src.nodata = 65535 - #clip slope to the exent of the water body and calculate mean slope - masked_slope = slope_res.rio.clip([row['geometry']], gdf_pred.crs, drop=True)[0] - - if np.nanmean(masked_slope)>SLOPE_THRESHOLD: - masked_slope = slope_res.rio.clip([row['geometry']], gdf_pred.crs, drop=False) - #remove water body if slope is above threshold - gdf_pred = gdf_pred.drop(index) - prediction[masked_slope!=65535] = 0 - #print('dropped water body above slope threshold') - - src.nodata = 0 - - if len(gdf_pred)>0: - print('writing to {}'.format(path_to_out_shapefile)) - print(gdf_pred.dtypes) - gdf_pred.to_file(path_to_out_shapefile) - - #write postprocessed mask to tif - out_meta = src_pred.meta.copy() - out_meta.update({'driver':'GTiff', - 'width':src_pred.shape[1], - 'height':src_pred.shape[0], - 'count':1, - 'dtype':'float64', - 'crs':src_pred.crs, - 'transform':src_pred.transform, - 'nodata':0}) - - with rio.open(fp=path_to_output_geotiff, mode='w',**out_meta) as dst: - dst.write(prediction, 1) - -def main(): - - #check if script is being called with arguments from SLURM - if len(sys.argv) > 1: - print('argument read') - path_df = pd.read_csv(sys.argv[1]) - image_paths = path_df['image_paths'].to_list() - prediction_paths = path_df['prediction_paths'].to_list() - out_shapefiles = path_df['out_shapefiles'].to_list() - out_geotiffs = path_df['out_geotiffs'].to_list() - - else: - - #build arrays of images, predictions, and output shapefile paths - image_paths = [os.path.join(images_dir, image) for image in os.listdir(images_dir) if image.endswith(image_descriptor)] - prediction_paths = [os.path.join(predictions_dir, image.split(image_descriptor)[0] + '_unet_pred.tif') for image in os.listdir(images_dir) if image.endswith(image_descriptor)] - out_shapefiles = [os.path.join(out_shapefiles_dir, image.split(image_descriptor)[0] + '_unet_pred.shp') for image in os.listdir(images_dir) if image.endswith(image_descriptor)] - out_geotiffs = [os.path.join(out_geotiffs_dir, image.split(image_descriptor)[0] + '_pp.tif') for image in os.listdir(images_dir) if image.endswith(image_descriptor)] - - #open slope raster if slope filtering on - if SLOPE_FILTER == True: - - xds_slope = rxr.open_rasterio(path_to_slope, masked=True) - - #loop through images and predictions - for i in range(0,len(image_paths)): - print(prediction_paths[i][:-4]+'_pp.tif') - if os.path.exists(prediction_paths[i][:-4]+'_pp.tif'): - - continue - - print('opening {}, associated with image: {}'.format(prediction_paths[i], image_paths[i])) - - if SLOPE_FILTER == True: - - run_postprocessing(image_paths[i], prediction_paths[i], out_shapefiles[i], out_geotiffs[i], slope = xds_slope) - - else: - - run_postprocessing(image_paths[i], prediction_paths[i], out_shapefiles[i], out_geotiffs[i]) - - -if __name__ == "__main__": - - main() - diff --git a/.ipynb_checkpoints/Predictor-checkpoint.py b/.ipynb_checkpoints/Predictor-checkpoint.py deleted file mode 100644 index 600fe4e..0000000 --- a/.ipynb_checkpoints/Predictor-checkpoint.py +++ /dev/null @@ -1,222 +0,0 @@ -import os -import tensorflow.keras as keras -import numpy as np -import rasterio as rio -import segmentation_models as sm -from tensorflow.keras import models -import tensorflow as tf -from tensorflow.keras.layers import Input, Conv2D -from tensorflow.keras.models import Model -from MightyMosaic import MightyMosaic -import rioxarray as rxr -import sys -import pandas as pd -import argparse - -#################################################################### variable definitions ################################################################## -# set backbone and backbone-specific preprocessing -BACKBONE = 'efficientnetb7' -preprocess_input = sm.get_preprocessing(BACKBONE) - -#set tensorflow data options -options = tf.data.Options() -options.experimental_distribute.auto_shard_policy = \ - tf.data.experimental.AutoShardPolicy.OFF - -########################################################################################################################################################### - -# compile cnn from .h5 model file -def compile_cnn(model_file): - """ - Compile u-net from .h5 model file - :param model_file: path to .h5 model file. - :type shape: `str` representing the path to .h5 model file. - - :return: u-net model - :rtype: 'tf.keras.Model' - """ - model = keras.models.load_model(model_file, - custom_objects={'binary_focal_loss_plus_jaccard_loss': sm.losses.binary_focal_jaccard_loss, - 'precision':sm.metrics.Precision, - 'recall':sm.metrics.Recall, - 'f1-score':sm.metrics.FScore, - 'iou_score': sm.metrics.IOUScore}) - - return model - -def compile_cnn_from_weights(weights_file): - """ - Compile u-net from .h5 model file that includes weights only - - :param model_file: path to .h5 model weights file. - :type shape: `str` representing the path to .h5 model weights file. - - :return: u-net model - :rtype: tf.keras.Model - """ - - #set backbone and get associated preprocessing - BACKBONE = 'efficientnetb7' - preprocess_input = sm.get_preprocessing(BACKBONE) - - #define model params - BATCH_SIZE = 32 - LR = 0.001 - EPOCHS = 220 - activation = 'softmax' - - #ensure that segmentation models is using the keras framework in channels_last mode - sm.set_framework('tf.keras') - keras.backend.set_image_data_format('channels_last') - - # define optimizer - optimizer = keras.optimizers.Adam(LR) - # enabling mixed precision to avoid underflow - optimizer = keras.mixed_precision.LossScaleOptimizer(optimizer) - # define loss - total_loss = keras.losses.CategoricalCrossentropy() - # define metrics to track - metrics = [sm.metrics.Precision(threshold=0.5), - sm.metrics.Recall(threshold=0.5), - sm.metrics.FScore(threshold=0.5), - sm.metrics.IOUScore(threshold=0.5)] - - #build model, compile, and load weights - model = sm.Unet(BACKBONE, classes = 1, activation=activation, encoder_weights=None, input_shape=(None, None, 4)) - model.compile(optimizer, total_loss, metrics) - model.load_weights(weights_file) - - return model - -def create_moving_window_data(image_dir, image, preprocess_input, slope = None): - """ - Format input data for u-net prediction - - :param image_dir: path to directory containing images to be predicted. - :type image_dir: `str` representing path to directory containing images to be predicted. - :param image: name of image to predict. - :type image: `str` representing name of image, must end in .tif. - :param slope: slope raster. - :type slope: `xarray.core.dataarray.DataArray` of slope raster. - :param preprocess_input: u-net preprocessing function specific to model backbone (efficientnet-b7). - :type preprocess_input: 'function'. - - :return: full_im - :rtype: 'np.array' of preprocessed image input data - :return: crs (projection) - :rtype: 'str' wkt representation of image projection - :return: gt (geotransform) - :rtype: 'tuple' array of image geotransform in gdal format - :return: shape - :rtype: 'tuple' dimensions of input image in (y,x) - """ - #open image - xds_full_im = rxr.open_rasterio(os.path.join(image_dir, image)) - - #get projection information (crs, geotransform, and raster shape) - crs = xds_full_im.rio.crs.wkt - gt = xds_full_im.rio.transform() - shape = np.shape(xds_full_im[0]) - - #get values as array - full_im = xds_full_im.values - - #scale image values - full_im = (full_im/10000.0)*255 #PlanetScope specific normalization - - #set areas where image=0 to 0.5 - image_zero_mask = full_im==0 - full_im[image_zero_mask==True] = 0.5 - - #stack on optional slope raster - if slope is not None: - - #reproject to match image extent, resolution, and crs - slope_data = slope.rio.reproject_match(xds_full_im) - slope_data = slope_data.assign_coords({ - "x": xds_full_im.x, - "y": xds_full_im.y, - }) - - slope_data = slope_data.values[0] - #set nodata areas in image to 0.5 in the slope raster - slope_data[image_zero_mask[0]==True] = 0.5 - - #add slope to stack - full_im = np.append(full_im, [slope_data], axis=0) - - #reshape to bands_last format and preprocess - full_im = full_im.transpose(2, 0, 1) - full_im = full_im.transpose(2, 0, 1) - full_im = preprocess_input(full_im) - - return full_im, crs, gt, shape - -def write_geotiff(out_image_path, image_shape, transform, crs, dataset, nodata): - - with rio.open(out_image_path, - 'w', - driver='GTiff', - height=image_shape[0], - width=image_shape[1], - count=1, - dtype=np.float64, - crs=crs, - transform=transform, - nodata=nodata, - compress='lzw') as output: - output.write(dataset, 1) - -def run_prediction(args): - - print('compiling model') - model = compile_cnn(args.model_file) - - images = [i for i in os.listdir(args.image_dir) if i.endswith('.tif')] - - #open slope raster once - if args.slope_model: - xds_slope = rxr.open_rasterio(args.slope_file) - - for image in images: - - print('formatting input data') - if args.slope_model: - full_im, crs, gt, image_shape = create_moving_window_data(args.image_dir, image, preprocess_input, slope=xds_slope) - else: - full_im, crs, gt, image_shape = create_moving_window_data(args.image_dir, image, preprocess_input) - print('generating Mighty Mosaic') - mosaic = MightyMosaic.from_array(full_im, (256,256), overlap_factor=args.tile_overlap, fill_mode='constant') - - print('predicting for input data') - prediction_mosaic = mosaic.apply(model.predict, progress_bar=True, batch_size=args.tile_batch) - prediction_mosaic = prediction_mosaic.get_fusion() - - write_geotiff(args.output_dir + image.split('.')[0] + '_unet_pred.tif', - image_shape, gt, crs, prediction_mosaic[:,:,0], 0) - - print('') - - slope = None - - return - -def main(): - - parser=argparse.ArgumentParser() - parser.add_argument("--image_dir", help="image directory to predict, expects geotiff format", required = False, default = 'examples/data/images/') - parser.add_argument("--output_dir", help="directory to save output water masks", required = False, default = 'examples/data/predictions/') - parser.add_argument("--model_file", help="path to the .h5 model file", required = False, default = 'res/single_class_best_model.h5') - parser.add_argument("--slope_model", help="whether or not to use the model that considers slope angle", required = False, default = False) - parser.add_argument("--slope_file", help="path to slope raster", required = False, default = 'examples/data/alaskaned_ex.tif') - parser.add_argument("--tile_overlap", help="#overlap factor for moving window prediction. Higher values increasingly mitigate image tiling artifacts but can potentially introduce noise.", required = False, default = 2) - parser.add_argument("--tile_batch", help="#batch size for model prediction. Number of tiles in the image must be divisible by this number", required = False, default = 4) - args=parser.parse_args() - - run_prediction(args) - - -if __name__ == "__main__": - main() - - diff --git a/.ipynb_checkpoints/UNet_single_class-checkpoint.py b/.ipynb_checkpoints/UNet_single_class-checkpoint.py deleted file mode 100644 index b3747c0..0000000 --- a/.ipynb_checkpoints/UNet_single_class-checkpoint.py +++ /dev/null @@ -1,542 +0,0 @@ -# -*- coding: utf-8 -*- -"""A module-level docstring - -Notice the comment above the docstring specifying the encoding. -Docstrings do appear in the bytecode, so you can access this through -the ``__doc__`` attribute. This is also what you'll see if you call -help() on a module or any other Python object. -""" -import os -from rasterio.plot import show -import cv2 -import tensorflow.keras as keras -import numpy as np -import matplotlib.pyplot as plt -import rasterio -import segmentation_models as sm -from tensorflow.keras import models -import tensorflow as tf -from tensorflow.keras.layers import Input, Conv2D -from tensorflow.keras.models import Model -from osgeo import gdal, gdalconst -from skimage.color import rgb2hsv -from rasterio.features import sieve, shapes -import albumentations as A -from functools import partial -import glob # for arrays modifications -import rioxarray as rxr -import random -from numpy.random import default_rng -import pandas as pd -import seaborn as sns - -#paths to image directories -x_train_dirs = [''] - -#paths to mask directories -y_train_dirs = [''] - -#paths to slope directories -slope_dirs = [''] - -#paths to twi directories -twi_dirs = [''] - -#path to npz directories -npz_dirs = [''] - -#tile ids to be used during training -path_to_tile_ids = '' - -#directory to save training history, validation stats, plots, and models -model_save_dir = '' - -#name of training run to associate with saved data -model_name = '' - -BATCH_SIZE = 32 -LR = 0.0001 -EPOCHS = 200 - -generate_npz = True #must be set to True if .npz data does not exist. If it does exist, set to false to save time on training -BACKBONE = 'efficientnetb7' - -#albumentations transformations -transforms = A.Compose([ - A.ShiftScaleRotate(p=0.5), - A.HorizontalFlip(p=0.125), - A.VerticalFlip(p=0.125) - ]) - -def gen_npz(ids, image_dirs, slope_dirs, masks_dirs, twi_dirs, preprocessing): - """ - Generate .npz files to store preprocessed training data to feed directly into model. - Args: - - ids (list(str)): list of image tile names to generate training data for, example:[''] - image_dirs (list(str)): list of directories containing image tiles - slope_dirs (list(str)): list of directories containing slope tiles - masks_dirs (list(str)): list of directories containing mask tiles - twi_dirs (list(str)): object id from npz file to get labels from - preprocessing (obj): segmentation models preprocessing object based on backbone specified - - Return: - get image and label datasets - ---------- - Example - ---------- - get_tensorslices(data_dir='images', img_id='x', label_id='y') - """ - - for image in ids: - - image_dir = '' - masks_dir = '' - slope_dir = '' - twi_dir = '' - - #loop through directories for different AOIs to make sure we are looking in the proper directory for each imag - for i in image_dirs: - if os.path.exists(os.path.join(i, image)): - image_dir = i - - for m in masks_dirs: - if os.path.exists(os.path.join(m, image)): - masks_dir = m - - for s in slope_dirs: - if os.path.exists(os.path.join(s, image)): - slope_dir = s - - for t in twi_dirs: - if os.path.exists(os.path.join(t, image)): - twi_dir = t - - save_dir = masks_dir[:-5] + 'npz/' - - - # read data - with rasterio.open(os.path.join(image_dir, image)) as src: - - #get array from image - image_data = (src.read(np.arange(1,src.count+1).tolist()).astype(np.float16)/10000.0)*255 #PlanetScope specific rescaling - - #get mask nodata - image_zero_mask = image_data==0 - - #set to different value - image_data[image_zero_mask==True] = 0.5 - - #open slope and append to data stack - ''' - with rasterio.open(os.path.join(slope_dir, image)) as slope_src: - - slope_data = slope_src.read(1).astype(np.float16) - - slope_data[image_zero_mask[0]==True] = 0.5 - slope_data[slope_data<=-1000] = 1 - - image_data = np.append(image_data, [slope_data], axis=0) - ''' - ''' - #open twi and append to data stack - with rasterio.open(os.path.join(twi_dir, image)) as twi_src: - - twi_data = twi_src.read(1).astype(np.float16) - - twi_data[image_zero_mask[0]==True] = 0.5 - twi_data[twi_data<=-1000] = 0 - - image_data = np.append(image_data, [twi_data], axis=0) - ''' - #reshape to 'bands last' format - image_data = image_data.transpose(2, 0, 1) - image_data = image_data.transpose(2, 0, 1) - - #apply preprocessing function - image_data = preprocessing(image_data) - - with rasterio.open(os.path.join(masks_dir, image)) as src_mask: - - #open mask data as np array - mask = src_mask.read(np.arange(1,src_mask.count+1).tolist()) - - #set all non-water to 0, water should = 1 - mask[np.expand_dims(image_zero_mask[0],axis=0)==True] = 0 - mask[mask<0.0] = 0 - mask[mask>1.0] = 0 - - mask = mask.astype(np.float16) - - #transpose array to "bands-last" format - mask = mask.transpose(2,0,1) - mask = mask.transpose(2,0,1) - - #save as npz - np.savez(f'{save_dir}{image[:-4]}.npz', x=image_data, y=mask) - -def get_tensorslices(data_dirs=[], img_id='x', label_id='y', test_proportion = 0.2, validation_proportion = 0.1): - """ - Getting tensor slices from .npz files - Args: - data_dirs (list): list of data directories where .npz data resides - img_id (str): object id from npz file to get data from - label_id (str): object id from npz file to get labels from - test_proportion (float): proportion of training data to use as test data - validation_proportion (float): proportion of training data to use as a holdout validation set - Return: - (tuple) - train_ids (list): list of image ids used for training - train_images (numpy array): array of shape (n_train_images, 256, 256, n_bands) - train_labels (numpy array): array of shape (n_train_labels, 256, 256, 1) - test_ids (list): list of image ids used for testing - test_images (numpy array): array of shape (n_test_images, 256, 256, n_bands) - test_labels (numpy array): array of shape (n_test_labels, 256, 256, 1) - validation_ids (list): list of image ids used for validation - validation_images (numpy array): array of shape (n_validation_images, 256, 256, n_bands) - validation_labels datasets (numpy array): array of shape (n_validation_labels, 256, 256, 1) - ---------- - Example - ---------- - get_tensorslices(data_dirs=['training_data/AOI/A/npz/', 'training_data/AOI/B/npz/'], img_id='x', label_id='y') - """ - # open files and generate training dataset - images = np.array([]) - labels = np.array([]) - ids = np.array([]) - - for data_dir in data_dirs: - print('reading in {}'.format(data_dir)) - # read all data files from disk - for f in glob.glob(f'{data_dir}/*'): - - with np.load(f) as data: - # vstack image batches into memory - if images.size: # if images has elements, vstack new batch - images = np.vstack([images, [data[img_id]]]) - else: # if images empty, images equals new batch - images = np.array([data[img_id]]) - # vstack label batches into memory - if labels.size: # if labels has elements, vstack new batch - labels = np.vstack([labels, [data[label_id]]]) - else: # if labels empty, images equals new batch - labels = np.array([data[label_id]]) - if ids.size: # if ids has elements, vstack new batch - ids = np.vstack([ids, [f[:-4] + '.tif']]) - else: # if ids empty, images equals new batch - ids = np.array([f[:-4] + '.tif']) - - # now we will randomly separate the train and test data based on specified proportion - num_test_samples = int(len(images) * test_proportion) - num_validation_samples = int(len(images) * validation_proportion) - - rng = default_rng(seed=4) - - random_indices = rng.choice(len(images), size=num_test_samples+num_validation_samples, replace=False) - - random.seed(4) - test_indices = np.array(random.sample(list(random_indices), num_test_samples)) - validation_indices = random_indices[~np.isin(random_indices,test_indices)] - - # create test set - test_images = images[test_indices] - test_labels = labels[test_indices] - test_ids = ids[test_indices] - - # create validation set - validation_images = images[validation_indices] - validation_labels = labels[validation_indices] - validation_ids = ids[validation_indices] - - # delete test and validation images from training stacks - train_images = np.delete(images, random_indices, axis=0) - train_labels = np.delete(labels, random_indices, axis=0) - train_ids = np.delete(ids, random_indices, axis=0) - - return train_ids, train_images, train_labels, test_ids, test_images, test_labels, validation_ids, validation_images, validation_labels - -#albumentations function -def set_shapes(img, label, img_shape=(256,256,4), mask_shape=(256,256,1)): - - img.set_shape(img_shape) - label.set_shape(mask_shape) - - return img, label - -#albumentations function -def aug_fn(image, label, img_size): - - data = {"image":image, "masks": [label[:,:,0]]} #uncomment for single class - - aug_data = transforms(**data) - - aug_img = aug_data["image"] - - aug_img = tf.image.resize(aug_img, size=[img_size, img_size]) - - aug_masks = aug_data["masks"] - - aug_masks = tf.transpose(aug_masks, perm = [2,0,1]) - aug_masks = tf.transpose(aug_masks, perm = [2,0,1]) - - return aug_img, aug_masks - -#albumentations function -def process_data(image, label, img_size): - - aug_data = tf.numpy_function(func=aug_fn, inp=[image, label, img_size], Tout=tuple([tf.float32, tf.float32])) - - return aug_data - -def get_training_dataset(dataset, batch_size = 8, drop_remainder=True): - - """ - Return training dataset to feed tf.fit. - Args: - dataset (tf.dataset): tensorflow dataset - batch_size (int): training batch size - drop_remainder (bool): drop remaineder when value does not match batch - Return: - tf dataset for training - ---------- - Example - ---------- - get_tensorslices(data_dir='images', img_id='x', label_id='y') - """ - - # create dataset - dataset = dataset.map(partial(process_data, img_size=256)) #use albumentations to augment data - dataset = dataset.map(set_shapes) #ensure input data has correct shape - dataset = dataset.shuffle(3000, reshuffle_each_iteration=True) #fill shuffle buffer - dataset = dataset.repeat() #repeat an undefined amount of times - dataset = dataset.batch(batch_size, drop_remainder=drop_remainder) - - # prefetch next batch while training (autotune prefetch buffer size) - dataset = dataset.prefetch(tf.data.AUTOTUNE) - - return dataset - -def water_bodies_by_size(validation_labels, predictions): - """ - Calculate accuracy metrics by water body size - Args: - validation_labels (numpy array): array of shape (n_validation_labels, 256, 256, 1) - predictions (numpy array): array of shape (n_predictions, 256, 256, 1) - Return: - tuple - IoU_scores (list(float)) - Precision_scores (list(float)) - Recall_scores (list(float)) - predicted_num_shapes (list(float)) - predicted_sieved (numpy array): array of shape (n_predictions, n_sieve_levels, 256, 256, 1) - pixel_cutoffs (list(float)): lower area boundary (in pixels) - ---------- - Example - ---------- - iou, precision, recall, num_shapes, sieved_predictions, pixel_cutoffs = water_bodies_by_size(validation_labels, predictions) - """ - - #define pixel cutoffs - pixel_cutoffs = [1000, 500, 250, 150, 60, 1] - - true_sieved = [] - predicted_sieved = [] - true_num_shapes = np.zeros(np.shape(pixel_cutoffs)) - predicted_num_shapes = np.zeros(np.shape(pixel_cutoffs)) - - for x in range(0,len(predictions)): - - true_sieved_levels = [] - predicted_sieved_levels = [] - - #get individual label and prediction - true = validation_labels[x, :, :, 0] - predicted = predictions[x, :, :, 0] - - true = true.astype(np.int16) - #binarize prediction - predicted[predicted<0.5] = 0 - predicted[predicted>=0.5] = 1 - predicted = predicted.astype(np.int16) - - i=0 - - for pixel_cutoff in pixel_cutoffs: - - #sieve the true mask and prediction based on water body size, starting with largest water bodies - ts = rasterio.features.sieve(true, pixel_cutoff, out=np.zeros(np.shape(true), np.int16)) - ps = rasterio.features.sieve(predicted, pixel_cutoff, out=np.zeros(np.shape(predicted), np.int16)) - - #append size group to list - true_sieved_levels.append(ts) - predicted_sieved_levels.append(ps) - - #add to shape count for water body sieve level - for x in range(0, len(list(rasterio.features.shapes(ts)))): - if list(rasterio.features.shapes(ts))[x][1]==1: - true_num_shapes[i] += 1 - - for y in range(0, len(list(rasterio.features.shapes(ps)))): - if list(rasterio.features.shapes(ps))[y][1]==1: - predicted_num_shapes[i] += 1 - - #set values of true and predicted mask from current sieve level to 0 - true[ts!=0] = 0 - predicted[ps!=0] = 0 - - i+=1 - - true_sieved.append(true_sieved_levels) - predicted_sieved.append(predicted_sieved_levels) - - #calculate scores for every sieve level and append results to respective lists - IoU_scores = [] - for sieve_level in range(0,len(pixel_cutoffs)): - - m = tf.keras.metrics.MeanIoU(2) - m.update_state(np.array(true_sieved)[:,sieve_level,:,:], np.array(predicted_sieved)[:,sieve_level,:,:]) - IoU_scores.append(m.result().numpy()) - - Precision_scores = [] - for sieve_level in range(0,len(pixel_cutoffs)): - - m = tf.keras.metrics.Precision() - m.update_state(np.array(true_sieved)[:,sieve_level,:,:], np.array(predicted_sieved)[:,sieve_level,:,:]) - Precision_scores.append(m.result().numpy()) - - Recall_scores = [] - for sieve_level in range(0,len(pixel_cutoffs)): - - m = tf.keras.metrics.Recall() - m.update_state(np.array(true_sieved)[:,sieve_level,:,:], np.array(predicted_sieved)[:,sieve_level,:,:]) - Recall_scores.append(m.result().numpy()) - - return IoU_scores, Precision_scores, Recall_scores, predicted_num_shapes, predicted_sieved, pixel_cutoffs - -def save_history_plot(history, out_img): - """ - Save plots for training loss and accuracy by epoch - Args: - history (tensorflow training history): output of model.fit - out_img (string): path to save output plot (must end in .jpg, .png, etc.) - Return: - None: saves plot to specified filepath - ---------- - Example - ---------- - save_history_plot(history, out_img) - """ - - # Plot training & validation iou_score values - plt.figure(figsize=(10, 5)) - plt.subplot(121) - plt.plot(history.history['iou_score']) - plt.plot(history.history['val_iou_score']) - plt.title('Model IOU-score') - plt.ylabel('IOU-Score') - plt.xlabel('Epoch') - plt.ylim(0, 1) - plt.legend(['Train', 'Test'], loc='upper left') - - # Plot training & validation loss values - plt.subplot(122) - plt.plot(history.history['loss']) - plt.plot(history.history['val_loss']) - plt.title('Model loss') - plt.ylabel('Loss') - plt.xlabel('Epoch') - plt.legend(['Train', 'Test'], loc='upper left') - plt.show() - plt.savefig(out_img, dpi=300) - -def main(): - - preprocess_input = sm.get_preprocessing(BACKBONE) - - df_ids = pd.read_csv(path_to_tile_ids) - ids = df_ids['ids'].to_numpy() - - if generate_npz == True: - print('generating npz') - gen_npz(ids, x_train_dirs, slope_dirs, y_train_dirs, twi_dirs, preprocess_input) - - #get data and convert to tf.Dataset object - train_ids, train_images, train_labels, test_ids, test_images, test_labels, validation_ids, validation_images, validation_labels= get_tensorslices(npz_dirs) - train_dataset = tf.data.Dataset.from_tensor_slices((train_images.astype(np.float32), train_labels.astype(np.float32))) - valid_dataset = tf.data.Dataset.from_tensor_slices((test_images.astype(np.float32), test_labels.astype(np.float32))).batch(8) - - #define model params - activation = 'sigmoid' - sm.set_framework('tf.keras') - keras.backend.set_image_data_format('channels_last') - optimizer = keras.optimizers.Adam(LR) - optimizer = keras.mixed_precision.LossScaleOptimizer(optimizer) # enabling mixed precision to avoid underflow - total_loss = sm.losses.binary_focal_jaccard_loss # define loss - # define metrics to track - metrics = [sm.metrics.Precision(threshold=0.5), - sm.metrics.Recall(threshold=0.5), - sm.metrics.FScore(threshold=0.5), - sm.metrics.IOUScore(threshold=0.5)] - - options = tf.data.Options() - options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA - - callbacks = [ - keras.callbacks.ModelCheckpoint(model_save_dir+model_name+'_best_model.h5', save_weights_only=False, save_best_only=True, mode='min', monitor = 'val_loss'), - keras.callbacks.ReduceLROnPlateau(monitor = 'loss', mode = 'min', verbose = 1), - keras.callbacks.CSVLogger(model_save_dir + model_name+'_train.csv') - ] - - strategy = tf.distribute.MirroredStrategy(devices= ["/GPU:0","/GPU:1", "/GPU:2", "/GPU:3"],cross_device_ops=tf.distribute.HierarchicalCopyAllReduce()) - print('Number of devices: {}'.format(strategy.num_replicas_in_sync)) - - # Open a strategy scope. - with strategy.scope(): - - # Everything that creates variables should be under the strategy scope. - # In general this is only model construction & `compile()`. - # create model - - #model = sm.Unet(BACKBONE, classes = 1, activation=activation, encoder_weights=None, input_shape=(None, None, 5)) - model = sm.Unet(BACKBONE, classes = 1, activation=activation, encoder_weights=None, input_shape=(None, None, 4)) - model.compile(optimizer, total_loss, metrics) - - # Train the model on all available devices. - # train model - history = model.fit( - get_training_dataset(train_dataset, batch_size = BATCH_SIZE).with_options(options), - steps_per_epoch=int(np.ceil(len(train_ids)/BATCH_SIZE)), - epochs=EPOCHS, - callbacks=callbacks, - validation_data=valid_dataset.with_options(options), - validation_steps=None, - use_multiprocessing = False - ) - - #save training history figure - hist_plot_path=model_save_dir + model_name+ '_history_plot.jpg' - save_history_plot(history, hist_plot_path) - - #get validation scores and save to csv - scores = model.evaluate(validation_images, validation_labels) - df_scores=pd.DataFrame(scores) - df_scores.to_csv(model_save_dir + model_name+ '_val.csv') - - #get validation predictions as tensor and get size-based stats - predictions = model.predict(validation_images) - IoU_scores, Precision_scores, Recall_scores, predicted_num_shapes, predicted_sieved, pixel_cutoffs = water_bodies_by_size(validation_labels, predictions) - - #save size-based stats to image - plt.figure(figsize=(10, 5)) - sns.scatterplot(x=pixel_cutoffs, y = IoU_scores, label = 'IoU') - sns.lineplot(x=pixel_cutoffs, y = IoU_scores, alpha = 0.3) - sns.scatterplot(x=pixel_cutoffs, y = Precision_scores, label = 'Precision') - sns.lineplot(x=pixel_cutoffs, y = Precision_scores, alpha = 0.3) - sns.scatterplot(x=pixel_cutoffs, y = Recall_scores, label = 'Recall') - sns.lineplot(x=pixel_cutoffs, y = Recall_scores, alpha = 0.3) - plt.ylabel('Score') - plt.xlabel('Water Body Area (pixels)') - plt.savefig(model_save_dir + model_name+ '_size_stats.jpg', dpi=300) - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/.ipynb_checkpoints/gen_composites-checkpoint.py b/.ipynb_checkpoints/gen_composites-checkpoint.py deleted file mode 100644 index 8a841a1..0000000 --- a/.ipynb_checkpoints/gen_composites-checkpoint.py +++ /dev/null @@ -1,175 +0,0 @@ -import sys -sys.path.append("..") -sys.path -import os -import numpy as np -import pandas as pd -import rasterio -import geopandas as gpd -from matplotlib import pyplot as plt -import json -from utils.gs_utils import write_geotiff -from osgeo import gdal, osr -import rioxarray as rxr - -#grouping = 'monthly' - -predictions_dir = '' -images_dir = '' -image_descriptor = '_masked.tif' -prediction_descriptor = '_unet_pred_pp.tif' -water_prob_image_dir = '' - -def get_bounding_box(prediction_names): - """ - Get UTM bounding box for group of images (upper left corner of pixels) - :param prediction_names: prediction names to get bounding box from. - :type prediction_names: `list(str)` only image names + .tif - - :return: (min_x, max_x, min_y, max_y) coordinates of upper left of pixels in bounding box - :rtype: tuple(float, float, float, float) - """ - #initialize minimum and maximum coordinates to extremes - min_x = 10000000 - max_x = 0 - min_y = 10000000 - max_y = 0 - - #loop through predictions - for prediction in prediction_names: - - with rasterio.open(os.path.join(predictions_dir, prediction)) as src: - - image_data = src.read(1).astype(np.float32) # rescale bands for "analytic_sr" asset - - shape = np.shape(image_data) - - gt = src.get_transform() - - if gt[0] < min_x: #gt[0] is the min x of the image - min_x = gt[0] - - if gt[0] + gt[1] * shape[1] > max_x: #gt[0] + gt[1] * shape[1] is the x-coordinate of the left side of the rightmost pixel - max_x = gt[0] + gt[1] * shape[1] - - if gt[3] > max_y: #gt[3] is the max y of the image - max_y = gt[3] - - if gt[3] + gt[5] * shape[0] < min_y: #gt[3] + gt[5] * shape[0] is the y coordinate of the top of the bottommost pixel - - min_y = gt[3] + gt[5] * shape[0] - - return min_x, max_x, min_y, max_y - -def get_prediction_stack(min_x, max_x, min_y, max_y, prediction_names, image_names): - """ - Get total predictions, total water predictions, and proportion water for each pixel for the entire domain - :param min_x: minimum x-coordinate from get_bounding_box. - :type min_x: `float` - :param max_x: maximum x-coordinate from get_bounding_box. - :type max_x: `float` - :param min_y: minimum y-coordinate from get_bounding_box. - :type min_y: `float` - :param max_y: maximum y-coordinate from get_bounding_box. - :type max_y: `float` - - :return: (sum_water, num_predictions, sum_water/num_predictions) - :rtype: tuple(float, float, float) - """ - #initialize empty arrays to build - sum_water = np.array([]) - num_predictions = np.array([]) - - for i in range(0,len(prediction_names)): - - #open image, pad to bounding box extent - xds_im = rxr.open_rasterio(os.path.join(images_dir, image_names[i]), nodata=0) - xds_im.values = xds_im.values.astype(np.uint8) - xds_im = xds_im.rio.pad_box( - minx=min_x, - miny=min_y, - maxx=max_x, - maxy=max_y - ) - - #open prediction, pad to bounding box extent - xds_pred = rxr.open_rasterio(os.path.join(predictions_dir, prediction_names[i]), nodata=0) - xds_pred = xds_pred.rio.pad_box( - minx=min_x, - miny=min_y, - maxx=max_x, - maxy=max_y - ) - - #get values - image_data = np.array(xds_im.values) - xds_im = None - pred_data = np.array(xds_pred.values) - xds_pred = None - - #threshold prediction so p>0.5 = water, otherwise nan - pred_data[pred_data>=0.5] = 1 - pred_data[pred_data<0.5] = np.nan - - #create mask for pixels that were predicted to be not water, not including imge nodata areas - data_mask = np.where((pred_data!=1) & (image_data[0]!=0)) - - #change values from nan to 0 for these pixels - pred_data[data_mask] = 0 - data_mask = None - - pred_data = pred_data.astype(np.float16) - - if sum_water.size == 0: #initialize arrays - - sum_water = np.copy(pred_data) - pred_data[pred_data>=0]=1 - pred_data[np.isnan(pred_data)]=0 - pred_data = pred_data.astype(np.uint16) - num_predictions = pred_data - - else: #add to arrays - - sum_water = np.nansum(np.array([sum_water,pred_data]), axis=0, dtype=np.float16) - pred_data[pred_data>=0]=1 - pred_data[pred_data!=1]=0 - pred_data = pred_data.astype(np.uint16) - num_predictions = np.nansum(np.array([num_predictions, pred_data]), axis=0, dtype=np.uint16) - - return sum_water, num_predictions, sum_water/num_predictions - -def build_composites(prediction_names, image_names): - - print('getting bounding box') - min_x, max_x, min_y, max_y = get_bounding_box(prediction_names) - - print('building prediction stack') - sum_water, num_predictions, water_prob = get_prediction_stack(min_x, max_x, min_y, max_y, prediction_names, image_names) - - return sum_water, num_predictions, water_prob, min_x, max_y - -def main(): - - if len(sys.argv) > 1: - print('argument read') - - df = pd.read_csv(sys.argv[1]) - month = sys.argv[1].split('/')[1].split('_composite_list.csv')[0] - - image_names = df['associated_image'].to_list() - prediction_names = df['prediction_name'].to_list() - - sum_water, num_predictions, water_prob, min_x, max_y = build_composites(prediction_names, image_names) - - gt = [min_x, 3.125, 0, max_y, 0, -3.125] - projection = osr.SpatialReference() - projection.ImportFromEPSG(32606) - projection = projection.ExportToWkt() - - write_geotiff(water_prob_image_dir + month + 'prob_composite.tif', np.shape(water_prob[0]), gt, projection, water_prob[0], 0) - write_geotiff(water_prob_image_dir + month + 'num_obs_composite.tif', np.shape(num_predictions[0]), gt, projection, num_predictions[0], 0) - write_geotiff(water_prob_image_dir + month + 'num_water_composite.tif', np.shape(sum_water[0]), gt, projection, sum_water[0], 0) - -if __name__ == "__main__": - - main() \ No newline at end of file diff --git a/.ipynb_checkpoints/prediction_example-checkpoint.ipynb b/.ipynb_checkpoints/prediction_example-checkpoint.ipynb deleted file mode 100644 index cb18a18..0000000 --- a/.ipynb_checkpoints/prediction_example-checkpoint.ipynb +++ /dev/null @@ -1,267 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-02-26 20:58:26.565250: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n", - ":228: RuntimeWarning: scipy._lib.messagestream.MessageStream size changed, may indicate binary incompatibility. Expected 56 from C header, got 64 from PyObject\n", - "/panfs/ccds02/nobackup/people/almullen/.conda/envs/smallsat/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Segmentation Models: using `tf.keras` framework.\n" - ] - } - ], - "source": [ - "import sys\n", - "import Predictor as pr\n", - "import os\n", - "import rioxarray as rxr\n", - "from matplotlib import pyplot as plt\n", - "import numpy as np\n", - "import Predictor\n", - "from box import Box" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "args={'image_dir': 'examples/data/images/', #directory with images to predict\n", - " 'output_dir': 'examples/data/predictions/', #directory to output predictions\n", - " 'model_file': 'res/single_class_slope_best_model.h5', #path to model file, use single_class_slope_best_model.h5 \n", - " #if slope_model==True, otherwise use single_class_best_model.h5\n", - " 'slope_model': True, #whether or not to the model includes slope\n", - " 'slope_file': 'examples/data/slope_ex.tif', #path to slope raster\n", - " 'tile_overlap': 2, #tile overlap factor for prediction\n", - " 'tile_batch': 4 #how many tiles to process per batch\n", - " }\n", - "args=Box(args)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "compiling model\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-02-26 20:58:31.240330: I tensorflow/compiler/jit/xla_cpu_device.cc:41] Not creating XLA devices, tf_xla_enable_xla_devices not set\n", - "2023-02-26 20:58:31.240493: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcuda.so.1\n", - "2023-02-26 20:58:31.302402: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1720] Found device 0 with properties: \n", - "pciBusID: 0000:62:00.0 name: Tesla V100-SXM2-32GB computeCapability: 7.0\n", - "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 31.74GiB deviceMemoryBandwidth: 836.37GiB/s\n", - "2023-02-26 20:58:31.302433: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n", - "2023-02-26 20:58:31.313339: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.10\n", - "2023-02-26 20:58:31.313408: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.10\n", - "2023-02-26 20:58:31.313430: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n", - "2023-02-26 20:58:31.313455: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n", - "2023-02-26 20:58:31.315586: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.10\n", - "2023-02-26 20:58:31.316649: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.10\n", - "2023-02-26 20:58:31.320853: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.7\n", - "2023-02-26 20:58:31.321493: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1862] Adding visible gpu devices: 0\n", - "2023-02-26 20:58:31.321921: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: SSE4.1 SSE4.2 AVX AVX2 AVX512F FMA\n", - "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2023-02-26 20:58:31.325102: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n", - "2023-02-26 20:58:31.325502: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1720] Found device 0 with properties: \n", - "pciBusID: 0000:62:00.0 name: Tesla V100-SXM2-32GB computeCapability: 7.0\n", - "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 31.74GiB deviceMemoryBandwidth: 836.37GiB/s\n", - "2023-02-26 20:58:31.325522: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n", - "2023-02-26 20:58:31.325564: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.10\n", - "2023-02-26 20:58:31.325580: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.10\n", - "2023-02-26 20:58:31.325594: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n", - "2023-02-26 20:58:31.325608: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n", - "2023-02-26 20:58:31.325622: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.10\n", - "2023-02-26 20:58:31.325638: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.10\n", - "2023-02-26 20:58:31.325653: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.7\n", - "2023-02-26 20:58:31.326238: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1862] Adding visible gpu devices: 0\n", - "2023-02-26 20:58:31.326268: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n", - "2023-02-26 20:58:31.840293: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1261] Device interconnect StreamExecutor with strength 1 edge matrix:\n", - "2023-02-26 20:58:31.840329: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1267] 0 \n", - "2023-02-26 20:58:31.840339: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1280] 0: N \n", - "2023-02-26 20:58:31.841488: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1406] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 30122 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-32GB, pci bus id: 0000:62:00.0, compute capability: 7.0)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "formatting input data\n", - "generating Mighty Mosaic\n", - "predicting for input data\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/140 [00:00=0.5]=1\n", - "predicted_mask.values[predicted_mask.values<0.5]=0" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1,2,figsize=(15,15))\n", - "axes[0].imshow(np.moveaxis(in_image.values[1:4][::-1]/10000, 0, -1))\n", - "axes[1].imshow(predicted_mask[0])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1,2,figsize=(15,15))\n", - "axes[0].imshow(np.moveaxis(in_image.values[1:4, 50:1000, 1000:2500][::-1]/10000, 0, -1))\n", - "axes[1].imshow(predicted_mask[0, 50:1000, 1000:2500])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:.conda-smallsat]", - "language": "python", - "name": "conda-env-.conda-smallsat-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..e11d24d --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,165 @@ +# Contributing + +When contributing to this repository, please first discuss the change you wish to make via issue, +email, or any other method with the owners of this repository before making a change. + +Please note we have a code of conduct, please follow it in all your interactions with the project. + +## Pull Request Process + +1. Ensure any install or build dependencies are removed before the end of the layer when doing a + build. +2. Update the README.md with details of changes to the interface, this includes new environment + variables, exposed ports, useful file locations and container parameters. +3. Increase the version numbers in any examples files and the README.md to the new version that this + Pull Request would represent. The versioning scheme we use is [SemVer](http://semver.org/). +4. Regenerate any additional documentation using PDOC (usage details listed below). +5. Document the proposed changes in the CHANGELOG.md file. +6. You may submit your merge request for review and the change will be reviewed. + +## Code of Conduct + +### Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +### Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +### Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +### Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +### Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at [INSERT EMAIL ADDRESS]. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +### Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ + +## Appendix + +### Generating Documentation + +This repository follows semi-automatic documentation generation. The following +is an example of how to generate documentation for a single module. + +```bash +conda activate terragpu +pdoc --html terragpu/raster.py --force +``` + +### Linting + +This project uses flake8 for PREP8 linting and format. Every submodule should include +a test section in the tests directory. Refer to the text directory for more examples. +The Python unittests library is used for these purposes. + +### Documenting Methods + +The following documentation format should be followed below each method to allow for +explicit semi-automatic documentation generation. + +```bash + """ + Read raster and append data to existing Raster object + Args: + filename (str): raster filename to read from + bands (str list): list of bands to append to object, e.g ['Red'] + chunks_band (int): integer to map object to memory, z + chunks_x (int): integer to map object to memory, x + chunks_y (int): integer to map object to memory, y + Return: + raster (raster object): raster object to manipulate rasters + ---------- + Example + ---------- + raster.readraster(filename, bands) + """ +``` + +### Format of CHANGELOG + +The following describes the format for each CHANGELOG release. If there are no contributions +in any of the sections, they are removed from the description. + +```bash +## [0.0.3] - 2020-12-14 + +### Added +- Short description + +### Fixed +- Short description + +### Changed +- Short description + +### Removed +- Short description + +### Approved +Approver Name, Email +``` + +### Example Using Container in ADAPT + +```bash +module load singularity +singularity shell -B /att,/lscratch/jacaraba,/lscratch/jacaraba/singularity_tmp:/tmp,/adapt/nobackup/projects/ilab --nv terragpu/ +``` diff --git a/__pycache__/Predictor.cpython-39.pyc b/__pycache__/Predictor.cpython-39.pyc deleted file mode 100644 index b0becae..0000000 Binary files a/__pycache__/Predictor.cpython-39.pyc and /dev/null differ diff --git a/Postprocessing.py b/dl_water_bodies/Postprocessing.py similarity index 100% rename from Postprocessing.py rename to dl_water_bodies/Postprocessing.py diff --git a/Predictor.py b/dl_water_bodies/Predictor.py similarity index 100% rename from Predictor.py rename to dl_water_bodies/Predictor.py diff --git a/UNet_single_class.py b/dl_water_bodies/UNet_single_class.py similarity index 100% rename from UNet_single_class.py rename to dl_water_bodies/UNet_single_class.py diff --git a/analysis/.ipynb_checkpoints/methane-checkpoint.ipynb b/dl_water_bodies/analysis/.ipynb_checkpoints/methane-checkpoint.ipynb similarity index 100% rename from analysis/.ipynb_checkpoints/methane-checkpoint.ipynb rename to dl_water_bodies/analysis/.ipynb_checkpoints/methane-checkpoint.ipynb diff --git a/analysis/.ipynb_checkpoints/methane_vis-checkpoint.ipynb b/dl_water_bodies/analysis/.ipynb_checkpoints/methane_vis-checkpoint.ipynb similarity index 100% rename from analysis/.ipynb_checkpoints/methane_vis-checkpoint.ipynb rename to dl_water_bodies/analysis/.ipynb_checkpoints/methane_vis-checkpoint.ipynb diff --git a/analysis/.ipynb_checkpoints/size_based_ext_prod_comp-checkpoint.ipynb b/dl_water_bodies/analysis/.ipynb_checkpoints/size_based_ext_prod_comp-checkpoint.ipynb similarity index 100% rename from analysis/.ipynb_checkpoints/size_based_ext_prod_comp-checkpoint.ipynb rename to dl_water_bodies/analysis/.ipynb_checkpoints/size_based_ext_prod_comp-checkpoint.ipynb diff --git a/analysis/.ipynb_checkpoints/timeseries_water_bodies-checkpoint.ipynb b/dl_water_bodies/analysis/.ipynb_checkpoints/timeseries_water_bodies-checkpoint.ipynb similarity index 100% rename from analysis/.ipynb_checkpoints/timeseries_water_bodies-checkpoint.ipynb rename to dl_water_bodies/analysis/.ipynb_checkpoints/timeseries_water_bodies-checkpoint.ipynb diff --git a/analysis/data/YKD_wb_tracking.parquet b/dl_water_bodies/analysis/data/YKD_wb_tracking.parquet similarity index 100% rename from analysis/data/YKD_wb_tracking.parquet rename to dl_water_bodies/analysis/data/YKD_wb_tracking.parquet diff --git a/analysis/data/delta_junction_wb_tracking.parquet b/dl_water_bodies/analysis/data/delta_junction_wb_tracking.parquet similarity index 100% rename from analysis/data/delta_junction_wb_tracking.parquet rename to dl_water_bodies/analysis/data/delta_junction_wb_tracking.parquet diff --git a/analysis/data/dj_external_IOUs.parquet b/dl_water_bodies/analysis/data/dj_external_IOUs.parquet similarity index 100% rename from analysis/data/dj_external_IOUs.parquet rename to dl_water_bodies/analysis/data/dj_external_IOUs.parquet diff --git a/analysis/data/fairbanks_wb_tracking.parquet b/dl_water_bodies/analysis/data/fairbanks_wb_tracking.parquet similarity index 100% rename from analysis/data/fairbanks_wb_tracking.parquet rename to dl_water_bodies/analysis/data/fairbanks_wb_tracking.parquet diff --git a/analysis/data/fb_external_IOUs.parquet b/dl_water_bodies/analysis/data/fb_external_IOUs.parquet similarity index 100% rename from analysis/data/fb_external_IOUs.parquet rename to dl_water_bodies/analysis/data/fb_external_IOUs.parquet diff --git a/analysis/data/planet_methane.csv b/dl_water_bodies/analysis/data/planet_methane.csv similarity index 100% rename from analysis/data/planet_methane.csv rename to dl_water_bodies/analysis/data/planet_methane.csv diff --git a/analysis/data/s2_methane.csv b/dl_water_bodies/analysis/data/s2_methane.csv similarity index 100% rename from analysis/data/s2_methane.csv rename to dl_water_bodies/analysis/data/s2_methane.csv diff --git a/analysis/data/yf_external_IOUs.parquet b/dl_water_bodies/analysis/data/yf_external_IOUs.parquet similarity index 100% rename from analysis/data/yf_external_IOUs.parquet rename to dl_water_bodies/analysis/data/yf_external_IOUs.parquet diff --git a/analysis/data/ykd_external_IOUs.parquet b/dl_water_bodies/analysis/data/ykd_external_IOUs.parquet similarity index 100% rename from analysis/data/ykd_external_IOUs.parquet rename to dl_water_bodies/analysis/data/ykd_external_IOUs.parquet diff --git a/analysis/data/yukon_flats_wb_tracking.parquet b/dl_water_bodies/analysis/data/yukon_flats_wb_tracking.parquet similarity index 100% rename from analysis/data/yukon_flats_wb_tracking.parquet rename to dl_water_bodies/analysis/data/yukon_flats_wb_tracking.parquet diff --git a/analysis/methane.ipynb b/dl_water_bodies/analysis/methane.ipynb similarity index 100% rename from analysis/methane.ipynb rename to dl_water_bodies/analysis/methane.ipynb diff --git a/analysis/methane_vis.ipynb b/dl_water_bodies/analysis/methane_vis.ipynb similarity index 100% rename from analysis/methane_vis.ipynb rename to dl_water_bodies/analysis/methane_vis.ipynb diff --git a/analysis/output/.ipynb_checkpoints/methane_ponds-checkpoint.jpg b/dl_water_bodies/analysis/output/.ipynb_checkpoints/methane_ponds-checkpoint.jpg similarity index 100% rename from analysis/output/.ipynb_checkpoints/methane_ponds-checkpoint.jpg rename to dl_water_bodies/analysis/output/.ipynb_checkpoints/methane_ponds-checkpoint.jpg diff --git a/analysis/output/.ipynb_checkpoints/water_body_tracking_2021-checkpoint.jpg b/dl_water_bodies/analysis/output/.ipynb_checkpoints/water_body_tracking_2021-checkpoint.jpg similarity index 100% rename from analysis/output/.ipynb_checkpoints/water_body_tracking_2021-checkpoint.jpg rename to dl_water_bodies/analysis/output/.ipynb_checkpoints/water_body_tracking_2021-checkpoint.jpg diff --git a/analysis/output/methane_ponds.jpg b/dl_water_bodies/analysis/output/methane_ponds.jpg similarity index 100% rename from analysis/output/methane_ponds.jpg rename to dl_water_bodies/analysis/output/methane_ponds.jpg diff --git a/analysis/output/product_ious.jpg b/dl_water_bodies/analysis/output/product_ious.jpg similarity index 100% rename from analysis/output/product_ious.jpg rename to dl_water_bodies/analysis/output/product_ious.jpg diff --git a/analysis/output/water_body_tracking_2021.jpg b/dl_water_bodies/analysis/output/water_body_tracking_2021.jpg similarity index 100% rename from analysis/output/water_body_tracking_2021.jpg rename to dl_water_bodies/analysis/output/water_body_tracking_2021.jpg diff --git a/analysis/size_based_ext_prod_comp.ipynb b/dl_water_bodies/analysis/size_based_ext_prod_comp.ipynb similarity index 100% rename from analysis/size_based_ext_prod_comp.ipynb rename to dl_water_bodies/analysis/size_based_ext_prod_comp.ipynb diff --git a/analysis/timeseries_water_bodies.ipynb b/dl_water_bodies/analysis/timeseries_water_bodies.ipynb similarity index 100% rename from analysis/timeseries_water_bodies.ipynb rename to dl_water_bodies/analysis/timeseries_water_bodies.ipynb diff --git a/gen_composites.py b/dl_water_bodies/gen_composites.py similarity index 100% rename from gen_composites.py rename to dl_water_bodies/gen_composites.py diff --git a/dl_water_bodies/pipelines/composite_pipeline.py b/dl_water_bodies/pipelines/composite_pipeline.py new file mode 100644 index 0000000..d026349 --- /dev/null +++ b/dl_water_bodies/pipelines/composite_pipeline.py @@ -0,0 +1 @@ +# Composite pipeline diff --git a/dl_water_bodies/pipelines/dlwater_pipeline.py b/dl_water_bodies/pipelines/dlwater_pipeline.py new file mode 100644 index 0000000..fb0a971 --- /dev/null +++ b/dl_water_bodies/pipelines/dlwater_pipeline.py @@ -0,0 +1 @@ +# CNN Pipeline diff --git a/utils/.ipynb_checkpoints/gs_utils-checkpoint.py b/dl_water_bodies/utils/.ipynb_checkpoints/gs_utils-checkpoint.py similarity index 100% rename from utils/.ipynb_checkpoints/gs_utils-checkpoint.py rename to dl_water_bodies/utils/.ipynb_checkpoints/gs_utils-checkpoint.py diff --git a/utils/gs_utils.py b/dl_water_bodies/utils/gs_utils.py similarity index 100% rename from utils/gs_utils.py rename to dl_water_bodies/utils/gs_utils.py diff --git a/dl_water_bodies/view/composite_pipeline_cli.py b/dl_water_bodies/view/composite_pipeline_cli.py new file mode 100644 index 0000000..3f213d4 --- /dev/null +++ b/dl_water_bodies/view/composite_pipeline_cli.py @@ -0,0 +1 @@ +# CLI diff --git a/dl_water_bodies/view/dlwater_pipeline_cli.py b/dl_water_bodies/view/dlwater_pipeline_cli.py new file mode 100644 index 0000000..9d1e733 --- /dev/null +++ b/dl_water_bodies/view/dlwater_pipeline_cli.py @@ -0,0 +1 @@ +# CNN CLI diff --git a/prediction_example.ipynb b/examples/prediction_example.ipynb similarity index 100% rename from prediction_example.ipynb rename to examples/prediction_example.ipynb diff --git a/notebooks/.gitkeep b/notebooks/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/requirements/.gitkeep b/requirements/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/tests/.gitkeep b/tests/.gitkeep new file mode 100644 index 0000000..e69de29