├── .gitignore
├── Konza
    └── MDP-burn-analysis.ipynb
├── LICENSE
├── Mobotix_RadTherm
    ├── Ground
    │   ├── All_Data_Plot.ipynb
    │   ├── Mask_Mulch_Area_Data.ipynb
    │   ├── Mobotix_Ground_Temp_ASOS_Comparison.ipynb
    │   ├── Mobotix_Thermal_Image_Subset.ipynb
    │   └── Tree_Mask_Data_Area.ipynb
    └── Sky
    │   ├── CCL_CT_Model_Forecasting_Sounding.ipynb
    │   ├── LCL_Calculation_Plot.ipynb
    │   ├── Mobotix_Thermal_MinTemp.ipynb
    │   └── Sky_Mask_Data_Area.ipynb
├── README.md
├── WiseNet_RadTherm_Camera
    └── Read_And_Scale_From_4030TR.ipynb
├── api_examples
    └── Konza API Example.ipynb
└── lightning
    ├── analyze_lightning_signal.ipynb
    ├── capture_sdr.ipynb
    ├── lightning_env.yaml
    └── rtl-sdr.jpg


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | *.py,cover
 51 | .hypothesis/
 52 | .pytest_cache/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | target/
 76 | 
 77 | # Jupyter Notebook
 78 | .ipynb_checkpoints
 79 | 
 80 | # IPython
 81 | profile_default/
 82 | ipython_config.py
 83 | 
 84 | # pyenv
 85 | .python-version
 86 | 
 87 | # pipenv
 88 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 89 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 90 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 91 | #   install all needed dependencies.
 92 | #Pipfile.lock
 93 | 
 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 95 | __pypackages__/
 96 | 
 97 | # Celery stuff
 98 | celerybeat-schedule
 99 | celerybeat.pid
100 | 
101 | # SageMath parsed files
102 | *.sage.py
103 | 
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 | 
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 | 
117 | # Rope project settings
118 | .ropeproject
119 | 
120 | # mkdocs documentation
121 | /site
122 | 
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 | 
128 | # Pyre type checker
129 | .pyre/
130 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 3-Clause License
 2 | 
 3 | Copyright (c) 2020, Sage Continuum
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | 1. Redistributions of source code must retain the above copyright notice, this
10 |    list of conditions and the following disclaimer.
11 | 
12 | 2. Redistributions in binary form must reproduce the above copyright notice,
13 |    this list of conditions and the following disclaimer in the documentation
14 |    and/or other materials provided with the distribution.
15 | 
16 | 3. Neither the name of the copyright holder nor the names of its
17 |    contributors may be used to endorse or promote products derived from
18 |    this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Ground/Mask_Mulch_Area_Data.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "#Import Mods\n",
 10 |     "import pandas as pd\n",
 11 |     "import numpy as np\n",
 12 |     "\n",
 13 |     "import glob\n",
 14 |     "\n",
 15 |     "import matplotlib.pyplot as plt\n",
 16 |     "\n",
 17 |     "from datetime import datetime\n",
 18 |     "from datetime import timedelta\n",
 19 |     "\n",
 20 |     "import metpy.calc as mpcalc\n",
 21 |     "from metpy.units import units\n",
 22 |     "\n",
 23 |     "from PIL import Image, ImageDraw"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "code",
 28 |    "execution_count": 2,
 29 |    "metadata": {},
 30 |    "outputs": [],
 31 |    "source": [
 32 |     "#Selected files to create the mask.\n",
 33 |     "file = pd.read_csv(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/\"\n",
 34 |     "                \"thermal/1618776148_000001_right_336x252_14bit.thermal.celsius.csv\")"
 35 |    ]
 36 |   },
 37 |   {
 38 |    "cell_type": "code",
 39 |    "execution_count": 3,
 40 |    "metadata": {},
 41 |    "outputs": [],
 42 |    "source": [
 43 |     "#Create image list by unpacking data from CSV and placing in correct spot.\n",
 44 |     "image_array = []\n",
 45 |     "\n",
 46 |     "for i in range(file.size):\n",
 47 |     "    if i >= 6:\n",
 48 |     "        data = file.values[i][0]\n",
 49 |     "        data = data.split(';')\n",
 50 |     "        array = np.array(data)\n",
 51 |     "        array = array.astype(np.float)\n",
 52 |     "        image_array.append(array)\n",
 53 |     "        "
 54 |    ]
 55 |   },
 56 |   {
 57 |    "cell_type": "code",
 58 |    "execution_count": 4,
 59 |    "metadata": {},
 60 |    "outputs": [],
 61 |    "source": [
 62 |     "#Create mask list with threshold value.\n",
 63 |     "mask_col = []\n",
 64 |     "\n",
 65 |     "for j in image_array:\n",
 66 |     "    mask_row = []\n",
 67 |     "    for k in range(len(j)):\n",
 68 |     "        \n",
 69 |     "        if k > 160 and k < 210:\n",
 70 |     "            \n",
 71 |     "            if j[k] > 19.75:\n",
 72 |     "                mask_row.append(1)\n",
 73 |     "            else:\n",
 74 |     "                mask_row.append(0)\n",
 75 |     "                \n",
 76 |     "        else:\n",
 77 |     "            mask_row.append(0)\n",
 78 |     "\n",
 79 |     "    mask_col.append(mask_row)\n",
 80 |     "            "
 81 |    ]
 82 |   },
 83 |   {
 84 |    "cell_type": "code",
 85 |    "execution_count": 5,
 86 |    "metadata": {},
 87 |    "outputs": [],
 88 |    "source": [
 89 |     "#create mask array and a find x-y values of for desired area\n",
 90 |     "mask_array = np.array(mask_col)\n",
 91 |     "x, y = np.nonzero(mask_array)"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "code",
 96 |    "execution_count": 6,
 97 |    "metadata": {},
 98 |    "outputs": [
 99 |     {
100 |      "data": {
101 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVAAAAD8CAAAAAAEKqMkAAAAz0lEQVR4nO3UwQrCMBBF0QT8/1+Oi6pFMDUFYZ56zrZd3BmStAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP9itFGdcKRXB5zwWGRydHLbk1fHst8/BE0RlDK3L7PP7nvMHDEhc+tPZsIwCQ3Htiv9bqv99kP5POUBa5ZPafk85QErFtcZMculOuAjIla5CUpZMfbX8tvSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPghV2UwDwwm6HRaAAAAAElFTkSuQmCC\n",
102 |       "text/plain": [
103 |        "<PIL.Image.Image image mode=L size=336x252 at 0x2B7FC7C43070>"
104 |       ]
105 |      },
106 |      "execution_count": 6,
107 |      "metadata": {},
108 |      "output_type": "execute_result"
109 |     }
110 |    ],
111 |    "source": [
112 |     "#Create image with with mask array\n",
113 |     "#This shape is a rectangle given the top left corner and botttom right corner\n",
114 |     "#shape = [(160, 150), (210, 190)]\n",
115 |     "\n",
116 |     "#Tranform list into array and convert all true values from 1 to 255 as well as use an unsigned 8-bit integer dtype.\n",
117 |     "array = np.array(mask_col).astype('uint8')*255\n",
118 |     "\n",
119 |     "#create image\n",
120 |     "im = Image.fromarray(array)\n",
121 |     "\n",
122 |     "#img1 = ImageDraw.Draw(im)\n",
123 |     "#img1.rectangle(shape, fill = 12 , outline =\"red\")\n",
124 |     "#im.save('Mulch_Mask.png')\n",
125 |     "im"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": 7,
131 |    "metadata": {},
132 |    "outputs": [],
133 |    "source": [
134 |     "#Grab files from directory and sort them into correct order\n",
135 |     "files = []\n",
136 |     "for filename in glob.glob(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/thermal/\"\n",
137 |     "                          \"*.thermal.celsius.csv\"):\n",
138 |     "    files.append(filename)\n",
139 |     "files.sort()"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "code",
144 |    "execution_count": 8,
145 |    "metadata": {},
146 |    "outputs": [],
147 |    "source": [
148 |     "#Run through all images and save off average temperature for each\n",
149 |     "temp_avg = []\n",
150 |     "temp_med = []\n",
151 |     "image_time = []\n",
152 |     "\n",
153 |     "\n",
154 |     "for path in files:\n",
155 |     "    file = pd.read_csv(path)\n",
156 |     "    image_time.append(datetime.fromtimestamp(int(path[86:96])) + timedelta(hours = 5))\n",
157 |     "    image_array = []\n",
158 |     "    mask_image = []\n",
159 |     "    \n",
160 |     "    \n",
161 |     "    for i in range(file.size):\n",
162 |     "        if i >= 6:\n",
163 |     "            data = file.values[i][0]\n",
164 |     "            data = data.split(';')\n",
165 |     "            array = np.array(data)\n",
166 |     "            array = array.astype(np.float)\n",
167 |     "            image_array.append(array)\n",
168 |     "            \n",
169 |     "    image_array = np.array(image_array)\n",
170 |     "    \n",
171 |     "    temp_avg.append(np.mean(image_array[x, y]))\n",
172 |     "    temp_med.append(np.median(image_array[x, y]))"
173 |    ]
174 |   },
175 |   {
176 |    "cell_type": "code",
177 |    "execution_count": 9,
178 |    "metadata": {},
179 |    "outputs": [],
180 |    "source": [
181 |     "#Convert units from Celsius to Fahrenheit\n",
182 |     "temp_avgc = temp_avg * units.celsius\n",
183 |     "temp_medc = temp_med * units.celsius\n",
184 |     "\n",
185 |     "temp_avgf = temp_avgc.to(units.fahrenheit)\n",
186 |     "temp_medf = temp_medc.to(units.fahrenheit)"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "code",
191 |    "execution_count": 10,
192 |    "metadata": {},
193 |    "outputs": [
194 |     {
195 |      "data": {
196 |       "text/plain": [
197 |        "Text(0.5, 1.0, 'Mulch Area Average Temperature Measurement ')"
198 |       ]
199 |      },
200 |      "execution_count": 10,
201 |      "metadata": {},
202 |      "output_type": "execute_result"
203 |     },
204 |     {
205 |      "data": {
206 |       "image/png": "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\n",
207 |       "text/plain": [
208 |        "<Figure size 432x288 with 1 Axes>"
209 |       ]
210 |      },
211 |      "metadata": {
212 |       "needs_background": "light"
213 |      },
214 |      "output_type": "display_data"
215 |     }
216 |    ],
217 |    "source": [
218 |     "#Create plot\n",
219 |     "plt.plot(image_time, temp_avgf, color = 'blue')\n",
220 |     "\n",
221 |     "plt.xlabel('Time (UTC)')\n",
222 |     "#image_time = np.array(image_time)\n",
223 |     "plt.xticks((image_time[11], image_time[344], image_time[796], image_time[1212], image_time[1523]))\n",
224 |     "plt.ylabel('Temperature (F)')\n",
225 |     "\n",
226 |     "plt.title('Mulch Area Average Temperature Measurement ')\n"
227 |    ]
228 |   },
229 |   {
230 |    "cell_type": "code",
231 |    "execution_count": null,
232 |    "metadata": {},
233 |    "outputs": [],
234 |    "source": []
235 |   },
236 |   {
237 |    "cell_type": "code",
238 |    "execution_count": null,
239 |    "metadata": {},
240 |    "outputs": [],
241 |    "source": []
242 |   }
243 |  ],
244 |  "metadata": {
245 |   "kernelspec": {
246 |    "display_name": "Python 3",
247 |    "language": "python",
248 |    "name": "python3"
249 |   },
250 |   "language_info": {
251 |    "codemirror_mode": {
252 |     "name": "ipython",
253 |     "version": 3
254 |    },
255 |    "file_extension": ".py",
256 |    "mimetype": "text/x-python",
257 |    "name": "python",
258 |    "nbconvert_exporter": "python",
259 |    "pygments_lexer": "ipython3",
260 |    "version": "3.8.5"
261 |   }
262 |  },
263 |  "nbformat": 4,
264 |  "nbformat_minor": 4
265 | }
266 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Ground/Mobotix_Ground_Temp_ASOS_Comparison.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "#Import Mods\n",
 10 |     "import pandas as pd\n",
 11 |     "import numpy as np\n",
 12 |     "\n",
 13 |     "import glob\n",
 14 |     "\n",
 15 |     "import matplotlib.pyplot as plt\n",
 16 |     "\n",
 17 |     "import act\n",
 18 |     "import metpy.calc as mpcalc\n",
 19 |     "from metpy.units import units\n",
 20 |     "\n",
 21 |     "from datetime import datetime\n",
 22 |     "from datetime import timedelta"
 23 |    ]
 24 |   },
 25 |   {
 26 |    "cell_type": "code",
 27 |    "execution_count": 2,
 28 |    "metadata": {},
 29 |    "outputs": [
 30 |     {
 31 |      "name": "stdout",
 32 |      "output_type": "stream",
 33 |      "text": [
 34 |       "Downloading: LOT\n"
 35 |      ]
 36 |     }
 37 |    ],
 38 |    "source": [
 39 |     "#Grab ASOS data from nearest station.\n",
 40 |     "time_window = [datetime(2021, 4, 16, 0, 0), datetime(2021, 4, 24, 3, 0)]\n",
 41 |     "my_asoses = act.discovery.get_asos(time_window, station = 'LOT')\n",
 42 |     "station = my_asoses['LOT']"
 43 |    ]
 44 |   },
 45 |   {
 46 |    "cell_type": "code",
 47 |    "execution_count": 3,
 48 |    "metadata": {},
 49 |    "outputs": [],
 50 |    "source": [
 51 |     "#Save off data that be used later\n",
 52 |     "tempsf = station.tmpf.values\n",
 53 |     "dewpsf = station.dwpf.values\n",
 54 |     "time = station.time.values\n"
 55 |    ]
 56 |   },
 57 |   {
 58 |    "cell_type": "code",
 59 |    "execution_count": 4,
 60 |    "metadata": {},
 61 |    "outputs": [],
 62 |    "source": [
 63 |     "#Grab files from directory and sort them into correct order\n",
 64 |     "files = []\n",
 65 |     "for filename in glob.glob(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/thermal/\"\n",
 66 |     "                          \"*.thermal.celsius.csv\"):\n",
 67 |     "    files.append(filename)\n",
 68 |     "files.sort()"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": 6,
 74 |    "metadata": {},
 75 |    "outputs": [],
 76 |    "source": [
 77 |     "#Grab mask CSVs and prepare them for use\n",
 78 |     "area1 = pd.read_csv(\"/gpfs/fs1/home/ac.jcorner/Thermal/Masks/Ground_Area1_Mask.csv\")\n",
 79 |     "area2 = pd.read_csv(\"/gpfs/fs1/home/ac.jcorner/Thermal/Masks/Ground_Area2_Mask.csv\")\n",
 80 |     "\n",
 81 |     "mask_array1 = np.array(area1)\n",
 82 |     "x1, y1 = np.nonzero(mask_array1)\n",
 83 |     "\n",
 84 |     "mask_array2 = np.array(area2)\n",
 85 |     "x2, y2 = np.nonzero(mask_array2)\n"
 86 |    ]
 87 |   },
 88 |   {
 89 |    "cell_type": "code",
 90 |    "execution_count": 7,
 91 |    "metadata": {},
 92 |    "outputs": [],
 93 |    "source": [
 94 |     "#Run through all images and save off average temperature for each\n",
 95 |     "temp_avg1 = []\n",
 96 |     "temp_avg2 = []\n",
 97 |     "image_count = []\n",
 98 |     "image_time = []\n",
 99 |     "\n",
100 |     "\n",
101 |     "for path in files:\n",
102 |     "    file = pd.read_csv(path)\n",
103 |     "    image_time.append(datetime.fromtimestamp(int(path[86:96])) + timedelta(hours = 5))\n",
104 |     "    image_array = []\n",
105 |     "    \n",
106 |     "    \n",
107 |     "    for i in range(file.size):\n",
108 |     "        if i >= 6:\n",
109 |     "            data = file.values[i][0]\n",
110 |     "            data = data.split(';')\n",
111 |     "            array = np.array(data)\n",
112 |     "            array = array.astype(np.float)\n",
113 |     "            image_array.append(array)\n",
114 |     "            \n",
115 |     "    image_array = np.array(image_array)\n",
116 |     "    \n",
117 |     "    temp_avg1.append(np.mean(image_array[x1, y1]))\n",
118 |     "    temp_avg2.append(np.mean(image_array[x2, y2]))"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "code",
123 |    "execution_count": 8,
124 |    "metadata": {},
125 |    "outputs": [],
126 |    "source": [
127 |     "#Convert units from Celsius to Fahrenheit\n",
128 |     "temp_avgc1 = temp_avg1 * units.celsius\n",
129 |     "temp_avgf1 = temp_avgc1.to(units.fahrenheit)\n",
130 |     "\n",
131 |     "temp_avgc2 = temp_avg2 * units.celsius\n",
132 |     "temp_avgf2 = temp_avgc2.to(units.fahrenheit)"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "code",
137 |    "execution_count": 9,
138 |    "metadata": {},
139 |    "outputs": [
140 |     {
141 |      "data": {
142 |       "text/plain": [
143 |        "<matplotlib.legend.Legend at 0x2aeafa6f64c0>"
144 |       ]
145 |      },
146 |      "execution_count": 9,
147 |      "metadata": {},
148 |      "output_type": "execute_result"
149 |     },
150 |     {
151 |      "data": {
152 |       "image/png": "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\n",
153 |       "text/plain": [
154 |        "<Figure size 432x288 with 1 Axes>"
155 |       ]
156 |      },
157 |      "metadata": {
158 |       "needs_background": "light"
159 |      },
160 |      "output_type": "display_data"
161 |     }
162 |    ],
163 |    "source": [
164 |     "#Plot time series\n",
165 |     "plt.plot(image_time, temp_avgf1, color = 'Red')\n",
166 |     "plt.plot(image_time, temp_avgf2, color = 'Blue')\n",
167 |     "plt.plot(time, tempsf, color='Black')\n",
168 |     "\n",
169 |     "plt.xlabel('Time (UTC)')\n",
170 |     "plt.xticks(time[np.arange(0, len(time), 144)])\n",
171 |     "plt.ylabel('Temperature (F)')\n",
172 |     "\n",
173 |     "plt.title('Thermal Camera Ground Temperature Comparison with KLOT ASOS')\n",
174 |     "\n",
175 |     "# Create a custom legend\n",
176 |     "plt.legend(['Area 1', 'Area 2', 'KLOT'], loc = 'upper center')\n",
177 |     "\n",
178 |     "\n",
179 |     "#plt.savefig('Thermal_ASOS_Comparison_Ground.png', transparent='true')"
180 |    ]
181 |   },
182 |   {
183 |    "cell_type": "code",
184 |    "execution_count": null,
185 |    "metadata": {},
186 |    "outputs": [],
187 |    "source": []
188 |   },
189 |   {
190 |    "cell_type": "code",
191 |    "execution_count": null,
192 |    "metadata": {},
193 |    "outputs": [],
194 |    "source": []
195 |   }
196 |  ],
197 |  "metadata": {
198 |   "kernelspec": {
199 |    "display_name": "Python 3",
200 |    "language": "python",
201 |    "name": "python3"
202 |   },
203 |   "language_info": {
204 |    "codemirror_mode": {
205 |     "name": "ipython",
206 |     "version": 3
207 |    },
208 |    "file_extension": ".py",
209 |    "mimetype": "text/x-python",
210 |    "name": "python",
211 |    "nbconvert_exporter": "python",
212 |    "pygments_lexer": "ipython3",
213 |    "version": "3.8.5"
214 |   }
215 |  },
216 |  "nbformat": 4,
217 |  "nbformat_minor": 4
218 | }
219 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Ground/Mobotix_Thermal_Image_Subset.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "#Import Mods\n",
 10 |     "import pandas as pd\n",
 11 |     "import numpy as np\n",
 12 |     "\n",
 13 |     "import glob\n",
 14 |     "\n",
 15 |     "import matplotlib.pyplot as plt\n",
 16 |     "\n",
 17 |     "from datetime import datetime\n",
 18 |     "from datetime import timedelta\n",
 19 |     "\n",
 20 |     "from PIL import Image, ImageDraw"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 2,
 26 |    "metadata": {},
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "#Grab image to create mask\n",
 30 |     "file = pd.read_csv(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/\"\n",
 31 |     "                \"thermal/1618803166_000001_right_336x252_14bit.thermal.celsius.csv\")"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 3,
 37 |    "metadata": {},
 38 |    "outputs": [],
 39 |    "source": [
 40 |     "#Create image list by unpacking data from CSV and placing in correct spot.\n",
 41 |     "image_array = []\n",
 42 |     "\n",
 43 |     "for i in range(file.size):\n",
 44 |     "    if i >= 6:\n",
 45 |     "        data = file.values[i][0]\n",
 46 |     "        data = data.split(';')\n",
 47 |     "        array = np.array(data)\n",
 48 |     "        array = array.astype(np.float)\n",
 49 |     "        image_array.append(array)\n",
 50 |     "        "
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 5,
 56 |    "metadata": {},
 57 |    "outputs": [],
 58 |    "source": [
 59 |     "#Create mask list with threshold value.\n",
 60 |     "mask_col = []\n",
 61 |     "count = 0\n",
 62 |     "\n",
 63 |     "for j in image_array:\n",
 64 |     "    mask_row = []\n",
 65 |     "    \n",
 66 |     "    for k in range(len(j)):\n",
 67 |     "        \n",
 68 |     "        if k > 160 and k < 200:\n",
 69 |     "        \n",
 70 |     "            if count > 210 and count < 245:\n",
 71 |     "                if j[k] < 2:\n",
 72 |     "                    mask_row.append(1)\n",
 73 |     "                else:\n",
 74 |     "                    mask_row.append(0)\n",
 75 |     "\n",
 76 |     "            else:\n",
 77 |     "                 mask_row.append(0)\n",
 78 |     "        else:\n",
 79 |     "             mask_row.append(0)\n",
 80 |     "                \n",
 81 |     "    mask_col.append(mask_row)\n",
 82 |     "    count = count + 1"
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "code",
 87 |    "execution_count": 6,
 88 |    "metadata": {},
 89 |    "outputs": [],
 90 |    "source": [
 91 |     "#create mask array and a find x-y values of for desired area\n",
 92 |     "mask_array = np.array(mask_col)\n",
 93 |     "x, y = np.nonzero(mask_array)"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 7,
 99 |    "metadata": {},
100 |    "outputs": [
101 |     {
102 |      "data": {
103 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVAAAAD8CAAAAAAEKqMkAAAAuklEQVR4nO3QwQ2AMAwEwUD/PYcS4LGSIzTz9uO8awEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe7pge82t/OTnnknh7wN4LGBI0JGhM0JmhM0JigMUFjgsYEjQkaEzQmaEzQmKAxQWOCxgSNCRoTNCZoTNCYoDFBY4LGBI0JGhM0JmhM0JigMUEBAJjwAAFvAURiY1u1AAAAAElFTkSuQmCC\n",
104 |       "text/plain": [
105 |        "<PIL.Image.Image image mode=L size=336x252 at 0x2ACF24581EB0>"
106 |       ]
107 |      },
108 |      "execution_count": 7,
109 |      "metadata": {},
110 |      "output_type": "execute_result"
111 |     }
112 |    ],
113 |    "source": [
114 |     "#Create image with with mask array\n",
115 |     "#This shape is a rectangle given the top left corner and botttom right corner\n",
116 |     "shape1 = [(10, 150), (70, 190)]\n",
117 |     "\n",
118 |     "shape2 = [(160, 210), (200, 245)]\n",
119 |     "\n",
120 |     "#Tranform list into array and convert all true values from 1 to 255 as well as use an unsigned 8-bit integer dtype.\n",
121 |     "array = np.array(mask_col).astype('uint8')*255\n",
122 |     "\n",
123 |     "#create image\n",
124 |     "im = Image.fromarray(array)\n",
125 |     "\n",
126 |     "#img1 = ImageDraw.Draw(im)\n",
127 |     "#img1.rectangle(shape2, fill = 150 , outline =\"red\")\n",
128 |     "#im.save('Mulch_Mask.png')\n",
129 |     "im"
130 |    ]
131 |   },
132 |   {
133 |    "cell_type": "code",
134 |    "execution_count": 8,
135 |    "metadata": {},
136 |    "outputs": [],
137 |    "source": [
138 |     "#Convert mask into a CSV so as to be used else where.\n",
139 |     "#np.savetxt(\"Ground_Area2_Mask.csv\", mask_array, delimiter = \",\")"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "code",
144 |    "execution_count": null,
145 |    "metadata": {},
146 |    "outputs": [],
147 |    "source": []
148 |   }
149 |  ],
150 |  "metadata": {
151 |   "kernelspec": {
152 |    "display_name": "Python 3",
153 |    "language": "python",
154 |    "name": "python3"
155 |   },
156 |   "language_info": {
157 |    "codemirror_mode": {
158 |     "name": "ipython",
159 |     "version": 3
160 |    },
161 |    "file_extension": ".py",
162 |    "mimetype": "text/x-python",
163 |    "name": "python",
164 |    "nbconvert_exporter": "python",
165 |    "pygments_lexer": "ipython3",
166 |    "version": "3.8.5"
167 |   }
168 |  },
169 |  "nbformat": 4,
170 |  "nbformat_minor": 4
171 | }
172 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Ground/Tree_Mask_Data_Area.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "#Import Mods\n",
 10 |     "import pandas as pd\n",
 11 |     "import numpy as np\n",
 12 |     "\n",
 13 |     "import glob\n",
 14 |     "\n",
 15 |     "import matplotlib.pyplot as plt\n",
 16 |     "\n",
 17 |     "import act\n",
 18 |     "import metpy.calc as mpcalc\n",
 19 |     "from metpy.units import units\n",
 20 |     "\n",
 21 |     "from datetime import datetime\n",
 22 |     "from datetime import timedelta\n",
 23 |     "\n",
 24 |     "from PIL import Image, ImageDraw"
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "code",
 29 |    "execution_count": 2,
 30 |    "metadata": {},
 31 |    "outputs": [],
 32 |    "source": [
 33 |     "#grab sinlge image used to create the mask\n",
 34 |     "file = pd.read_csv(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/\"\n",
 35 |     "                \"thermal/1618803166_000001_right_336x252_14bit.thermal.celsius.csv\")"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "code",
 40 |    "execution_count": 3,
 41 |    "metadata": {},
 42 |    "outputs": [],
 43 |    "source": [
 44 |     "#Create image list by unpacking data from CSV and placing in correct spot.\n",
 45 |     "image_array = []\n",
 46 |     "\n",
 47 |     "for i in range(file.size):\n",
 48 |     "    if i >= 6:\n",
 49 |     "        data = file.values[i][0]\n",
 50 |     "        data = data.split(';')\n",
 51 |     "        array = np.array(data)\n",
 52 |     "        array = array.astype(np.float)\n",
 53 |     "        image_array.append(array)\n",
 54 |     "        "
 55 |    ]
 56 |   },
 57 |   {
 58 |    "cell_type": "code",
 59 |    "execution_count": 4,
 60 |    "metadata": {},
 61 |    "outputs": [],
 62 |    "source": [
 63 |     "#Create first mask list with threshold value.\n",
 64 |     "mask_col1 = []\n",
 65 |     "count = 0\n",
 66 |     "\n",
 67 |     "for j in image_array:\n",
 68 |     "    mask_row = []\n",
 69 |     "    \n",
 70 |     "    for k in range(len(j)):\n",
 71 |     "        \n",
 72 |     "        if k > 40 and k < 110:\n",
 73 |     "        \n",
 74 |     "            if count > 40 and count < 90:\n",
 75 |     "                if j[k] > 7:\n",
 76 |     "                    mask_row.append(1)\n",
 77 |     "                else:\n",
 78 |     "                    mask_row.append(0)\n",
 79 |     "\n",
 80 |     "            else:\n",
 81 |     "                 mask_row.append(0)\n",
 82 |     "        else:\n",
 83 |     "             mask_row.append(0)\n",
 84 |     "                \n",
 85 |     "    mask_col1.append(mask_row)\n",
 86 |     "    count = count + 1"
 87 |    ]
 88 |   },
 89 |   {
 90 |    "cell_type": "code",
 91 |    "execution_count": 5,
 92 |    "metadata": {},
 93 |    "outputs": [],
 94 |    "source": [
 95 |     "#Create second mask list with threshold value.\n",
 96 |     "mask_col2 = []\n",
 97 |     "count = 0\n",
 98 |     "\n",
 99 |     "for j in image_array:\n",
100 |     "    mask_row = []\n",
101 |     "    \n",
102 |     "    for k in range(len(j)):\n",
103 |     "        \n",
104 |     "        if k > 250 and k < 300:\n",
105 |     "        \n",
106 |     "            if count > 50 and count < 100:\n",
107 |     "                if j[k] > 5:\n",
108 |     "                    mask_row.append(1)\n",
109 |     "                else:\n",
110 |     "                    mask_row.append(0)\n",
111 |     "\n",
112 |     "            else:\n",
113 |     "                 mask_row.append(0)\n",
114 |     "        else:\n",
115 |     "             mask_row.append(0)\n",
116 |     "                \n",
117 |     "    mask_col2.append(mask_row)\n",
118 |     "    count = count + 1"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "code",
123 |    "execution_count": 6,
124 |    "metadata": {},
125 |    "outputs": [],
126 |    "source": [
127 |     "#create mask array and a find x-y values of for desired area\n",
128 |     "mask_array1 = np.array(mask_col1)\n",
129 |     "x1, y1 = np.nonzero(mask_array1)\n",
130 |     "\n",
131 |     "\n",
132 |     "mask_array2 = np.array(mask_col2)\n",
133 |     "x2, y2 = np.nonzero(mask_array2)"
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "code",
138 |    "execution_count": 7,
139 |    "metadata": {},
140 |    "outputs": [
141 |     {
142 |      "data": {
143 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVAAAAD8CAAAAAAEKqMkAAAA1ElEQVR4nO3QwQmAMAAEwWj/PScdiMpCRGb+B8eOAQAAAAAAAAAAAAAAAAAAAACfduw+sNF8OrgT63xxhAuCxgSNCRoTNCZoTNCYoDFBY4LGBI0JGhM0JmhM0JigMUFjgsYEjQkaEzQmaEzQmKAxQWOCxgSNCRoTNCZoTNCYoDFBY4LGBI0JGhM0JmhM0JigMUFjgsYEjQkaEzQmaEzQmKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8GMLJwMBYu6z6KYAAAAASUVORK5CYII=\n",
144 |       "text/plain": [
145 |        "<PIL.Image.Image image mode=L size=336x252 at 0x2B73E94431F0>"
146 |       ]
147 |      },
148 |      "execution_count": 7,
149 |      "metadata": {},
150 |      "output_type": "execute_result"
151 |     }
152 |    ],
153 |    "source": [
154 |     "#Create image with with mask array\n",
155 |     "#This shape is a rectangle given the top left corner and botttom right corner\n",
156 |     "#shape1 = [(40, 40), (110, 90)]\n",
157 |     "\n",
158 |     "shape2 = [(250, 50), (300, 100)]\n",
159 |     "\n",
160 |     "#Tranform list into array and convert all true values from 1 to 255 as well as use an unsigned 8-bit integer dtype.\n",
161 |     "array = np.array(mask_col2).astype('uint8')*255\n",
162 |     "\n",
163 |     "#create image\n",
164 |     "im = Image.fromarray(array)\n",
165 |     "\n",
166 |     "#img1 = ImageDraw.Draw(im)\n",
167 |     "#img1.rectangle(shape2, fill = 150 , outline =\"red\")\n",
168 |     "im"
169 |    ]
170 |   },
171 |   {
172 |    "cell_type": "code",
173 |    "execution_count": 8,
174 |    "metadata": {},
175 |    "outputs": [
176 |     {
177 |      "name": "stdout",
178 |      "output_type": "stream",
179 |      "text": [
180 |       "Downloading: LOT\n"
181 |      ]
182 |     }
183 |    ],
184 |    "source": [
185 |     "#Grab ASOS data from nearest station.\n",
186 |     "time_window = [datetime(2021, 4, 16, 0, 0), datetime(2021, 4, 24, 3, 0)]\n",
187 |     "my_asoses = act.discovery.get_asos(time_window, station = 'LOT')\n",
188 |     "station = my_asoses['LOT']"
189 |    ]
190 |   },
191 |   {
192 |    "cell_type": "code",
193 |    "execution_count": 9,
194 |    "metadata": {},
195 |    "outputs": [],
196 |    "source": [
197 |     "#Save off data that be used later\n",
198 |     "tempsf = station.tmpf.values\n",
199 |     "dewpsf = station.dwpf.values\n",
200 |     "time = station.time.values"
201 |    ]
202 |   },
203 |   {
204 |    "cell_type": "code",
205 |    "execution_count": 10,
206 |    "metadata": {},
207 |    "outputs": [],
208 |    "source": [
209 |     "#Grab files from directory and sort them into correct order\n",
210 |     "files = []\n",
211 |     "for filename in glob.glob(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/thermal/\"\n",
212 |     "                          \"*.thermal.celsius.csv\"):\n",
213 |     "    files.append(filename)\n",
214 |     "files.sort()"
215 |    ]
216 |   },
217 |   {
218 |    "cell_type": "code",
219 |    "execution_count": 11,
220 |    "metadata": {},
221 |    "outputs": [],
222 |    "source": [
223 |     "#Run through all images and save off average temperature for each\n",
224 |     "temp_avg1 = []\n",
225 |     "temp_avg2 = []\n",
226 |     "image_count = []\n",
227 |     "image_time = []\n",
228 |     "\n",
229 |     "\n",
230 |     "for path in files:\n",
231 |     "    file = pd.read_csv(path)\n",
232 |     "    image_time.append(datetime.fromtimestamp(int(path[86:96])) + timedelta(hours = 5))\n",
233 |     "    image_array = []\n",
234 |     "    \n",
235 |     "    \n",
236 |     "    for i in range(file.size):\n",
237 |     "        if i >= 6:\n",
238 |     "            data = file.values[i][0]\n",
239 |     "            data = data.split(';')\n",
240 |     "            array = np.array(data)\n",
241 |     "            array = array.astype(np.float)\n",
242 |     "            image_array.append(array)\n",
243 |     "            \n",
244 |     "    image_array = np.array(image_array)\n",
245 |     "    \n",
246 |     "    temp_avg1.append(np.mean(image_array[x1, y1]))\n",
247 |     "    temp_avg2.append(np.mean(image_array[x2, y2]))"
248 |    ]
249 |   },
250 |   {
251 |    "cell_type": "code",
252 |    "execution_count": 12,
253 |    "metadata": {},
254 |    "outputs": [],
255 |    "source": [
256 |     "#Convert units from Celsius to Fahrenheit\n",
257 |     "temp_avgc1 = temp_avg1 * units.celsius\n",
258 |     "temp_avgf1 = temp_avgc1.to(units.fahrenheit)\n",
259 |     "\n",
260 |     "temp_avgc2 = temp_avg2 * units.celsius\n",
261 |     "temp_avgf2 = temp_avgc2.to(units.fahrenheit)"
262 |    ]
263 |   },
264 |   {
265 |    "cell_type": "code",
266 |    "execution_count": 13,
267 |    "metadata": {},
268 |    "outputs": [
269 |     {
270 |      "data": {
271 |       "text/plain": [
272 |        "<matplotlib.legend.Legend at 0x2b73e9b83370>"
273 |       ]
274 |      },
275 |      "execution_count": 13,
276 |      "metadata": {},
277 |      "output_type": "execute_result"
278 |     },
279 |     {
280 |      "data": {
281 |       "image/png": "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\n",
282 |       "text/plain": [
283 |        "<Figure size 432x288 with 1 Axes>"
284 |       ]
285 |      },
286 |      "metadata": {
287 |       "needs_background": "light"
288 |      },
289 |      "output_type": "display_data"
290 |     }
291 |    ],
292 |    "source": [
293 |     "#Plot time series\n",
294 |     "plt.plot(image_time, temp_avgf1, color = 'red')\n",
295 |     "#plt.plot(image_time, temp_avgf2, color = 'blue')\n",
296 |     "plt.plot(time, tempsf, color='black')\n",
297 |     "\n",
298 |     "plt.xlabel('Time (UTC)')\n",
299 |     "plt.xticks(time[np.arange(0, len(time), 144)])\n",
300 |     "plt.ylabel('Temperature (F)')\n",
301 |     "\n",
302 |     "plt.title('Thermal Camera Tree Temperature Comparison with KLOT ASOS')\n",
303 |     "\n",
304 |     "# Create a custom legend\n",
305 |     "plt.legend(['Area 1', 'KLOT'], loc = 'upper center')\n",
306 |     "\n",
307 |     "\n",
308 |     "#plt.savefig('Thermal_ASOS_Comparison_tree.png', transparent='true')"
309 |    ]
310 |   },
311 |   {
312 |    "cell_type": "code",
313 |    "execution_count": null,
314 |    "metadata": {},
315 |    "outputs": [],
316 |    "source": []
317 |   }
318 |  ],
319 |  "metadata": {
320 |   "kernelspec": {
321 |    "display_name": "Python 3",
322 |    "language": "python",
323 |    "name": "python3"
324 |   },
325 |   "language_info": {
326 |    "codemirror_mode": {
327 |     "name": "ipython",
328 |     "version": 3
329 |    },
330 |    "file_extension": ".py",
331 |    "mimetype": "text/x-python",
332 |    "name": "python",
333 |    "nbconvert_exporter": "python",
334 |    "pygments_lexer": "ipython3",
335 |    "version": "3.8.5"
336 |   }
337 |  },
338 |  "nbformat": 4,
339 |  "nbformat_minor": 4
340 | }
341 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Sky/LCL_Calculation_Plot.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import pandas as pd\n",
 10 |     "import numpy as np\n",
 11 |     "\n",
 12 |     "import matplotlib.pyplot as plt\n",
 13 |     "\n",
 14 |     "import act\n",
 15 |     "import metpy.calc as mpcalc\n",
 16 |     "from metpy.units import units\n",
 17 |     "\n",
 18 |     "from datetime import datetime\n",
 19 |     "from datetime import timedelta"
 20 |    ]
 21 |   },
 22 |   {
 23 |    "cell_type": "code",
 24 |    "execution_count": 2,
 25 |    "metadata": {},
 26 |    "outputs": [
 27 |     {
 28 |      "name": "stdout",
 29 |      "output_type": "stream",
 30 |      "text": [
 31 |       "Downloading: LOT\n"
 32 |      ]
 33 |     }
 34 |    ],
 35 |    "source": [
 36 |     "#Data grab section for KLOT ASOS\n",
 37 |     "#Grab ASOS data from nearest station.\n",
 38 |     "time_window = [datetime(2021, 4, 16, 0, 0), datetime(2021, 4, 24, 3, 0)]\n",
 39 |     "my_asoses = act.discovery.get_asos(time_window, station = 'LOT')\n",
 40 |     "station = my_asoses['LOT']"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "code",
 45 |    "execution_count": 3,
 46 |    "metadata": {},
 47 |    "outputs": [],
 48 |    "source": [
 49 |     "#Save off data that be used later\n",
 50 |     "tempsf = station.tmpf.values * units.celsius\n",
 51 |     "dewpsf = station.dwpf.values * units.celsius\n",
 52 |     "press = station.alti.values * units.in_Hg\n",
 53 |     "press = press.to(units.hectopascal)\n",
 54 |     "time = station.time.values"
 55 |    ]
 56 |   },
 57 |   {
 58 |    "cell_type": "code",
 59 |    "execution_count": null,
 60 |    "metadata": {},
 61 |    "outputs": [],
 62 |    "source": []
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": 4,
 67 |    "metadata": {},
 68 |    "outputs": [],
 69 |    "source": [
 70 |     "#Use MetPy to Calculate the LCL\n",
 71 |     "LCL_press, LCL_temp = mpcalc.lcl(press, tempsf, dewpsf)"
 72 |    ]
 73 |   },
 74 |   {
 75 |    "cell_type": "code",
 76 |    "execution_count": 5,
 77 |    "metadata": {
 78 |     "scrolled": false
 79 |    },
 80 |    "outputs": [
 81 |     {
 82 |      "name": "stdout",
 83 |      "output_type": "stream",
 84 |      "text": [
 85 |       "[809.1545467149045 871.3089354986157 883.4274700913064 884.8326351775819 885.1273828908325 892.6560250865919 896.2692275820125 896.3190386157728 893.7900691833247 902.2424791445695 902.5428261749104 913.6271493021699 930.4263301516083 935.6588123316761 951.9932189122898 957.4846932284007 950.71257059139 954.4393038913006 951.6764158444325 951.6764158444325 960.7605323892872 966.2447643818541 963.3046574293903 957.8494681474481 953.7500073004629 958.8417137972624 958.8169968483113 957.4166196114982 962.4555185497891 965.1585197932011 970.9831672312026 977.5040239449061 970.6793401570671 970.8940115262646 970.9337088695421 959.950080924893 978.0722941558676 945.9513132715326 940.8010608381387 926.6278461153729 910.1362670155637 900.1706505576672 885.4176944405817 874.8586608692855 863.9726813568249 866.1620599211648 855.7767077787676 840.323717467722 836.7798950730305 786.2410512505066 776.3054380549622 776.358442924037 779.6952144365563 778.6588083809444 767.9278441799052 767.0897795647275 772.3730788561193 763.5787091340466 770.2885943267441 764.9640396389616 764.8001024384824 744.7331164050163 753.1990629883826 739.5939791487173 798.2903909454407 816.7825285855068 793.7987931333251 803.5345299396018 826.6849115014534 831.1685698118791 837.6716234906771 840.7031486879149 856.9266137376078 880.9598934603341 908.3172071880845 914.5768965860663 923.379760888029 937.9730481904726 946.1314944535623 960.7965258936155 967.5491880407573 967.4773312434835 977.0614469479565 973.9179617055936 985.0143571390981 976.3348559181203 980.4628406747735 985.9575187857063 988.4936674508456 981.5557959344693 980.1355833848286 975.9504901340187 988.5220338237211 982.9486314202204 988.5559357516494 981.5700857334712 981.8978219891418 984.6987695209845 985.7416954698185 985.6726548229743 982.8867630862085 986.7286466349738 982.5309675773785 988.163619481747 985.3687107982697 981.5199794413656 983.2768279582568 981.8835274189215 980.5298676670205 979.5159990717328 973.9979065760069 965.8248415375255 964.5314556103463 955.101811572796 947.1534712605844 938.0052920285837 923.7636968517947 917.4798224695124 902.0703342745941 892.5087819767607 875.6981173905746 858.9131435404232 847.428694863764 843.0851200383037 828.0577953323334 806.7871739082865 777.3574172453614 772.4279618637112 777.0978655200709 760.7288227142477 762.1942110669104 735.7233116212874 755.4493627894343 740.6578591720006 732.0073502961951 731.093963746039 740.3099164905248 749.5650480039747 746.7729786994715 763.2054360120803 776.8563895543059 794.9446071682869 803.8952010033962 820.405538246804 829.6025547229723 846.6680060798504 851.4017371960582 856.08355543554 858.2835137119824 867.9446108996246 863.0378248562697 860.9441109631465 856.1406440816345 858.2829515987826 862.8895647061595 867.6898187279401 888.7833319024435 877.5335235531261 882.429991613087 922.7739273973148 914.8807351859759 909.5622144519157 895.4966109510304 885.1820625471452 895.0208437944409 893.8940627251923 915.964818807858 901.7576391174325 915.8179769689847 926.0466933147038 929.9755488393135 936.3079734638495 936.2742034839226 926.6597172853486 920.1854089563959 935.9953497665327 952.4529496909067 956.6137287656784 951.4768971327147 961.0443466859184 945.2837968579248 942.8102854740695 896.1712198297956 891.7073359994754 885.503007978239 863.9118205723745 840.5619047526806 817.7763408872761 812.7712461872496 808.6808630121054 805.7853634253769 770.2885943267441 731.7940790039223 718.0013143904545 700.2928417187409 675.9377051220345 674.2945555150732 681.3769793624917 673.7256538080836 680.4344744023902 679.3730066224385 681.8689814869795 675.6120056758073 684.3990153810511 675.3858972401728 682.3032405363784 684.2038161451675 682.3032405363784 686.5081813213818 677.7536843150943 694.2874566583372 698.1577785792716 689.7034939698223 693.3229427049326 689.2461244628531 697.4245063757143 711.5410094893347 712.1571288749874 724.7173154209919 735.4732108807374 751.9067668355123 770.7155041194785 789.8449811007323 782.4436447328633 804.1027608629728 799.7739995026042 804.9198539314696 824.072383760584 827.3600283753964 835.1984243790466 830.3180187898224 826.8316711066631 830.2473111417919 834.7803687937779 834.8495449072807 831.3424951058443 839.0291843657471 845.6488124149129 856.1333193891882 865.6182526942837 878.9376809125747 883.9037138998707 890.14784998853 895.0787174761643 900.9879978061749 903.5304681321825 901.0771759780406 892.0582498444298 881.0086858949503 878.8816852611334 878.8816852611334 881.3562906286148 880.5181293022108 861.4107342427621 853.2137690942584 852.2997701027689 843.176591362275 837.6133609713879 839.1454699446667 830.0347157612177 843.0956592077488 909.5896660478629 967.0682617514339 959.4378019467284 962.2969921241925 950.1230014318287 959.5937554068821 969.0406984456198 966.3167948905883 966.3167948905883 967.3164071812251 971.7374986087718 977.2110102205561 962.4071707697751 959.4156201452757 959.7366022865087 957.350649242824 966.8072037112647 975.3271426113722 978.0870112373414 976.7373895709483 975.3271426113722 972.6092651502152 968.8306689425002 963.415438561782 963.415438561782 953.9410385271525 936.543232137431 936.4944601848081 927.5301161429917 927.8034588226964 939.9645359676327 940.5920156311626 937.9117399473269 938.2245857578496 922.4383427215466 888.0592280218483 866.8185791060351 858.2093210618842 856.9202739233398 866.6020960401768 871.7945776886638 849.6531711279017 860.4967519615928 858.2575787601066 870.4446782595292 877.8669883065503 894.3014675712056 877.8669883065503 871.5401024711964 873.9825642109729 878.951261581645 889.0076977815799 885.4861322713166 869.178570384551 880.3615642212993 880.3615642212993 887.5696621691843 876.285550977999 882.7789279616281 886.5080255164478 876.7504841761117 884.608542133473 883.6608249925587 886.2031984444322 900.480744165577 895.6715813509306 919.0607980651608 940.2531577151905 977.2121067671334 995.8535983584844 1010.2163566524196 1016.0392237526603 1016.3768904936882 1019.302980742641 1019.302980742641 1019.302980742641 1019.302980742641 1019.302980742641 1018.9643418786069 1013.1363896149885 1011.67113216485 1011.67113216485 1008.4619522589189 966.1239802211486 938.6456769006247 942.8360768656989 927.8476381119045 927.7895373785385 935.6555344676226 927.57767445765 909.2260549913424 908.1817202286805 912.990114572086 910.7334102019545 890.3813900518339 895.4930751229327 917.351799384704 927.7462664669249 934.4366843863947 951.9829650276292 976.8414137937689 986.9641465487982 992.6286155695486 1000.0986482368994 995.7965792285124 988.6576223220125 994.6899073867755 1004.7603051644799 1013.4559713329605 1013.4559713329605 1011.9957932543659 1013.4559713329605 1019.302980742641 1016.3768904936882 1013.4612568201277 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.6257030145728 1018.6257030145728 1018.6257030145728 1018.6257030145728 1018.6257030145728 1018.6257030145728 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.9643418786069 1018.9643418786069 1019.302980742641 1019.641619606675 1015.2569332380384 1009.4517413829101 1002.2780086621646 983.8967944107394 956.4190678834395 934.8872799961206 924.8415659624836 905.570572162234 878.0228848508052 826.5439200197223 823.4034093820748 788.8891134725559 784.1690291366521 793.3155561509499 753.8522393091671 751.9178926318132 756.789795758811 734.4256856691145 734.4545635466492 733.5779082510104 724.8693020284481 727.7935873075409 737.8240715392269 731.6972059069402 766.1190033693318 739.0381671414002 746.3023980908413 757.8876513367002 809.7248900888197 759.8577319923477 764.6721772446883 761.3484711216562 781.587669223557 776.8658576945861 760.1613062586484 771.1253975517275 792.726091420492 798.1289798074542 936.1192445360765 943.0678950732351 962.2866030218757 969.1086737617746 973.5744957823205 980.5485478482784 980.4966408999254 983.3073538183729 980.4183472889031 987.52800424872 986.0384398260413 994.589696702107 1001.8118971599282 985.9706586584284 996.0173239557467 1000.3926659451653 1001.4711287375516 1002.8410082932402 1008.3577859808036 1009.8267976624076 1010.9454396144695 1010.9688989876367 1006.9335675741894 1008.3695338646246 999.9741855778078 977.0326925468486 949.4281538678974 942.5525591813552 938.4673442394874 938.5035302077775 934.8055442354101 937.5617019558931 943.5379568005492 934.0642649490874 934.5070672658077 929.5486748636787 923.159707198186 887.2579520766346 852.7774617306163 835.2763252392955 813.6815796383859 811.2556834817626 799.2061310276339 787.7022153580492 768.6364205857718 772.5625445665908 766.5389544221003 769.1538201057962 754.6047161529191 742.6111046296185 740.8275980715387 747.2473745798978 738.9852278057118 747.87531091939 737.8079529708338 737.2933915589765 735.8690210443262 740.2092287812908 717.9539207865275 721.1824544666181 712.5539271262365 701.7059087780424 696.7672268208389 690.9017548317103 684.5918072741894 687.0539292471616 682.1532620652463 685.5147217256072 691.967526305865 696.307824902396 714.2503162458439 734.7472686143502 736.5910640312914 738.3030553325589 752.9033583931194 765.6537037742381 767.6242320932203 770.9462077444022 767.6407476162335 778.181859264986 779.1439411056638 798.7355809876071 801.2645871123135 817.7211121626056 826.7620099281977 837.3149592064699 856.0490622740383 864.3130967316122 857.0680183661841 857.0020556275841 858.1234153753395 871.3212843796094 882.3648693400957 887.492905768434 882.269325216638 887.6018876662448 882.5628279861712 876.3599851353332 896.2546216315761 906.430890701359 891.4514606506497 896.4842254850543 914.1893793975739 916.9728114881171 919.6335697510136 921.027814078299 927.9717541905775 877.9315653836538 836.3035657684254 814.4498256976341 790.3477076762871 766.593699257015 756.6689162636939 739.1424096146169 731.158042170918 727.5479107014899 714.7873218188415 705.0259495672374 714.9318811360818 713.1575573523853 722.4756777533441 708.6264565105457 729.9226401527311 723.9590332997716 713.4229258439564 735.0764076675808 722.0470522341737 719.3879734108132 718.9651289117255 743.6209113913249 734.2400048973146 739.0048680689004 752.474426839826 760.667970838227 756.6479107093425 761.9090316878893 774.4522817269968 778.3607812705563 800.0771217145652 814.535310947443 827.924517642034 834.5523685169456 846.777624116176 847.5083849504689 857.0631704105384 871.2492756225047 869.1238667162775 878.7202239653647 876.3374628170692 889.6417972826079 907.1209938511978] hectopascal\n"
 86 |      ]
 87 |     }
 88 |    ],
 89 |    "source": [
 90 |     "print(LCL_press)"
 91 |    ]
 92 |   },
 93 |   {
 94 |    "cell_type": "code",
 95 |    "execution_count": 6,
 96 |    "metadata": {},
 97 |    "outputs": [
 98 |     {
 99 |      "data": {
100 |       "text/plain": [
101 |        "([<matplotlib.axis.XTick at 0x2b07fb215f70>,\n",
102 |        "  <matplotlib.axis.XTick at 0x2b07fb215f40>,\n",
103 |        "  <matplotlib.axis.XTick at 0x2b07fb236550>,\n",
104 |        "  <matplotlib.axis.XTick at 0x2b07fb236dc0>,\n",
105 |        "  <matplotlib.axis.XTick at 0x2b07fb9f9310>],\n",
106 |        " [Text(0, 0, ''),\n",
107 |        "  Text(0, 0, ''),\n",
108 |        "  Text(0, 0, ''),\n",
109 |        "  Text(0, 0, ''),\n",
110 |        "  Text(0, 0, '')])"
111 |       ]
112 |      },
113 |      "execution_count": 6,
114 |      "metadata": {},
115 |      "output_type": "execute_result"
116 |     },
117 |     {
118 |      "data": {
119 |       "image/png": "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\n",
120 |       "text/plain": [
121 |        "<Figure size 432x288 with 1 Axes>"
122 |       ]
123 |      },
124 |      "metadata": {
125 |       "needs_background": "light"
126 |      },
127 |      "output_type": "display_data"
128 |     }
129 |    ],
130 |    "source": [
131 |     "plt.plot(time, LCL_press, color='black')\n",
132 |     "plt.xticks(time[np.arange(0, len(time), 144)])"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "code",
137 |    "execution_count": null,
138 |    "metadata": {},
139 |    "outputs": [],
140 |    "source": []
141 |   },
142 |   {
143 |    "cell_type": "code",
144 |    "execution_count": null,
145 |    "metadata": {},
146 |    "outputs": [],
147 |    "source": []
148 |   },
149 |   {
150 |    "cell_type": "code",
151 |    "execution_count": null,
152 |    "metadata": {},
153 |    "outputs": [],
154 |    "source": []
155 |   }
156 |  ],
157 |  "metadata": {
158 |   "kernelspec": {
159 |    "display_name": "Python 3",
160 |    "language": "python",
161 |    "name": "python3"
162 |   },
163 |   "language_info": {
164 |    "codemirror_mode": {
165 |     "name": "ipython",
166 |     "version": 3
167 |    },
168 |    "file_extension": ".py",
169 |    "mimetype": "text/x-python",
170 |    "name": "python",
171 |    "nbconvert_exporter": "python",
172 |    "pygments_lexer": "ipython3",
173 |    "version": "3.8.5"
174 |   }
175 |  },
176 |  "nbformat": 4,
177 |  "nbformat_minor": 4
178 | }
179 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Sky/Mobotix_Thermal_MinTemp.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "#Import Mods\n",
 10 |     "import pandas as pd\n",
 11 |     "import numpy as np\n",
 12 |     "\n",
 13 |     "import glob\n",
 14 |     "\n",
 15 |     "import matplotlib.pyplot as plt\n",
 16 |     "\n",
 17 |     "from datetime import datetime\n",
 18 |     "from datetime import timedelta"
 19 |    ]
 20 |   },
 21 |   {
 22 |    "cell_type": "code",
 23 |    "execution_count": 2,
 24 |    "metadata": {
 25 |     "scrolled": true
 26 |    },
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "#Grab files from directory and sort them into correct order\n",
 30 |     "files = []\n",
 31 |     "for filename in glob.glob(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/thermal/\"\n",
 32 |     "                          \"*.thermal.celsius.csv\"):\n",
 33 |     "    files.append(filename)\n",
 34 |     "files.sort()"
 35 |    ]
 36 |   },
 37 |   {
 38 |    "cell_type": "code",
 39 |    "execution_count": 3,
 40 |    "metadata": {},
 41 |    "outputs": [],
 42 |    "source": [
 43 |     "#Run through all images and save off minimum temperature for each\n",
 44 |     "temp_min = []\n",
 45 |     "image_time = []\n",
 46 |     "\n",
 47 |     "timeset = datetime(2021, 4, 15, 5, 0)\n",
 48 |     "\n",
 49 |     "for path in files:\n",
 50 |     "    file = pd.read_csv(path)\n",
 51 |     "    image_time.append(datetime.fromtimestamp(int(path[86:96])) + timedelta(hours = 5))\n",
 52 |     "    image_array = []\n",
 53 |     "    \n",
 54 |     "    \n",
 55 |     "    for i in range(file.size):\n",
 56 |     "        if i >= 6:\n",
 57 |     "            data = file.values[i][0]\n",
 58 |     "            data = data.split(';')\n",
 59 |     "            array = np.array(data)\n",
 60 |     "            array = array.astype(np.float)\n",
 61 |     "            image_array.append(array)\n",
 62 |     "            \n",
 63 |     "    temp_min.append(np.min(image_array))"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 4,
 69 |    "metadata": {},
 70 |    "outputs": [
 71 |     {
 72 |      "data": {
 73 |       "text/plain": [
 74 |        "Text(0.5, 1.0, 'Mobotix Thermal Camera Minimum Temperature')"
 75 |       ]
 76 |      },
 77 |      "execution_count": 4,
 78 |      "metadata": {},
 79 |      "output_type": "execute_result"
 80 |     },
 81 |     {
 82 |      "data": {
 83 |       "image/png": "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\n",
 84 |       "text/plain": [
 85 |        "<Figure size 432x288 with 1 Axes>"
 86 |       ]
 87 |      },
 88 |      "metadata": {
 89 |       "needs_background": "light"
 90 |      },
 91 |      "output_type": "display_data"
 92 |     }
 93 |    ],
 94 |    "source": [
 95 |     "#Plot time series\n",
 96 |     "plt.plot(image_time[0:750], temp_min[0:750], color = 'blue')\n",
 97 |     "\n",
 98 |     "plt.xlabel('Time (UTC)')\n",
 99 |     "plt.xticks((image_time[163], image_time[369], image_time[575]), ('4-16 0Z','4-17 0Z','4-18 0Z'))\n",
100 |     "plt.ylabel('Temperature (F)')\n",
101 |     "\n",
102 |     "plt.title('Mobotix Thermal Camera Minimum Temperature')\n",
103 |     "\n",
104 |     "#plt.savefig('Thermal_Time_Series_Third.png')"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "code",
109 |    "execution_count": null,
110 |    "metadata": {},
111 |    "outputs": [],
112 |    "source": []
113 |   }
114 |  ],
115 |  "metadata": {
116 |   "kernelspec": {
117 |    "display_name": "Python 3",
118 |    "language": "python",
119 |    "name": "python3"
120 |   },
121 |   "language_info": {
122 |    "codemirror_mode": {
123 |     "name": "ipython",
124 |     "version": 3
125 |    },
126 |    "file_extension": ".py",
127 |    "mimetype": "text/x-python",
128 |    "name": "python",
129 |    "nbconvert_exporter": "python",
130 |    "pygments_lexer": "ipython3",
131 |    "version": "3.8.5"
132 |   }
133 |  },
134 |  "nbformat": 4,
135 |  "nbformat_minor": 4
136 | }
137 | 


--------------------------------------------------------------------------------
/Mobotix_RadTherm/Sky/Sky_Mask_Data_Area.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "#Import Mods\n",
 10 |     "import pandas as pd\n",
 11 |     "import numpy as np\n",
 12 |     "\n",
 13 |     "import glob\n",
 14 |     "\n",
 15 |     "import matplotlib.pyplot as plt\n",
 16 |     "\n",
 17 |     "from datetime import datetime\n",
 18 |     "from datetime import timedelta\n",
 19 |     "\n",
 20 |     "from PIL import Image"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 2,
 26 |    "metadata": {},
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "#grab sinlge image used to create the mask\n",
 30 |     "file = pd.read_csv(\"/lcrc/project/waggle/public_html/private/training_data/waggle_area510/mobotix/\"\n",
 31 |     "                \"thermal/1618866828_000001_right_336x252_14bit.thermal.celsius.csv\")"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 3,
 37 |    "metadata": {},
 38 |    "outputs": [],
 39 |    "source": [
 40 |     "#Create image list by unpacking data from CSV and placing in correct spot.\n",
 41 |     "\n",
 42 |     "image_array = []\n",
 43 |     "\n",
 44 |     "for i in range(file.size):\n",
 45 |     "    if i >= 6:\n",
 46 |     "        data = file.values[i][0]\n",
 47 |     "        data = data.split(';')\n",
 48 |     "        array = np.array(data)\n",
 49 |     "        array = array.astype(np.float)\n",
 50 |     "        image_array.append(array)\n",
 51 |     "    "
 52 |    ]
 53 |   },
 54 |   {
 55 |    "cell_type": "code",
 56 |    "execution_count": 4,
 57 |    "metadata": {},
 58 |    "outputs": [],
 59 |    "source": [
 60 |     "#Create mask list with threshold value.\n",
 61 |     "mask_col = []\n",
 62 |     "\n",
 63 |     "for j in image_array:\n",
 64 |     "    mask_row = []\n",
 65 |     "    for k in j:\n",
 66 |     "        if k < -0.50:\n",
 67 |     "            mask_row.append(1)\n",
 68 |     "        else:\n",
 69 |     "            mask_row.append(0)\n",
 70 |     "            \n",
 71 |     "    mask_col.append(mask_row)"
 72 |    ]
 73 |   },
 74 |   {
 75 |    "cell_type": "code",
 76 |    "execution_count": 5,
 77 |    "metadata": {},
 78 |    "outputs": [],
 79 |    "source": [
 80 |     "#Tranform list into array and convert all true values from 1 to 255 as well as use an unsigned 8-bit integer dtype.\n",
 81 |     "array = np.array(mask_col).astype('uint8')*255"
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 6,
 87 |    "metadata": {},
 88 |    "outputs": [
 89 |     {
 90 |      "data": {
 91 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVAAAAD8CAAAAAAEKqMkAAABrUlEQVR4nO3a0W6CMBSA4Z7F93/l7kIZOFFaKKHg912QZVkc+TlFESKnvsTRO7DRz9E78M/Ze3YXtLcFU+129A5MnX48U+sJvUKRjWLrGrs3zMOP1S837sA1jka7JR/D9n3TR7xIKY8HIu6bNP7y1LZO6JAgT1vMvWbkSCnlyBeI9snGoPN1ZoNu+j/nscvHpnit9y09107oeOJ7Y/qyXxMzpQ0TGh106vEqYP2SL+75eAffwfGH9NWqoDPnyPd/E5Ntc/3NaP05tDxNjmt8tKxSHfTbAtWqvFKSc0ndOVTPRVVB9VxWvOQ/fuvBn5oJNaAFSoOKWagwqJ6lyoLqWay3u56nVxTUgJYzoY0J2pigjZUEdQqtYEIbW76WN59VFidUzzqWfGOCNrYU1IqvNBs0Yue7vxf2etdzbHj1B+V28TSh8fwMg54rTCdUwAa8yzc2CWpAWxguPdVs5B5UzmZuSc62PA4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP5+Aa3+I4h0r2tdAAAAAElFTkSuQmCC\n",
 92 |       "text/plain": [
 93 |        "<PIL.Image.Image image mode=L size=336x252 at 0x2AF613993820>"
 94 |       ]
 95 |      },
 96 |      "execution_count": 6,
 97 |      "metadata": {},
 98 |      "output_type": "execute_result"
 99 |     }
100 |    ],
101 |    "source": [
102 |     "#create image\n",
103 |     "im = Image.fromarray(array)\n",
104 |     "im\n",
105 |     "\n",
106 |     "#im.save('Sky_Mask.png')"
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": null,
112 |    "metadata": {},
113 |    "outputs": [],
114 |    "source": []
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": null,
119 |    "metadata": {},
120 |    "outputs": [],
121 |    "source": []
122 |   }
123 |  ],
124 |  "metadata": {
125 |   "kernelspec": {
126 |    "display_name": "Python 3",
127 |    "language": "python",
128 |    "name": "python3"
129 |   },
130 |   "language_info": {
131 |    "codemirror_mode": {
132 |     "name": "ipython",
133 |     "version": 3
134 |    },
135 |    "file_extension": ".py",
136 |    "mimetype": "text/x-python",
137 |    "name": "python",
138 |    "nbconvert_exporter": "python",
139 |    "pygments_lexer": "ipython3",
140 |    "version": "3.8.5"
141 |   }
142 |  },
143 |  "nbformat": 4,
144 |  "nbformat_minor": 4
145 | }
146 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # SageScienceExamples
2 | Collected notes, notebooks and code snippets showcasing what can be done with Sage
3 | 


--------------------------------------------------------------------------------
/api_examples/Konza API Example.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": null,
  6 |    "id": "a4af764c",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "import numpy as np\n",
 11 |     "from matplotlib import pyplot as plt\n",
 12 |     "from matplotlib import colors\n",
 13 |     "import xarray as xr\n",
 14 |     "import pandas as pd\n",
 15 |     "import csv\n",
 16 |     "import subprocess\n",
 17 |     "import os\n",
 18 |     "import sage_data_client\n",
 19 |     "import urllib\n",
 20 |     "import tempfile\n",
 21 |     "from xmovie import Movie\n",
 22 |     "import cftime\n",
 23 |     "\n",
 24 |     "\n",
 25 |     "%matplotlib inline"
 26 |    ]
 27 |   },
 28 |   {
 29 |    "cell_type": "code",
 30 |    "execution_count": null,
 31 |    "id": "d87d8d95",
 32 |    "metadata": {},
 33 |    "outputs": [],
 34 |    "source": [
 35 |     "# https://portal.sagecontinuum.org/data-browser?nodes=W038&window=d&apps=air-quality%3A0.2.0\n",
 36 |     "# https://github.com/sagecontinuum/sage-data-client"
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "code",
 41 |    "execution_count": null,
 42 |    "id": "93566b54",
 43 |    "metadata": {},
 44 |    "outputs": [],
 45 |    "source": [
 46 |     "dfaq = sage_data_client.query(\n",
 47 |     "    start=\"2022-04-15 19:00\", end=\"2022-04-15 23:55\",\n",
 48 |     "    filter={\n",
 49 |     "        \"name\": \"env.air_quality.conc\",\n",
 50 |     "        'vsn' : 'W038'\n",
 51 |     "    }\n",
 52 |     ")"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": null,
 58 |    "id": "008f440d",
 59 |    "metadata": {},
 60 |    "outputs": [],
 61 |    "source": []
 62 |   },
 63 |   {
 64 |    "cell_type": "code",
 65 |    "execution_count": null,
 66 |    "id": "9c3ab6f8",
 67 |    "metadata": {},
 68 |    "outputs": [],
 69 |    "source": []
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": null,
 74 |    "id": "c23e408d",
 75 |    "metadata": {},
 76 |    "outputs": [],
 77 |    "source": [
 78 |     "dfaq['timestamp'] = pd.to_datetime(dfaq['timestamp'])\n",
 79 |     "dfaq = dfaq.set_index('timestamp')"
 80 |    ]
 81 |   },
 82 |   {
 83 |    "cell_type": "code",
 84 |    "execution_count": null,
 85 |    "id": "0d0bace7",
 86 |    "metadata": {},
 87 |    "outputs": [],
 88 |    "source": [
 89 |     "my_fig = plt.figure(figsize=[15,5])\n",
 90 |     "dfaq.value[\"2022-04-15 20:00\":\"2022-04-15 23:55\"].plot()\n",
 91 |     "plt.ylabel('PM2.5 mg/m$^3$')"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "code",
 96 |    "execution_count": null,
 97 |    "id": "953e36f1",
 98 |    "metadata": {},
 99 |    "outputs": [],
100 |    "source": [
101 |     "#Thermal Camera"
102 |    ]
103 |   },
104 |   {
105 |    "cell_type": "code",
106 |    "execution_count": null,
107 |    "id": "a5ac8cbc",
108 |    "metadata": {},
109 |    "outputs": [],
110 |    "source": [
111 |     "df = sage_data_client.query(\n",
112 |     "    start=\"2022-04-15 19:00\", end=\"2022-04-15 23:55\",\n",
113 |     "    filter={\n",
114 |     "        \"plugin\": \"mobotix-sampler.*\",\n",
115 |     "        \"vsn\" : \"V008\"\n",
116 |     "    }\n",
117 |     ")\n",
118 |     "\n",
119 |     "targets = []\n",
120 |     "times = []\n",
121 |     "for i in range(len(df)):\n",
122 |     "    if 'celsius' in df.iloc[i].value:\n",
123 |     "        targets.append(df.iloc[i].value)\n",
124 |     "        times.append(df.iloc[i].timestamp)\n"
125 |    ]
126 |   },
127 |   {
128 |    "cell_type": "code",
129 |    "execution_count": null,
130 |    "id": "0c6c9b41",
131 |    "metadata": {},
132 |    "outputs": [],
133 |    "source": [
134 |     "df.iloc[-9210]"
135 |    ]
136 |   },
137 |   {
138 |    "cell_type": "code",
139 |    "execution_count": null,
140 |    "id": "dbcf9a45",
141 |    "metadata": {},
142 |    "outputs": [],
143 |    "source": []
144 |   },
145 |   {
146 |    "cell_type": "code",
147 |    "execution_count": null,
148 |    "id": "c3226fa1",
149 |    "metadata": {},
150 |    "outputs": [],
151 |    "source": [
152 |     "def read_mob_from_sage(url, datet):\n",
153 |     "    tempf = tempfile.NamedTemporaryFile()\n",
154 |     "    try:\n",
155 |     "        urllib.request.urlretrieve(url, tempf.name)\n",
156 |     "        head = []\n",
157 |     "        with open(tempf.name, 'r') as f:\n",
158 |     "            reader = csv.reader(f, delimiter=';')\n",
159 |     "            for i in range(7):\n",
160 |     "                headers = next(reader)\n",
161 |     "                head.append(headers)\n",
162 |     "            _ = next(reader)\n",
163 |     "            data = np.expand_dims(np.flipud(np.array(list(reader)).astype(float)), axis=0)\n",
164 |     "        print(data.shape)\n",
165 |     "        tt = datet.to_pydatetime()\n",
166 |     "        ctime = cftime.datetime(tt.year, tt.month, tt.day, hour=tt.hour, minute=tt.minute, second=tt.second)\n",
167 |     "\n",
168 |     "        ds = xr.Dataset({\n",
169 |     "        'thermalimage': xr.DataArray(\n",
170 |     "                    data   = data,   # enter data here\n",
171 |     "                    dims   = ['time', 'y', 'x'],\n",
172 |     "                    coords = {'time': [ctime],\n",
173 |     "                             'y' : np.arange(data.shape[1]),\n",
174 |     "                             'x' : np.arange(data.shape[2])},\n",
175 |     "                    attrs  = {\n",
176 |     "                        '_FillValue': -999.9,\n",
177 |     "                        'units'     : 'celsius'\n",
178 |     "                        }\n",
179 |     "                    ),\n",
180 |     "                },\n",
181 |     "            attrs = {'Source': 'MOBOTIX M16 camera operated by Sage',\n",
182 |     "                    'URL' : url}\n",
183 |     "        )\n",
184 |     "    except urllib.error.HTTPError:\n",
185 |     "        ds=\"ERROR\"\n",
186 |     "    \n",
187 |     "    return ds\n",
188 |     "    "
189 |    ]
190 |   },
191 |   {
192 |    "cell_type": "code",
193 |    "execution_count": null,
194 |    "id": "7b7a658b",
195 |    "metadata": {},
196 |    "outputs": [],
197 |    "source": [
198 |     "i = -1 #3000\n",
199 |     "myxr = read_mob_from_sage(targets[i], times[i])"
200 |    ]
201 |   },
202 |   {
203 |    "cell_type": "code",
204 |    "execution_count": null,
205 |    "id": "39540b15",
206 |    "metadata": {},
207 |    "outputs": [],
208 |    "source": []
209 |   },
210 |   {
211 |    "cell_type": "code",
212 |    "execution_count": null,
213 |    "id": "0d4ecf23",
214 |    "metadata": {},
215 |    "outputs": [],
216 |    "source": []
217 |   }
218 |  ],
219 |  "metadata": {
220 |   "kernelspec": {
221 |    "display_name": "Python 3 (ipykernel)",
222 |    "language": "python",
223 |    "name": "python3"
224 |   },
225 |   "language_info": {
226 |    "codemirror_mode": {
227 |     "name": "ipython",
228 |     "version": 3
229 |    },
230 |    "file_extension": ".py",
231 |    "mimetype": "text/x-python",
232 |    "name": "python",
233 |    "nbconvert_exporter": "python",
234 |    "pygments_lexer": "ipython3",
235 |    "version": "3.7.8"
236 |   }
237 |  },
238 |  "nbformat": 4,
239 |  "nbformat_minor": 5
240 | }
241 | 


--------------------------------------------------------------------------------
/lightning/lightning_env.yaml:
--------------------------------------------------------------------------------
 1 | name: sage-lightning
 2 | channels:
 3 |   - conda-forge
 4 |   - defaults
 5 | dependencies:
 6 |   - python=3.8
 7 |   - numpy
 8 |   - scipy
 9 |   - xarray
10 |   - jupyter
11 |   - matplotlib


--------------------------------------------------------------------------------
/lightning/rtl-sdr.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sagecontinuum/SageScienceExamples/751d87844c3c8195ca57be1a091b10079cb8a466/lightning/rtl-sdr.jpg


--------------------------------------------------------------------------------