Full Commit

lib/fish_eye/.gitignore

@@ -0,0 +1,104 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/

lib/fish_eye/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Grant Van Horn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/fish_eye/README.md

@@ -0,0 +1,19 @@
+# Converting ARIS into image zipfiles that can be provided to annotators:
+```
+gen_clips.py --aris_dir [location of source files]
+             --clip_dir [location to output unzipped images]
+             --dump_dir [location to output json dumps of created clips]
+             --river_name [eg. kenai]
+             --river_location [eg. ak]
+             --zip_location [location to output zipped images for annotation]
+```
+
+# Annotate zip files:
+https://kulits.github.io/vatic.js/index.html
+
+# Convert outputs of annotation tool to common format:
+```
+convert_annotations.py --json_dump_path [path to json dump of annotated files created in the previous step]
+                       --xml_dir [location of annotations created in the previous step]
+                       --output_path [location of place to put converted annotations]
+```

lib/fish_eye/beam_widths/ARIS1800_1200_48.csv

@@ -0,0 +1,49 @@
+beam_num,beam_center,beam_left,beam_right
+0,-13.5735,-13.7893,-13.3577
+1,-13.1419,-13.3577,-12.9211
+2,-12.7003,-12.9211,-12.4723
+3,-12.2442,-12.4723,-12.0082
+4,-11.7721,-12.0082,-11.5301
+5,-11.2881,-11.5301,-11.0401
+6,-10.7921,-11.0401,-10.5373
+7,-10.2824,-10.5373,-10.0211
+8,-9.7597,-10.0211,-9.4902
+9,-9.2206,-9.4902,-8.9418
+10,-8.663,-8.9418,-8.3765
+11,-8.0899,-8.3765,-7.7963
+12,-7.5026,-7.7963,-7.2023
+13,-6.9019,-7.2023,-6.5958
+14,-6.2897,-6.5958,-5.9779
+15,-5.6661,-5.9779,-5.3476
+16,-5.0291,-5.3476,-4.7057
+17,-4.3823,-4.7057,-4.0544
+18,-3.7264,-4.0544,-3.3948
+19,-3.0632,-3.3948,-2.7282
+20,-2.3931,-2.7282,-2.0551
+21,-1.717,-2.0551,-1.3757
+22,-1.0343,-1.3757,-0.6902
+23,-0.3461,-0.6902,0.0
+24,0.3461,0.0,0.6902
+25,1.0343,0.6902,1.3757
+26,1.717,1.3757,2.0551
+27,2.3931,2.0551,2.7282
+28,3.0632,2.7282,3.3948
+29,3.7264,3.3948,4.0544
+30,4.3823,4.0544,4.7057
+31,5.0291,4.7057,5.3476
+32,5.6661,5.3476,5.9779
+33,6.2897,5.9779,6.5958
+34,6.9019,6.5958,7.2023
+35,7.5026,7.2023,7.7963
+36,8.0899,7.7963,8.3765
+37,8.663,8.3765,8.9418
+38,9.2206,8.9418,9.4902
+39,9.7597,9.4902,10.0211
+40,10.2824,10.0211,10.5373
+41,10.7921,10.5373,11.0401
+42,11.2881,11.0401,11.5301
+43,11.7721,11.5301,12.0082
+44,12.2442,12.0082,12.4723
+45,12.7003,12.4723,12.9211
+46,13.1419,12.9211,13.3577
+47,13.5735,13.3577,13.7893

lib/fish_eye/beam_widths/ARIS1800_96.csv

@@ -0,0 +1,97 @@
+beam_num,beam_center,beam_left,beam_right
+0,-13.749,-13.8562,-13.6419
+1,-13.5347,-13.6419,-13.4261
+2,-13.3174,-13.4261,-13.2075
+3,-13.0975,-13.2075,-12.9867
+4,-12.8758,-12.9867,-12.7628
+5,-12.6498,-12.7628,-12.5348
+6,-12.4197,-12.5348,-12.3026
+7,-12.1855,-12.3026,-12.0666
+8,-11.9476,-12.0666,-11.8273
+9,-11.7069,-11.8273,-11.5853
+10,-11.4636,-11.5853,-11.3405
+11,-11.2173,-11.3405,-11.0925
+12,-10.9676,-11.0925,-10.841
+13,-10.7144,-10.841,-10.5862
+14,-10.4579,-10.5862,-10.3282
+15,-10.1985,-10.3282,-10.0669
+16,-9.9352,-10.0669,-9.8016
+17,-9.668,-9.8016,-9.5321
+18,-9.3961,-9.5321,-9.2578
+19,-9.1195,-9.2578,-8.979
+20,-8.8385,-8.979,-8.696
+21,-8.5535,-8.696,-8.4095
+22,-8.2654,-8.4095,-8.1196
+23,-7.9738,-8.1196,-7.826
+24,-7.6781,-7.826,-7.5287
+25,-7.3793,-7.5287,-7.2284
+26,-7.0774,-7.2284,-6.9251
+27,-6.7727,-6.9251,-6.619
+28,-6.4652,-6.619,-6.3101
+29,-6.1549,-6.3101,-5.9983
+30,-5.8416,-5.9983,-5.6831
+31,-5.5246,-5.6831,-5.3646
+32,-5.2046,-5.3646,-5.0435
+33,-4.8824,-5.0435,-4.7201
+34,-4.5578,-4.7201,-4.3944
+35,-4.231,-4.3944,-4.0665
+36,-3.9019,-4.0665,-3.7365
+37,-3.5711,-3.7365,-3.4049
+38,-3.2387,-3.4049,-3.0716
+39,-2.9044,-3.0716,-2.7365
+40,-2.5686,-2.7365,-2.4
+41,-2.2314,-2.4,-2.062
+42,-1.8925,-2.062,-1.7222
+43,-1.5519,-1.7222,-1.3809
+44,-1.2098,-1.3809,-1.0381
+45,-0.8664,-1.0381,-0.694
+46,-0.5216,-0.694,-0.3487
+47,-0.1757,-0.3487,-0.0026
+48,0.1706,-0.0026,0.3438
+49,0.5169,0.3438,0.6899
+50,0.8628,0.6899,1.0352
+51,1.2076,1.0352,1.3793
+52,1.551,1.3793,1.7221
+53,1.8931,1.7221,2.0634
+54,2.2337,2.0634,2.4032
+55,2.5726,2.4032,2.7412
+56,2.9098,2.7412,3.0777
+57,3.2456,3.0777,3.4128
+58,3.5799,3.4128,3.7461
+59,3.9123,3.7461,4.0777
+60,4.2431,4.0777,4.4077
+61,4.5722,4.4077,4.7356
+62,4.899,4.7356,5.0613
+63,5.2236,5.0613,5.3847
+64,5.5458,5.3847,5.7058
+65,5.8658,5.7058,6.0243
+66,6.1828,6.0243,6.3395
+67,6.4961,6.3395,6.6513
+68,6.8064,6.6513,6.9602
+69,7.1139,6.9602,7.2663
+70,7.4186,7.2663,7.5696
+71,7.7205,7.5696,7.8699
+72,8.0193,7.8699,8.1672
+73,8.315,8.1672,8.4608
+74,8.6066,8.4608,8.7507
+75,8.8947,8.7507,9.0372
+76,9.1797,9.0372,9.3202
+77,9.4607,9.3202,9.599
+78,9.7373,9.599,9.8733
+79,10.0092,9.8733,10.1428
+80,10.2764,10.1428,10.4081
+81,10.5397,10.4081,10.6694
+82,10.7991,10.6694,10.9274
+83,11.0556,10.9274,11.1822
+84,11.3088,11.1822,11.4337
+85,11.5585,11.4337,11.6817
+86,11.8048,11.6817,11.9265
+87,12.0481,11.9265,12.1685
+88,12.2888,12.1685,12.4078
+89,12.5267,12.4078,12.6438
+90,12.7609,12.6438,12.876
+91,12.991,12.876,13.104
+92,13.217,13.104,13.3279
+93,13.4387,13.3279,13.5487
+94,13.6586,13.5487,13.7673
+95,13.8759,13.7673,13.9831

lib/fish_eye/beam_widths/ARIS3000_128.csv

@@ -0,0 +1,129 @@
+beam_num,beam_center,beam_left,beam_right
+0,-15.0068,-15.1218,-14.8918
+1,-14.7768,-14.8918,-14.6615
+2,-14.5462,-14.6615,-14.4306
+3,-14.315,-14.4306,-14.1992
+4,-14.0833,-14.1992,-13.9672
+5,-13.8511,-13.9672,-13.7349
+6,-13.6186,-13.7349,-13.5022
+7,-13.3858,-13.5022,-13.2693
+8,-13.1528,-13.2693,-13.0362
+9,-12.9196,-13.0362,-12.8029
+10,-12.6861,-12.8029,-12.5692
+11,-12.4523,-12.5692,-12.3353
+12,-12.2182,-12.3353,-12.101
+13,-11.9838,-12.101,-11.8665
+14,-11.7491,-11.8665,-11.6316
+15,-11.5141,-11.6316,-11.3965
+16,-11.2789,-11.3965,-11.1612
+17,-11.0435,-11.1612,-10.9257
+18,-10.8079,-10.9257,-10.69
+19,-10.5721,-10.69,-10.4541
+20,-10.3361,-10.4541,-10.218
+21,-10.0999,-10.218,-9.9817
+22,-9.8635,-9.9817,-9.7452
+23,-9.6269,-9.7452,-9.5086
+24,-9.3902,-9.5086,-9.2718
+25,-9.1534,-9.2718,-9.035
+26,-8.9165,-9.035,-8.798
+27,-8.6795,-8.798,-8.561
+28,-8.4424,-8.561,-8.3239
+29,-8.2053,-8.3239,-8.0868
+30,-7.9682,-8.0868,-7.8496
+31,-7.731,-7.8496,-7.6124
+32,-7.4938,-7.6124,-7.3752
+33,-7.2566,-7.3752,-7.138
+34,-7.0193,-7.138,-6.9007
+35,-6.782,-6.9007,-6.6633
+36,-6.5446,-6.6633,-6.4259
+37,-6.3072,-6.4259,-6.1885
+38,-6.0698,-6.1885,-5.9511
+39,-5.8324,-5.9511,-5.7137
+40,-5.5949,-5.7137,-5.4762
+41,-5.3574,-5.4762,-5.2387
+42,-5.1199,-5.2387,-5.0011
+43,-4.8823,-5.0011,-4.7635
+44,-4.6447,-4.7635,-4.5259
+45,-4.4071,-4.5259,-4.2883
+46,-4.1695,-4.2883,-4.0507
+47,-3.9318,-4.0507,-3.813
+48,-3.6941,-3.813,-3.5753
+49,-3.4564,-3.5753,-3.3376
+50,-3.2187,-3.3376,-3.0998
+51,-2.9809,-3.0998,-2.862
+52,-2.743,-2.862,-2.624
+53,-2.505,-2.624,-2.386
+54,-2.2669,-2.386,-2.1478
+55,-2.0287,-2.1478,-1.9096
+56,-1.7904,-1.9096,-1.6712
+57,-1.552,-1.6712,-1.4328
+58,-1.3135,-1.4328,-1.1942
+59,-1.0749,-1.1942,-0.9556
+60,-0.8362,-0.9556,-0.7168
+61,-0.5974,-0.7168,-0.478
+62,-0.3585,-0.478,-0.2391
+63,-0.1196,-0.2391,-0.0001
+64,0.1194,-0.0001,0.2389
+65,0.3584,0.2389,0.4779
+66,0.5973,0.4779,0.7168
+67,0.8362,0.7168,0.9556
+68,1.075,0.9556,1.1944
+69,1.3137,1.1944,1.433
+70,1.5523,1.433,1.6716
+71,1.7908,1.6716,1.91
+72,2.0292,1.91,2.1484
+73,2.2675,2.1484,2.3866
+74,2.5057,2.3866,2.6248
+75,2.7438,2.6248,2.8628
+76,2.9818,2.8628,3.1008
+77,3.2197,3.1008,3.3386
+78,3.4575,3.3386,3.5764
+79,3.6952,3.5764,3.8141
+80,3.9329,3.8141,4.0518
+81,4.1706,4.0518,4.2895
+82,4.4083,4.2895,4.5271
+83,4.6459,4.5271,4.7647
+84,4.8835,4.7647,5.0023
+85,5.1211,5.0023,5.2399
+86,5.3587,5.2399,5.4775
+87,5.5962,5.4775,5.715
+88,5.8337,5.715,5.9525
+89,6.0712,5.9525,6.1899
+90,6.3086,6.1899,6.4273
+91,6.546,6.4273,6.6647
+92,6.7834,6.6647,6.9021
+93,7.0208,6.9021,7.1395
+94,7.2581,7.1395,7.3768
+95,7.4954,7.3768,7.614
+96,7.7326,7.614,7.8512
+97,7.9698,7.8512,8.0884
+98,8.207,8.0884,8.3256
+99,8.4441,8.3256,8.5627
+100,8.6812,8.5627,8.7998
+101,8.9183,8.7998,9.0368
+102,9.1553,9.0368,9.2738
+103,9.3922,9.2738,9.5106
+104,9.629,9.5106,9.7474
+105,9.8657,9.7474,9.984
+106,10.1023,9.984,10.2205
+107,10.3387,10.2205,10.4568
+108,10.5749,10.4568,10.6929
+109,10.8109,10.6929,10.9288
+110,11.0467,10.9288,11.1645
+111,11.2823,11.1645,11.4
+112,11.5177,11.4,11.6353
+113,11.7529,11.6353,11.8704
+114,11.9879,11.8704,12.1053
+115,12.2226,12.1053,12.3398
+116,12.457,12.3398,12.5741
+117,12.6911,12.5741,12.808
+118,12.9249,12.808,13.0417
+119,13.1584,13.0417,13.275
+120,13.3916,13.275,13.5081
+121,13.6246,13.5081,13.741
+122,13.8574,13.741,13.9737
+123,14.0899,13.9737,14.206
+124,14.3221,14.206,14.438
+125,14.5538,14.438,14.6694
+126,14.785,14.6694,14.9003
+127,15.0156,14.9003,15.1306

lib/fish_eye/beam_widths/ARIS3000_64.csv

@@ -0,0 +1,65 @@
+beam_num,beam_center,beam_left,beam_right
+0,-14.8872,-15.1175,-14.6569
+1,-14.4266,-14.6569,-14.1952
+2,-13.9637,-14.1952,-13.7314
+3,-13.499,-13.7314,-13.2661
+4,-13.0332,-13.2661,-12.7999
+5,-12.5665,-12.7999,-12.3326
+6,-12.0986,-12.3326,-11.8641
+7,-11.6295,-11.8641,-11.3944
+8,-11.1593,-11.3944,-10.9238
+9,-10.6883,-10.9238,-10.4524
+10,-10.2165,-10.4524,-9.9802
+11,-9.7439,-9.9802,-9.5073
+12,-9.2706,-9.5073,-9.0338
+13,-8.7969,-9.0338,-8.5599
+14,-8.3228,-8.5599,-8.0857
+15,-7.8486,-8.0857,-7.6114
+16,-7.3742,-7.6114,-7.137
+17,-6.8997,-7.137,-6.6624
+18,-6.425,-6.6624,-6.1876
+19,-5.9502,-6.1876,-5.7128
+20,-5.4753,-5.7128,-5.2378
+21,-5.0003,-5.2378,-4.7627
+22,-4.5251,-4.7627,-4.2875
+23,-4.0499,-4.2875,-3.8122
+24,-3.5745,-3.8122,-3.3368
+25,-3.0991,-3.3368,-2.8613
+26,-2.6234,-2.8613,-2.3854
+27,-2.1473,-2.3854,-1.9091
+28,-1.6708,-1.9091,-1.4324
+29,-1.1939,-1.4324,-0.9553
+30,-0.7166,-0.9553,-0.4778
+31,-0.2389,-0.4778,0.0
+32,0.2389,0.0,0.4778
+33,0.7166,0.4778,0.9553
+34,1.1939,0.9553,1.4324
+35,1.6708,1.4324,1.9091
+36,2.1473,1.9091,2.3854
+37,2.6234,2.3854,2.8613
+38,3.0991,2.8613,3.3368
+39,3.5745,3.3368,3.8122
+40,4.0499,3.8122,4.2875
+41,4.5251,4.2875,4.7627
+42,5.0003,4.7627,5.2378
+43,5.4753,5.2378,5.7128
+44,5.9502,5.7128,6.1876
+45,6.425,6.1876,6.6624
+46,6.8997,6.6624,7.137
+47,7.3742,7.137,7.6114
+48,7.8486,7.6114,8.0857
+49,8.3228,8.0857,8.5599
+50,8.7969,8.5599,9.0338
+51,9.2706,9.0338,9.5073
+52,9.7439,9.5073,9.9802
+53,10.2165,9.9802,10.4524
+54,10.6883,10.4524,10.9238
+55,11.1593,10.9238,11.3944
+56,11.6295,11.3944,11.8641
+57,12.0986,11.8641,12.3326
+58,12.5665,12.3326,12.7999
+59,13.0332,12.7999,13.2661
+60,13.499,13.2661,13.7314
+61,13.9637,13.7314,14.1952
+62,14.4266,14.1952,14.6569
+63,14.8872,14.6569,15.1175

lib/fish_eye/beam_widths/ARIS_Telephoto_48.csv

@@ -0,0 +1,49 @@
+beam_num,beam_center,beam_left,beam_right
+0,-7.339,-7.487,-7.345
+1,-7.043,-7.193,-7.048
+2,-6.744,-6.895,-6.749
+3,-6.443,-6.595,-6.447
+4,-6.14,-6.293,-6.144
+5,-5.835,-5.988,-5.839
+6,-5.529,-5.683,-5.533
+7,-5.222,-5.377,-5.225
+8,-4.913,-5.069,-4.915
+9,-4.602,-4.758,-4.604
+10,-4.29,-4.448,-4.291
+11,-3.975,-4.133,-3.976
+12,-3.659,-3.818,-3.66
+13,-3.342,-3.501,-3.343
+14,-3.025,-3.184,-3.026
+15,-2.708,-2.867,-2.709
+16,-2.391,-2.55,-2.392
+17,-2.074,-2.233,-2.075
+18,-1.756,-1.915,-1.757
+19,-1.438,-1.598,-1.438
+20,-1.119,-1.279,-1.119
+21,-0.8,-0.96,-0.8
+22,-0.48,-0.64,-0.48
+23,-0.16,-0.32,-0.16
+24,0.16,0.16,0.32
+25,0.48,0.48,0.64
+26,0.8,0.8,0.96
+27,1.119,1.119,1.279
+28,1.438,1.438,1.598
+29,1.756,1.757,1.915
+30,2.074,2.075,2.233
+31,2.391,2.392,2.55
+32,2.708,2.709,2.867
+33,3.025,3.026,3.184
+34,3.342,3.343,3.501
+35,3.659,3.66,3.818
+36,3.975,3.976,4.133
+37,4.29,4.291,4.448
+38,4.602,4.604,4.758
+39,4.913,4.915,5.069
+40,5.222,5.225,5.377
+41,5.529,5.533,5.683
+42,5.835,5.839,5.988
+43,6.14,6.144,6.293
+44,6.443,6.447,6.595
+45,6.744,6.749,6.895
+46,7.043,7.048,7.193
+47,7.339,7.345,7.487

lib/fish_eye/beam_widths/ARIS_Telephoto_96.csv

@@ -0,0 +1,97 @@
+beam_num,beam_center,beam_left,beam_right
+0,-7.419,-7.493,-7.345
+1,-7.271,-7.345,-7.197
+2,-7.123,-7.197,-7.048
+3,-6.974,-7.048,-6.899
+4,-6.824,-6.899,-6.749
+5,-6.674,-6.749,-6.598
+6,-6.523,-6.598,-6.447
+7,-6.372,-6.447,-6.296
+8,-6.22,-6.296,-6.144
+9,-6.068,-6.144,-5.992
+10,-5.915,-5.992,-5.839
+11,-5.763,-5.839,-5.686
+12,-5.609,-5.686,-5.533
+13,-5.456,-5.533,-5.379
+14,-5.302,-5.379,-5.225
+15,-5.148,-5.225,-5.07
+16,-4.993,-5.07,-4.915
+17,-4.838,-4.915,-4.76
+18,-4.682,-4.76,-4.604
+19,-4.526,-4.604,-4.448
+20,-4.37,-4.448,-4.291
+21,-4.213,-4.291,-4.134
+22,-4.055,-4.134,-3.976
+23,-3.897,-3.976,-3.818
+24,-3.739,-3.818,-3.66
+25,-3.581,-3.66,-3.501
+26,-3.422,-3.501,-3.343
+27,-3.264,-3.343,-3.185
+28,-3.105,-3.185,-3.026
+29,-2.947,-3.026,-2.868
+30,-2.788,-2.868,-2.709
+31,-2.63,-2.709,-2.55
+32,-2.471,-2.55,-2.392
+33,-2.313,-2.392,-2.233
+34,-2.154,-2.233,-2.075
+35,-1.995,-2.075,-1.916
+36,-1.836,-1.916,-1.757
+37,-1.677,-1.757,-1.598
+38,-1.518,-1.598,-1.438
+39,-1.359,-1.438,-1.279
+40,-1.199,-1.279,-1.119
+41,-1.039,-1.119,-0.96
+42,-0.88,-0.96,-0.8
+43,-0.72,-0.8,-0.64
+44,-0.56,-0.64,-0.48
+45,-0.4,-0.48,-0.32
+46,-0.24,-0.32,-0.16
+47,-0.08,-0.16,0.0
+48,0.08,0.0,0.16
+49,0.24,0.16,0.32
+50,0.4,0.32,0.48
+51,0.56,0.48,0.64
+52,0.72,0.64,0.8
+53,0.88,0.8,0.96
+54,1.039,0.96,1.119
+55,1.199,1.119,1.279
+56,1.359,1.279,1.438
+57,1.518,1.438,1.598
+58,1.677,1.598,1.757
+59,1.836,1.757,1.916
+60,1.995,1.916,2.075
+61,2.154,2.075,2.233
+62,2.313,2.233,2.392
+63,2.471,2.392,2.55
+64,2.63,2.55,2.709
+65,2.788,2.709,2.868
+66,2.947,2.868,3.026
+67,3.105,3.026,3.185
+68,3.264,3.185,3.343
+69,3.422,3.343,3.501
+70,3.581,3.501,3.66
+71,3.739,3.66,3.818
+72,3.897,3.818,3.976
+73,4.055,3.976,4.134
+74,4.213,4.134,4.291
+75,4.37,4.291,4.448
+76,4.526,4.448,4.605
+77,4.682,4.605,4.76
+78,4.838,4.76,4.916
+79,4.993,4.916,5.07
+80,5.148,5.07,5.225
+81,5.302,5.225,5.379
+82,5.456,5.379,5.533
+83,5.609,5.533,5.686
+84,5.763,5.686,5.839
+85,5.915,5.839,5.992
+86,6.068,5.992,6.144
+87,6.22,6.144,6.296
+88,6.372,6.296,6.448
+89,6.523,6.448,6.599
+90,6.674,6.599,6.749
+91,6.824,6.749,6.899
+92,6.974,6.899,7.049
+93,7.123,7.049,7.199
+94,7.271,7.199,7.345
+95,7.419,7.345,7.493

lib/fish_eye/beams.py

@@ -0,0 +1,154 @@
+"""
+Utility functions for converting the beam width header files into
+python arrays.
+
+See : https://github.com/SoundMetrics/aris-file-sdk/tree/master/beam-width-metrics
+
+"""
+
+import glob
+import os
+import re
+
+import pandas as pd
+
+def parse_beam_header_file(fp):
+    """ Utility to parse the beam width header files.
+    """
+
+    # example of what we are trying to parse:
+    # DEFINE_BEAMWIDTH3(0, -13.5735, -13.7893, -13.3577)
+
+    pattern = re.compile(r"^DEFINE_BEAMWIDTH3\D*(\d+), ([-+]?\d*\.\d+), ([-+]?\d*\.\d+), ([-+]?\d*\.\d+)")
+
+    beam_angles = []
+
+    with open(fp) as f:
+        for line in f:
+            m = pattern.match(line)
+            if m:
+
+                beam_num = int(m.group(1))
+                beam_center = float(m.group(2))
+                beam_left = float(m.group(3))
+                beam_right = float(m.group(4))
+
+                beam_angles.append([beam_num, beam_center, beam_left, beam_right])
+
+    # Simple sanity check
+    for i in range(len(beam_angles)):
+        assert beam_angles[i][0] == i
+
+    beam_angles = pd.DataFrame(beam_angles, columns=['beam_num', 'beam_center', 'beam_left', 'beam_right'])
+
+    return beam_angles
+
+
+def convert_beam_header_files(beam_dir):
+    """ Convert the aris-file-sdk/beam-width-metrics directory to pandas data frames.
+    """
+
+    system_beam_angles = {}
+
+    for fp in glob.glob(os.path.join(beam_dir, "BeamWidths*")):
+
+        beam_angles = parse_beam_header_file(fp)
+        name = os.path.splitext(os.path.basename(fp))[0]
+        system_type = name.split("BeamWidths_")[1]
+
+        system_beam_angles[system_type] = beam_angles
+
+    return system_beam_angles
+
+
+def make_csv_files_for_beam_widths(beam_dir, output_dir):
+    """ Convert the aris-file-sdk/beam-width-metrics directory to pandas data frames
+    and save them as csv files.
+    """
+
+    system_beam_angles = convert_beam_header_files(beam_dir)
+
+    for system_type, beam_angles in system_beam_angles.items():
+
+        beam_angles.to_csv(os.path.join(output_dir, system_type + ".csv"), index=False)
+
+
+
+def load_beam_width_data(frame, beam_width_dir):
+    """ Load in the beam spacing file that corresponds to the correct ARIS setup for this frame.
+    """
+
+    system_type = frame.thesystemtype
+    beam_count = frame.BeamCount
+    used_telephoto = frame.largelens
+
+    beam_width_fn = None
+
+    # ARIS 1800
+    if system_type == 0:
+
+        if beam_count == 48:
+
+            if used_telephoto:
+                # ARIS_Telephoto_48
+                beam_width_fn = 'ARIS_Telephoto_48.csv'
+            else:
+                # ARIS1800_1200_48
+                beam_width_fn = 'ARIS1800_1200_48.csv'
+
+        elif beam_count == 96:
+
+            if used_telephoto:
+                # ARIS_Telephoto_96
+                beam_width_fn = 'ARIS_Telephoto_96.csv'
+            else:
+                # ARIS1800_96
+                beam_width_fn = 'ARIS1800_96.csv'
+
+        else:
+            raise ValueEror("Invalid Beam Count %d for ARIS 1800" % (beam_count,))
+
+    # ARIS 3000
+    elif system_type == 1:
+
+        if used_telephoto:
+            raise ValueEror("Don't know telephoto beam widths for ARIS 3000")
+
+        if beam_count == 64:
+            # ARIS3000_64
+            beam_width_fn = 'ARIS3000_64.csv'
+
+        elif beam_count == 128:
+            # ARIS3000_128
+            beam_width_fn = 'ARIS3000_128.csv'
+
+        else:
+            raise ValueEror("Invalid Beam Count %d for ARIS 3000" % (beam_count,))
+
+    # ARIS 1200
+    elif system_type == 2:
+
+        if beam_count != 48:
+            raise ValueEror("Invalid Beam Count %d for ARIS 1200" % (beam_count,))
+
+        if used_telephoto:
+            # ARIS_Telephoto_48
+            beam_width_fn = 'ARIS_Telephoto_48.csv'
+        else:
+            # ARIS1800_1200_48
+            beam_width_fn = 'ARIS1800_1200_48.csv'
+
+    else:
+        raise ValueError("Unknown System Type: %s" % (system_type,))
+
+
+    beam_width_fp = os.path.join(beam_width_dir, beam_width_fn)
+
+    # return pd.read_csv(beam_width_fp)
+    return (pd.read_csv(beam_width_fp), beam_width_fn.replace('.csv', ''))
+
+
+
+
+
+# /Users/GVH/Code/soundmetrics/aris-file-sdk/beam-width-metrics

lib/fish_eye/convert_annotations.py

@@ -0,0 +1,143 @@
+from absl import app
+from absl import flags
+from colorsys import hls_to_rgb
+import json
+import numpy as np
+import os
+import xml.etree.ElementTree as ET
+
+from fish_length import Fish_Length
+from tracker import Tracker
+
+flags.DEFINE_string(
+	'json_dump_path', None, 'Path to json containing annotated clip info.'
+)
+flags.DEFINE_string(
+	'xml_dir', None, 'Directory containing xml annotation files.'
+)
+flags.DEFINE_string(
+	'output_path', None, 'Directory to output clip annotation jsons.'
+)
+flags.mark_flag_as_required('json_dump_path')
+flags.mark_flag_as_required('xml_dir')
+flags.mark_flag_as_required('output_path')
+FLAGS = flags.FLAGS
+
+def get_annotation_from_clip(clip):
+	root = ET.parse(os.path.join(FLAGS.xml_dir, clip['clip_name']+'.xml')).getroot()
+
+	data = {}
+	data['clip_id'] = clip['clip_id']
+	data['aris_filename'] = clip['aris_filename']
+	data['start_frame'] = clip['start_frame']
+	data['end_frame'] = clip['end_frame']
+	data['upstream_direction'] = clip['upstream_direction']
+	data['image_meter_width'] = clip['aris_info']['pixel_meter_size']*clip['aris_info']['xdim']
+
+	# Create image entries
+	frames = []
+	for i in range(int(root.findall('object')[0].findtext('startFrame')), 1 + int(root.findall('object')[0].findtext('endFrame'))):
+		frame = {
+			'frame_num': clip['start_frame'] + i,
+			'fish': []
+		}
+		frames.append(frame)
+
+	fishes = []
+	# Populate images with bboxes
+	for track_id, object in enumerate(root.findall('object')):
+		fish = {}
+		fish['id'] = track_id
+		fish['length'] = -1
+		fish['direction'] = 'N/A'
+		fish['start_frame_index'] = -1
+		fish['end_frame_index'] = -1
+		fish['color'] = Tracker.selectColor(track_id)
+
+		fishes.append(fish)
+
+		last_drawn = None
+		stat_interp = []
+		lengths = []
+		for polygon in object.findall('polygon'):
+			if int(polygon.findtext('pt/l')) == -1:
+				continue
+			
+			index = int(polygon.find('t').text)
+
+			frame = frames[index]
+			
+			frame_entry = {}
+			frame_entry['fish_id'] = track_id
+			frame_entry['bbox'] = None
+			frame_entry['visible'] = 1
+			frame_entry['human_labeled'] = int(polygon.findtext('pt/l'))
+
+			frame['fish'].append(frame_entry)
+			
+			# Determine if polygon is stationary
+			if polygon.findtext('s') is not None and int(polygon.findtext('s')):
+				stat_interp.append(frame_entry)
+			else:
+				frame_entry['bbox'] = list(np.array([int(polygon.findtext('pt/x'))/clip['aris_info']['xdim'], int(polygon.findtext('pt/y'))/clip['aris_info']['ydim'],
+					int(polygon.findall('pt/x')[2].text)/clip['aris_info']['xdim'], int(polygon.findall('pt/y')[1].text)/clip['aris_info']['ydim']]))
+				
+				# Coordinates of greater than 1.1 will cause training to fail
+				if (np.array(frame_entry['bbox']) > 1.1).any():
+					print('Error: Invalid bbox.')
+					frame['fish'].pop()
+					continue
+
+				lengths.append(int(polygon.findall('pt/x')[2].text)-int(polygon.findtext('pt/x')))
+
+				# Interpolate if there are stationary boxes
+				if stat_interp:
+					bbox_interp = last_drawn + np.dot(1 + np.array(range(len(stat_interp)))[:,np.newaxis], (np.array(frame_entry['bbox']) - np.array(last_drawn))[np.newaxis])/(len(stat_interp) + 1)
+					for frame_entry, bbox in zip(stat_interp, bbox_interp):	
+						frame_entry['bbox'] = list(bbox)
+					stat_interp = []
+				last_drawn = frame_entry['bbox']
+			
+			if fish['start_frame_index'] == -1:
+				fish['start_frame_index'] = index
+			fish['end_frame_index'] = index
+
+		if stat_interp:
+			for frame_entry in stat_interp:
+				frame_entry['bbox'] = last_drawn
+
+	data['frames'] = frames
+	data['fish'] = fishes
+
+	# Add track
+	for fish in fishes:
+		for frame_entry in frames[fish['start_frame_index']]['fish']:
+			if frame_entry['fish_id'] == fish['id']:
+				start_bbox = frame_entry['bbox']
+				break
+		else:
+			raise RuntimeWarning(f'Start box of fish {fish["id"]} in {clip["clip_name"]} is not defined.')
+
+		for frame_entry in frames[fish['end_frame_index']]['fish']:
+			if frame_entry['fish_id'] == fish['id']:
+				end_bbox = frame_entry['bbox']
+				break
+		else:
+			raise RuntimeWarning(f'End box of fish {fish["id"]} in {clip["clip_name"]} is not defined.')
+
+		fish['direction'] = Tracker.get_direction(start_bbox, end_bbox)
+
+	return Fish_Length.add_lengths(data)
+
+def main(argv):
+	with open(FLAGS.json_dump_path) as json_file:
+		json_dump = json.load(json_file)
+	
+	for clip in json_dump:
+		data = get_annotation_from_clip(clip)
+
+		with open(os.path.join(FLAGS.output_path, f'{clip["clip_name"]}.json'), 'w') as output_file:
+			json.dump(data, output_file, indent=2)
+
+if __name__ == '__main__':
+	app.run(main)

lib/fish_eye/data_format.md

@@ -0,0 +1,72 @@
+
+We are typically given an ARIS file and a "count file" that contains the human counts of fish at some temporal resolution. The "count file" might be a csv file, a text file, or something else. We'll create a json file that stores this information in a more convenient/universal format:
+
+```
+{   // Information for a single clip
+    "clip_id" :               // Unique id for this clip (perhaps a UUID?)
+    "aris_filename" :         // Path to the ARIS file
+    "clip_name" :             // Basename of annotation files
+    "start_frame" :           // Start frame for this "count event", used to index into the ARIS file
+    "end_frame" :             // End frame for this "count event", used to index into the ARIS file
+    "start_time" :            // Start time in for this "count event" (this should be the sonartimestamp of the start_frame )
+    "end_time " :             // End time for this "count event" (this should be the sonartimestamp of the end_frame )
+    "upstream_direction" :    // Either `left` or `right`
+    "fish": [                  // Should have one entry for each fish
+        {
+            "frame" : ,        // Manual marking frame number
+            "direction" : ,    // Either `left`, `right`, or `undefined`
+            "length" : ,       // Length in meters
+            "x" : ,            // x position of marking
+            "y" : ,            // y position of marking
+        }
+    ],
+    "aris_info" : {            // Needed for generating a warped image from the raw ARIS samples
+        "camera_type" : ,      // ARIS camera type
+        "framerate" : ,        // Frames per second
+        "pixel_meter_size" : , // The size of a pixel in meters
+        "xdim" : ,             // The width of the warped image
+        "ydim" : ,             // The height of the warped image
+        "x_meter_start" : ,    // x start in meters 
+        "y_meter_start" : ,    // y start in meters
+        "x_meter_stop" : ,     // x stop in meters
+        "y_meter_stop' : ,     // y stop in meters
+    }
+}
+```
+
+
+When a sequence of frames are annotated from an ARIS file (i.e. a "clip"), we will produce the following json file:
+
+```
+{   // Annotation information for a single "clip"
+    "clip_id" :                // a unique clip id, should match the `clip_id` in the clip info dictionary above.
+    "aris_filename" :          // the name of the associated aris file
+    "start_frame" :            // Start frame for this "clip", used to index into the ARIS file
+    "end_frame" :              // End frame for this "clip", used to index into the ARIS file
+    "upstream_direction" :     // Either `left` or `right`
+    "clip_meter_width" :       // Width of a frame in meters
+    "clip_meter_height" :      // Height of a frame in meters
+    "frames" : [                                      // Should have one entry for each frame
+        {
+            "frame_num" : ,                           // the frame number from the ARIS file
+            "fish" : [                                // should have one entry for each fish that is present in this frame
+                {
+                    "fish_id" :                       // fish track id
+                    "box" : [xmin, ymin, xmax, ymax]  // in normalized coordinates (multiply by `xdim` and `ydim` to get unnormalized coordinates)
+                    "visible" :                       // 0 means not visible (is this necessary?), 1 means visible
+                    "human_labeled" :                 // 1 or 0 for whether a human did the annotation or if it was interpolated 
+                }
+            ]
+        }
+    ],
+    "fish" : [                        // Should have one entry for each fish
+        {
+            "id" :                    // fish track id (should be unique) (0 based, not unique across clips)
+            "length" :                // computed fish length in meters
+            "direction" :             // computed swimming direction {left, right, none}
+            "start_frame_index" :     // first frame this fish appears in
+            "end_frame_index" :       // last frame this fish appears in 
+            "color" :                 // a unique hex color value for this fish
+        }
+    ]
+}

lib/fish_eye/fish_length.py

@@ -0,0 +1,38 @@
+from collections import defaultdict
+from copy import deepcopy
+import json
+import numpy as np
+
+class Fish_Length:
+    @staticmethod
+    def mean_length(tracks, constant, aux=-1):
+        return [np.mean(track[2] - track[0])*constant for track in tracks]
+
+    @staticmethod
+    def quantile_length(tracks, constant, aux=-1):
+        return [np.quantile(track[2] - track[0], aux)*constant for track in tracks]
+
+    @staticmethod
+    def quantile_diagonal(tracks, constant, aux=-1):
+        return [np.quantile(np.sqrt((track[2] - track[0])**2 + (track[3] - track[1])**2), aux)*constant for track in tracks]
+
+    @staticmethod
+    def add_lengths(json_data, length_fn=quantile_length.__func__, constant=0.8348286633599985, aux=0.8773333335319834, output_path=None):
+        json_data = deepcopy(json_data)
+        
+        tracks = defaultdict(list)
+        for frame in json_data['frames']:
+            for frame_entry in frame['fish']:
+                tracks[frame_entry['fish_id']].append(np.array(frame_entry['bbox']))
+        tracks = [np.array(track).T for _, track in sorted(tracks.items())]
+
+        lengths = np.array(length_fn(tracks, constant*json_data['image_meter_width'], aux=aux))
+        
+        for fish, fish_length in zip(sorted(json_data['fish'], key=lambda k: k['id']), lengths):
+            fish['length'] = fish_length
+        
+        if output_path is not None:
+            with open(output_path,'w') as output:
+                json.dump(json_data, output, indent=2)
+
+        return json_data

lib/fish_eye/pyARIS.py

@@ -0,0 +1,1009 @@
+# -*- coding: utf-8 -*-
+"""
+===================================================
+A python interface for ARIS files
+===================================================
+
+Last modified on: January 31, 2017
+The most recent version can be found at: https://github.com/EminentCodfish/pyARIS
+
+@author: Chris Rillahan
+"""
+
+import struct, array, pytz, datetime, tqdm
+import os
+import subprocess as sp
+from matplotlib import cm as colormap
+from PIL import Image, ImageFont, ImageDraw
+import numpy as np
+from beams import load_beam_width_data
+
+
+class ARIS_File:
+    'This is a class container for the ARIS file headers'
+
+    def __init__(self, filename, version_number, FrameCount, FrameRate, HighResolution, NumRawBeams, SampleRate, SamplesPerChannel, ReceiverGain,
+                 WindowStart, WindowLength, Reverse, SN, strDate, strHeaderID, UserID1, UserID2, UserID3, UserID4, StartFrame,EndFrame,
+                 TimeLapse, RecordInterval, RadioSeconds, FrameInterval, Flags, AuxFlags, Sspd, Flags3D, SoftwareVersion, WaterTemp,
+                 Salinity, PulseLength, TxMode, VersionFGPA, VersionPSuC, ThumbnailFI, FileSize, OptionalHeaderSize, OptionalTailSize,
+                 VersionMinor, LargeLens):
+                     self.filename = filename #Name of the ARIS file
+                     self.version_number = version_number #File format version DDF_05 = 0x05464444
+                     #OBSOLETE: Calculate the number of frames from file size & beams*samples.
+                     self.FrameCount = FrameCount #Total frames in file
+                     #OBSOLETE: See frame header instead.
+                     self.FrameRate = FrameRate #Initial recorded frame rate
+                     #OBSOLETE: See frame header instead.
+                     self.HighResolution = HighResolution #Non-zero if HF, zero if LF
+                     #OBSOLETE: See frame header instead.
+                     self.NumRawBeams = NumRawBeams #ARIS 3000 = 128/64, ARIS 1800 = 96/48, ARIS 1200 = 48
+                     #OBSOLETE: See frame header instead.
+                     self.SampleRate = SampleRate #1/Sample Period
+                     #OBSOLETE: See frame header instead.
+                     self.SamplesPerChannel = SamplesPerChannel #Number of range samples in each beam
+                     #OBSOLETE: See frame header instead.
+                     self.ReceiverGain = ReceiverGain #Relative gain in dB:  0 - 40
+                     #OBSOLETE: See frame header instead.
+                     self.WindowStart = WindowStart #Image window start range in meters (code [0..31] in DIDSON)
+                     #OBSOLETE: See frame header instead.
+                     self.WindowLength = WindowLength #Image window length in meters  (code [0..3] in DIDSON)
+                     #OBSOLETE: See frame header instead.
+                     self.Reverse = Reverse #Non-zero = lens down (DIDSON) or lens up (ARIS), zero = opposite
+                     self.SN = SN  #Sonar serial number
+                     self.strDate = strDate #Date that file was recorded
+                     self.strHeaderID = strHeaderID #User input to identify file in 256 characters
+                     self.UserID1 = UserID1 #User-defined integer quantity
+                     self.UserID2 = UserID2 #User-defined integer quantity
+                     self.UserID3 = UserID3 #User-defined integer quantity
+                     self.UserID4 = UserID4 #User-defined integer quantity
+                     self.StartFrame = StartFrame #First frame number from source file (for DIDSON snippet files)
+                     self.EndFrame = EndFrame #Last frame number from source file (for DIDSON snippet files)
+                     self.TimeLapse = TimeLapse #Non-zero indicates time lapse recording
+                     self.RecordInterval = RecordInterval #Number of frames/seconds between recorded frames
+                     self.RadioSeconds = RadioSeconds #Frames or seconds interval
+                     self.FrameInterval = FrameInterval #Record every Nth frame
+                     self.Flags = Flags #See DDF_04 file format document (OBSOLETE)
+                     self.AuxFlags = AuxFlags #See DDF_04 file format document
+                     #OBSOLETE: See frame header instead.
+                     self.Sspd = Sspd #Sound velocity in water
+                     self.Flags3D = Flags3D #See DDF_04 file format document
+                     self.SoftwareVersion = SoftwareVersion #DIDSON software version that recorded the file
+                     self.WaterTemp = WaterTemp #Water temperature code:  0 = 5-15C, 1 = 15-25C, 2 = 25-35C
+                     self.Salinity = Salinity #Salinity code:  0 = fresh, 1 = brackish, 2 = salt
+                     self.PulseLength = PulseLength #Added for ARIS but not used
+                     self.TxMode = TxMode #Added for ARIS but not used
+                     self.VersionFGPA = VersionFGPA #Reserved for future use
+                     self.VersionPSuC = VersionPSuC #Reserved for future use
+                     self.ThumbnailFI = ThumbnailFI #Frame index of frame used for thumbnail image of file
+                     #OBSOLETE: Do not use; query your filesystem instead.
+                     self.FileSize = FileSize #Total file size in bytes
+                     self.OptionalHeaderSize = OptionalHeaderSize#Reserved for future use (Obsolete, not used)
+                     self.OptionalTailSize = OptionalTailSize #Reserved for future use (Obsolete, not used)
+                     self.VersionMinor = VersionMinor #DIDSON_ADJUSTED_VERSION_MINOR (Obsolete)
+                     self.LargeLens = LargeLens #Non-zero if telephoto lens (large lens, hi-res lens, big lens) is present
+
+    def __len__(self):
+         return self.FrameCount
+
+    def __repr__(self):
+        return 'ARIS File: ' + self.filename
+
+    def info(self):
+        print('Filename: ' + str(self.filename))
+        print('Software Version: ' + str(self.SoftwareVersion))
+        print('ARIS S/N: ' + str(self.SN))
+        print('File size: ' + str(self.FileSize))
+        print('Number of Frames: ' + str(self.FrameCount))
+        print('Beam Count: ' + str(self.NumRawBeams))
+        print('Samples/Beam: ' + str(self.SamplesPerChannel))
+
+class ARIS_Frame(ARIS_File):
+    """This is a class container for the ARIS frame dataPI"""
+
+    def __init__(self, frameindex, frametime, version, status, sonartimestamp, tsday, tshour, tsminute, tssecond, tshsecond, transmitmode,
+                 windowstart, windowlength, threshold, intensity, receivergain, degc1, degc2, humidity, focus, battery, uservalue1, uservalue2,
+                 uservalue3,  uservalue4,  uservalue5, uservalue6, uservalue7, uservalue8,  velocity, depth, altitude, pitch, pitchrate, roll,
+                 rollrate, heading, headingrate, compassheading, compasspitch, compassroll, latitude, longitude, sonarposition, configflags,
+                 beamtilt, targetrange, targetbearing, targetpresent, firmwarerevision, flags, sourceframe, watertemp, timerperiod, sonarx,
+                 sonary, sonarz, sonarpan, sonartilt, sonarroll, panpnnl, tiltpnnl, rollpnnl, vehicletime, timeggk, dateggk, qualityggk, numsatsggk,
+                 dopggk, ehtggk, heavetss, yeargps, monthgps, daygps, hourgps, minutegps, secondgps, hsecondgps, sonarpanoffset, sonartiltoffset,
+                 sonarrolloffset, sonarxoffset, sonaryoffset, sonarzoffset, tmatrix, samplerate, accellx, accelly, accellz, pingmode, frequencyhilow,
+                 pulsewidth, cycleperiod, sampleperiod, transmitenable, framerate, soundspeed, samplesperbeam, enable150v, samplestartdelay, largelens,
+                 thesystemtype, sonarserialnumber, encryptedkey, ariserrorflagsuint, missedpackets, arisappversion, available2, reorderedsamples,
+                 salinity, pressure, batteryvoltage, mainvoltage, switchvoltage, focusmotormoving, voltagechanging, focustimeoutfault, focusovercurrentfault,
+                 focusnotfoundfault, focusstalledfault, fpgatimeoutfault, fpgabusyfault, fpgastuckfault, cputempfault, psutempfault, watertempfault,
+                 humidityfault, pressurefault, voltagereadfault, voltagewritefault, focuscurrentposition, targetpan, targettilt, targetroll, panmotorerrorcode,
+                 tiltmotorerrorcode, rollmotorerrorcode, panabsposition, tiltabsposition, rollabsposition, panaccelx, panaccely, panaccelz, tiltaccelx,
+                 tiltaccely, tiltaccelz, rollaccelx, rollaccely, rollaccelz, appliedsettings, constrainedsettings, invalidsettings, enableinterpacketdelay,
+                 interpacketdelayperiod, uptime, arisappversionmajor, arisappversionminor, gotime, panvelocity, tiltvelocity, rollvelocity, sentinel):
+
+                    self.frameindex = frameindex #Frame number in file
+                    self.frametime = frametime #PC time stamp when recorded; microseconds since epoch (Jan 1st 1970)
+                    self.version = version #ARIS file format version = 0x05464444
+                    self.status = status
+                    self.sonartimestamp = sonartimestamp #On-sonar microseconds since epoch (Jan 1st 1970)
+                    self.tsday = tsday
+                    self.tshour = tshour
+                    self.tsminute = tsminute
+                    self.tssecond = tssecond
+                    self.tshsecond = tshsecond
+                    self.transmitmode = transmitmode
+                    self.windowstart = windowstart #Window start in meters
+                    self.windowlength = windowlength #Window length in meters
+                    self.threshold = threshold
+                    self.intensity = intensity
+                    self.receivergain = receivergain #Note: 0-24 dB
+                    self.degc1 = degc1 #CPU temperature (C)
+                    self.degc2 = degc2 #Power supply temperature (C)
+                    self.humidity = humidity #% relative humidity
+                    self.focus = focus #Focus units 0-1000
+                    self.battery = battery #OBSOLETE: Unused.
+                    self.uservalue1 = uservalue1
+                    self.uservalue2 = uservalue2
+                    self.uservalue3 = uservalue3
+                    self.uservalue4 = uservalue4
+                    self.uservalue5 = uservalue5
+                    self.uservalue6 = uservalue6
+                    self.uservalue7 = uservalue7
+                    self.uservalue8 = uservalue8
+                    self.velocity = velocity # Platform velocity from AUV integration
+                    self.depth = depth # Platform depth from AUV integration
+                    self.altitude = altitude # Platform altitude from AUV integration
+                    self.pitch = pitch # Platform pitch from AUV integration
+                    self.pitchrate = pitchrate # Platform pitch rate from AUV integration
+                    self.roll = roll # Platform roll from AUV integration
+                    self.rollrate = rollrate # Platform roll rate from AUV integration
+                    self.heading = heading # Platform heading from AUV integration
+                    self.headingrate = headingrate # Platform heading rate from AUV integration
+                    self.compassheading = compassheading # Sonar compass heading output
+                    self.compasspitch = compasspitch # Sonar compass pitch output
+                    self.compassroll = compassroll # Sonar compass roll output
+                    self.latitude = latitude # from auxiliary GPS sensor
+                    self.longitude = longitude # from auxiliary GPS sensor
+                    self.sonarposition = sonarposition # special for PNNL
+                    self.configflags = configflags
+                    self.beamtilt = beamtilt
+                    self.targetrange = targetrange
+                    self.targetbearing = targetbearing
+                    self.targetpresent = targetpresent
+                    self.firmwarerevision = firmwarerevision #OBSOLETE: Unused.
+                    self.flags = flags
+                    self.sourceframe = sourceframe # Source file frame number for CSOT output files
+                    self.watertemp = watertemp # Water temperature from housing temperature sensor
+                    self.timerperiod = timerperiod
+                    self.sonarx = sonarx # Sonar X location for 3D processing
+                    self.sonary = sonary # Sonar Y location for 3D processing
+                    self.sonayz = sonarz # Sonar Z location for 3D processing
+                    self.sonarpan = sonarpan # X2 pan output
+                    self.sonartilt = sonartilt # X2 tilt output
+                    self.sonarroll = sonarroll # X2 roll output                                                                                                                       **** End of DDF_03 frame header data ****
+                    self.panpnnl = panpnnl
+                    self.tiltpnnl = tiltpnnl
+                    self.rollpnnl = rollpnnl
+                    self.vehicletime = vehicletime # special for Bluefin Robotics HAUV or other AUV integration
+                    self.timeggk = timeggk # GPS output from NMEA GGK message
+                    self.dateggk = dateggk # GPS output from NMEA GGK message
+                    self.qualityggk = qualityggk # GPS output from NMEA GGK message
+                    self.numsatsggk = numsatsggk # GPS output from NMEA GGK message
+                    self.dopggk = dopggk # GPS output from NMEA GGK message
+                    self.ehtggk = ehtggk # GPS output from NMEA GGK message
+                    self.heavetss = heavetss # external sensor
+                    self.yeargps = yeargps # GPS year output
+                    self.monthgps = monthgps # GPS month output
+                    self.daygps = daygps # GPS day output
+                    self.hourgps = hourgps # GPS hour output
+                    self.minutegps = minutegps # GPS minute output
+                    self.secondgps = secondgps # GPS second output
+                    self.hsecondgps = hsecondgps # GPS 1/100th second output
+                    self.sonarpanoffset = sonarpanoffset # Sonar mount location pan offset for 3D processing
+                    self.sonartiltoffset = sonartiltoffset # Sonar mount location tilt offset for 3D processing
+                    self.sonarrolloffset = sonarrolloffset # Sonar mount location roll offset for 3D processing
+                    self.sonarxoffset = sonarxoffset # Sonar mount location X offset for 3D processing
+                    self.sonaryoffset = sonaryoffset # Sonar mount location Y offset for 3D processing
+                    self.sonarzoffset = sonarzoffset # Sonar mount location Z offset for 3D processing
+                    self.tmatirx = tmatrix # 3D processing transformation matrix
+                    self.samplerate = samplerate # Calculated as 1e6/SamplePeriod
+                    self.accellx = accellx # X-axis sonar acceleration
+                    self.accelly = accelly # Y-axis sonar acceleration
+                    self.accellz = accellz # Z-axis sonar acceleration
+                    self.pingmode = pingmode # ARIS ping mode [1..12]
+                    self.frequencyhilow = frequencyhilow # 1 = HF, 0 = LF
+                    self.pulsewidth = pulsewidth # Width of transmit pulse in usec, [4..100]
+                    self.cycleperiod = cycleperiod # Ping cycle time in usec, [1802..65535]
+                    self.sampleperiod = sampleperiod # Downrange sample rate in usec, [4..100]
+                    self.tranmitenable = transmitenable # 1 = Transmit ON, 0 = Transmit OFF
+                    self.framerate = framerate # Instantaneous frame rate between frame N and frame N-1
+                    self.soundspeed = soundspeed # Sound velocity in water calculated from water temperature and salinity setting
+                    self.samplesperbeam = samplesperbeam # Number of downrange samples in each beam
+                    self.enable150v = enable150v # 1 = 150V ON (Max Power), 0 = 150V OFF (Min Power, 12V)
+                    self.samplestartdelay = samplestartdelay # Delay from transmit until start of sampling (window start) in usec, [930..65535]
+                    self.largelens = largelens # 1 = telephoto lens (large lens, big lens, hi-res lens) present
+                    self.thesystemtype = thesystemtype # 1 = ARIS 3000, 0 = ARIS 1800, 2 = ARIS 1200
+                    self.sonarserialnumber = sonarserialnumber # Sonar serial number as labeled on housing
+                    self.encryptedkey = encryptedkey # Reserved for future use
+                    self.ariserrorflagsuint = ariserrorflagsuint # Error flag code bits
+                    self.missedpackets = missedpackets # Missed packet count for Ethernet statistics reporting
+                    self.arisappversion = arisappversion # Version number of ArisApp sending frame data
+                    self.available2 = available2 # Reserved for future use
+                    self.reorderedsamples = reorderedsamples # 1 = frame data already ordered into [beam,sample] array, 0 = needs reordering
+                    self.salinity = salinity # Water salinity code:  0 = fresh, 15 = brackish, 35 = salt
+                    self.pressure = pressure # Depth sensor output in meters (psi)
+                    self.batteryvoltage = batteryvoltage # Battery input voltage before power steering
+                    self.mainvoltage = mainvoltage # Main cable input voltage before power steering
+                    self.switchvoltage = switchvoltage # Input voltage after power steering
+                    self.focusmotormoving = focusmotormoving # Added 14-Aug-2012 for AutomaticRecording
+                    self.voltagechanging = voltagechanging # Added 16-Aug (first two bits = 12V, second two bits = 150V, 00 = not changing, 01 = turning on, 10 = turning off)
+                    self.focustimeoutfault = focustimeoutfault
+                    self.focusovercurrentfault = focusovercurrentfault
+                    self.focusnotfoundfault = focusnotfoundfault
+                    self.focusstalledfault = focusstalledfault
+                    self.fpgatimeoutfault = fpgatimeoutfault
+                    self.fpgabusyfault = fpgabusyfault
+                    self.fpgastuckfault = fpgastuckfault
+                    self.cputempfault = cputempfault
+                    self.psutempfault = psutempfault
+                    self.watertempfault = watertempfault
+                    self.humidityfault = humidityfault
+                    self.pressurefault = pressurefault
+                    self.voltagereadfault = voltagereadfault
+                    self.voltagewritefault = voltagewritefault
+                    self.focuscurrentposition = focuscurrentposition # Focus shaft current position in motor units [0.1000]
+                    self.targetpan = targetpan # Commanded pan position
+                    self.targettilt = targettilt # Commanded tilt position
+                    self.targetroll = targetroll # Commanded roll position
+                    self.panmotorerrorcode = panmotorerrorcode
+                    self.tiltmotorerrorcode = tiltmotorerrorcode
+                    self.rollmotorerrorcode = rollmotorerrorcode
+                    self.panabsposition = panabsposition # Low-resolution magnetic encoder absolute pan position
+                    self.tiltabsposition = tiltabsposition # Low-resolution magnetic encoder absolute tilt position
+                    self.rollabsposition = rollabsposition # Low-resolution magnetic encoder absolute roll position
+                    self.panaccelx = panaccelx # Accelerometer outputs from AR2 CPU board sensor
+                    self.panaccely = panaccely
+                    self.panaccelz = panaccelz
+                    self.tiltaccelx = tiltaccelx
+                    self.tiltaccely = tiltaccely
+                    self.tiltaccelz = tiltaccelz
+                    self.rollaccelx = rollaccelx
+                    self.rollaccely = rollaccely
+                    self.rollccelz = rollaccelz
+                    self.appliedsettings = appliedsettings # Cookie indices for command acknowlege in frame header
+                    self.constrainedsettings = constrainedsettings
+                    self.invalidsettings = invalidsettings
+                    self.enableinterpacketdelay = enableinterpacketdelay # If true delay is added between sending out image data packets
+                    self.interpacketdelayperiod = interpacketdelayperiod # packet delay factor in us (does not include function overhead time)
+                    self.uptime = uptime # Total number of seconds sonar has been running
+                    self.arisappverionmajor = arisappversionmajor # Major version number
+                    self.arisappversionminor = arisappversionminor # Minor version number
+                    self.gotime = gotime # Sonar time when frame cycle is initiated in hardware
+                    self.panvelocity = panvelocity # AR2 pan velocity in degrees/second
+                    self.tiltvelocity = tiltvelocity # AR2 tilt velocity in degrees/second
+                    self.rollvelocity = rollvelocity # AR2 roll velocity in degrees/second
+                    self.sentinel = sentinel # Used to measure the frame header size
+
+    def __repr__(self):
+        return 'ARIS Frame Number: ' + str(self.frameindex)
+
+    def info(self):
+        print('Frame Number: ' + str(self.frameindex))
+        print('Frame Time: ' + str(datetime.datetime.fromtimestamp(self.sonartimestamp/1000000, pytz.timezone('UTC')).strftime('%Y-%m-%d %H:%M:%S.%f')))
+        print('Frame Rate: ' + str(self.framerate))
+        print('Window Start: ' + str(self.windowstart))
+        print('Window Length: ' + str(self.windowlength))
+        print('Ping Mode: ' + str(self.pingmode))
+        print('Frequency: ' + str(self.frequencyhilow))
+
+
+def DataImport(filename, startFrame = 1, frameBuffer = 0):
+    """DataImport reads in the file specified by the filename.  The function populates
+    a ARIS_File data structure.  This function then calls the FrameRead() method
+    to load a starting frame.
+
+    Parameters
+    -----------
+    filename    : Input file (*.aris)
+    startFrame  : The first frame to be populated into the data structure
+    frameBuffer : This parameter is passed into the FrameRead method.  It adds a
+        specified number of pixels around the edges of the remapped frame.
+
+    Returns
+    -------
+    output_data : a ARIS_File data structure
+    frame : An ARIS_Frame data structure
+
+    Notes
+    -------
+    Basic frame attributes can be found by calling the file.info() method.
+    A list of all the frames attributes can be found by using dir(file), some
+        of these may or may not be used by the ARIS.
+    """
+
+    try:
+        data = open(filename, 'rb')
+    except:
+        print('File Error: An error occurred trying to read the file.')
+        raise
+
+    #Start reading file header
+    version_number      = struct.unpack('I', data.read(4))[0]
+    FrameCount          = struct.unpack('I', data.read(4))[0]
+    FrameRate           = struct.unpack('I', data.read(4))[0]
+    HighResolution      = struct.unpack('I', data.read(4))[0]
+    NumRawBeams         = struct.unpack('I', data.read(4))[0]
+    SampleRate          = struct.unpack('f', data.read(4))[0]
+    SamplesPerChannel   = struct.unpack('I', data.read(4))[0]
+    ReceiverGain        = struct.unpack('I', data.read(4))[0]
+    WindowStart         = struct.unpack('f', data.read(4))[0]
+    WindowLength        = struct.unpack('f', data.read(4))[0]
+    Reverse             = struct.unpack('I', data.read(4))[0]
+    SN                  = struct.unpack('I', data.read(4))[0]
+    strDate             = struct.unpack('32s', data.read(32))[0]
+    strHeaderID         = struct.unpack('256s', data.read(256))[0]
+    UserID1             = struct.unpack('i', data.read(4))[0]
+    UserID2             = struct.unpack('i', data.read(4))[0]
+    UserID3             = struct.unpack('i', data.read(4))[0]
+    UserID4             = struct.unpack('i', data.read(4))[0]
+    StartFrame          = struct.unpack('I', data.read(4))[0]
+    EndFrame            = struct.unpack('I', data.read(4))[0]
+    TimeLapse           = struct.unpack('I', data.read(4))[0]
+    RecordInterval      = struct.unpack('I', data.read(4))[0]
+    RadioSeconds        = struct.unpack('I', data.read(4))[0]
+    FrameInterval       = struct.unpack('I', data.read(4))[0]
+    Flags               = struct.unpack('I', data.read(4))[0]
+    AuxFlags            = struct.unpack('I', data.read(4))[0]
+    Sspd                = struct.unpack('I', data.read(4))[0]
+    Flags3D             = struct.unpack('I', data.read(4))[0]
+    SoftwareVersion     = struct.unpack('I', data.read(4))[0]
+    WaterTemp           = struct.unpack('I', data.read(4))[0]
+    Salinity            = struct.unpack('I', data.read(4))[0]
+    PulseLength         = struct.unpack('I', data.read(4))[0]
+    TxMode              = struct.unpack('I', data.read(4))[0]
+    VersionFGPA         = struct.unpack('I', data.read(4))[0]
+    VersionPSuC         = struct.unpack('I', data.read(4))[0]
+    ThumbnailFI         = struct.unpack('I', data.read(4))[0]
+    FileSize            = struct.unpack('Q', data.read(8))[0]
+    OptionalHeaderSize  = struct.unpack('Q', data.read(8))[0]
+    OptionalTailSize    = struct.unpack('Q', data.read(8))[0]
+    VersionMinor        = struct.unpack('I', data.read(4))[0]
+    LargeLens           = struct.unpack('I', data.read(4))[0]
+
+    #Create data structure
+    output_data = ARIS_File(filename, version_number, FrameCount, FrameRate, HighResolution, NumRawBeams, SampleRate, SamplesPerChannel, ReceiverGain,
+                 WindowStart, WindowLength, Reverse, SN, strDate, strHeaderID, UserID1, UserID2, UserID3, UserID4, StartFrame,EndFrame,
+                 TimeLapse, RecordInterval, RadioSeconds, FrameInterval, Flags, AuxFlags, Sspd, Flags3D, SoftwareVersion, WaterTemp,
+                 Salinity, PulseLength, TxMode, VersionFGPA, VersionPSuC, ThumbnailFI, FileSize, OptionalHeaderSize, OptionalTailSize,
+                 VersionMinor, LargeLens)
+
+    #Close data file
+    data.close()
+
+    #Create an empty container for the lookup table
+    output_data.LUP = None
+
+    #Load the first frame
+    frame = FrameRead(output_data, startFrame)
+
+    #Return the data structure
+    return output_data, frame
+
+def FrameRead(ARIS_data, frameIndex, frameBuffer = None):
+    """The FrameRead function loads in the specified frame data from the raw ARIS data.
+    The function then calls the remapARIS() function which remaps the raw data into
+    a 2D real world projection.
+
+    Parameters
+    -----------
+    ARIS_data : ARIS data structure returned via pyARIS.DataImport()
+    frameIndex : frame number
+    frameBuffer : This parameter add a specified number of pixels around the edges
+                    of the remapped frame.
+
+    Returns
+    -------
+    output : a frame data structure
+
+    Notes
+    -------
+    Basic frame attributes can be found by calling the frame.info() method.
+    A list of all the frames attributes can be found by using dir(frame), some
+        of these may or may not be used by the ARIS.
+    """
+
+    FrameSize = ARIS_data.NumRawBeams*ARIS_data.SamplesPerChannel
+
+    frameoffset = (1024+(frameIndex*(1024+(FrameSize))))
+
+    data = open(ARIS_data.filename, 'rb')
+    data.seek(frameoffset, 0)
+
+    frameindex          = struct.unpack('I', data.read(4))[0] #Frame number in file
+    frametime           = struct.unpack('Q', data.read(8))[0] #PC time stamp when recorded; microseconds since epoch (Jan 1st 1970)
+    version             = struct.unpack('I', data.read(4))[0] #ARIS file format version = 0x05464444
+    status              = struct.unpack('I', data.read(4))[0]
+    sonartimestamp      = struct.unpack('Q', data.read(8))[0] #On-sonar microseconds since epoch (Jan 1st 1970)
+    tsday               = struct.unpack('I', data.read(4))[0]
+    tshour              = struct.unpack('I', data.read(4))[0]
+    tsminute            = struct.unpack('I', data.read(4))[0]
+    tssecond            = struct.unpack('I', data.read(4))[0]
+    tshsecond           = struct.unpack('I', data.read(4))[0]
+    transmitmode        = struct.unpack('I', data.read(4))[0]
+    windowstart         = struct.unpack('f', data.read(4))[0] #Window start in meters
+    windowlength        = struct.unpack('f', data.read(4))[0] #Window length in meters
+    threshold           = struct.unpack('I', data.read(4))[0]
+    intensity           = struct.unpack('i', data.read(4))[0]
+    receivergain        = struct.unpack('I', data.read(4))[0] #Note: 0-24 dB
+    degc1               = struct.unpack('I', data.read(4))[0] #CPU temperature (C)
+    degc2               = struct.unpack('I', data.read(4))[0] #Power supply temperature (C)
+    humidity            = struct.unpack('I', data.read(4))[0] #% relative humidity
+    focus               = struct.unpack('I', data.read(4))[0] #Focus units 0-1000
+    battery             = struct.unpack('I', data.read(4))[0] #OBSOLETE: Unused.
+    uservalue1          = struct.unpack('f', data.read(4))[0]
+    uservalue2          = struct.unpack('f', data.read(4))[0]
+    uservalue3          = struct.unpack('f', data.read(4))[0]
+    uservalue4          = struct.unpack('f', data.read(4))[0]
+    uservalue5          = struct.unpack('f', data.read(4))[0]
+    uservalue6          = struct.unpack('f', data.read(4))[0]
+    uservalue7          = struct.unpack('f', data.read(4))[0]
+    uservalue8          = struct.unpack('f', data.read(4))[0]
+    velocity            = struct.unpack('f', data.read(4))[0] # Platform velocity from AUV integration
+    depth               = struct.unpack('f', data.read(4))[0] # Platform depth from AUV integration
+    altitude            = struct.unpack('f', data.read(4))[0] # Platform altitude from AUV integration
+    pitch               = struct.unpack('f', data.read(4))[0] # Platform pitch from AUV integration
+    pitchrate           = struct.unpack('f', data.read(4))[0] # Platform pitch rate from AUV integration
+    roll                = struct.unpack('f', data.read(4))[0] # Platform roll from AUV integration
+    rollrate            = struct.unpack('f', data.read(4))[0] # Platform roll rate from AUV integration
+    heading             = struct.unpack('f', data.read(4))[0] # Platform heading from AUV integration
+    headingrate         = struct.unpack('f', data.read(4))[0] # Platform heading rate from AUV integration
+    compassheading      = struct.unpack('f', data.read(4))[0] # Sonar compass heading output
+    compasspitch        = struct.unpack('f', data.read(4))[0] # Sonar compass pitch output
+    compassroll         = struct.unpack('f', data.read(4))[0] # Sonar compass roll output
+    latitude            = struct.unpack('d', data.read(8))[0] # from auxiliary GPS sensor
+    longitude           = struct.unpack('d', data.read(8))[0] # from auxiliary GPS sensor
+    sonarposition       = struct.unpack('f', data.read(4))[0] # special for PNNL
+    configflags         = struct.unpack('I', data.read(4))[0]
+    beamtilt            = struct.unpack('f', data.read(4))[0]
+    targetrange         = struct.unpack('f', data.read(4))[0]
+    targetbearing       = struct.unpack('f', data.read(4))[0]
+    targetpresent       = struct.unpack('I', data.read(4))[0]
+    firmwarerevision    = struct.unpack('I', data.read(4))[0] #OBSOLETE: Unused.
+    flags               = struct.unpack('I', data.read(4))[0]
+    sourceframe         = struct.unpack('I', data.read(4))[0] # Source file frame number for CSOT output files
+    watertemp           = struct.unpack('f', data.read(4))[0] # Water temperature from housing temperature sensor
+    timerperiod         = struct.unpack('I', data.read(4))[0]
+    sonarx              = struct.unpack('f', data.read(4))[0] # Sonar X location for 3D processing
+    sonary              = struct.unpack('f', data.read(4))[0] # Sonar Y location for 3D processing
+    sonarz              = struct.unpack('f', data.read(4))[0] # Sonar Z location for 3D processing
+    sonarpan            = struct.unpack('f', data.read(4))[0] # X2 pan output
+    sonartilt           = struct.unpack('f', data.read(4))[0] # X2 tilt output
+    sonarroll           = struct.unpack('f', data.read(4))[0] # X2 roll output                                                                                                                       **** End of DDF_03 frame header data ****
+    panpnnl             = struct.unpack('f', data.read(4))[0]
+    tiltpnnl            = struct.unpack('f', data.read(4))[0]
+    rollpnnl            = struct.unpack('f', data.read(4))[0]
+    vehicletime         = struct.unpack('d', data.read(8))[0] # special for Bluefin Robotics HAUV or other AUV integration
+    timeggk             = struct.unpack('f', data.read(4))[0] # GPS output from NMEA GGK message
+    dateggk             = struct.unpack('I', data.read(4))[0] # GPS output from NMEA GGK message
+    qualityggk          = struct.unpack('I', data.read(4))[0] # GPS output from NMEA GGK message
+    numsatsggk          = struct.unpack('I', data.read(4))[0] # GPS output from NMEA GGK message
+    dopggk              = struct.unpack('f', data.read(4))[0] # GPS output from NMEA GGK message
+    ehtggk              = struct.unpack('f', data.read(4))[0] # GPS output from NMEA GGK message
+    heavetss            = struct.unpack('f', data.read(4))[0] # external sensor
+    yeargps             = struct.unpack('I', data.read(4))[0] # GPS year output
+    monthgps            = struct.unpack('I', data.read(4))[0] # GPS month output
+    daygps              = struct.unpack('I', data.read(4))[0] # GPS day output
+    hourgps             = struct.unpack('I', data.read(4))[0] # GPS hour output
+    minutegps           = struct.unpack('I', data.read(4))[0] # GPS minute output
+    secondgps           = struct.unpack('I', data.read(4))[0] # GPS second output
+    hsecondgps          = struct.unpack('I', data.read(4))[0] # GPS 1/100th second output
+    sonarpanoffset      = struct.unpack('f', data.read(4))[0] # Sonar mount location pan offset for 3D processing
+    sonartiltoffset     = struct.unpack('f', data.read(4))[0] # Sonar mount location tilt offset for 3D processing
+    sonarrolloffset     = struct.unpack('f', data.read(4))[0] # Sonar mount location roll offset for 3D processing
+    sonarxoffset        = struct.unpack('f', data.read(4))[0] # Sonar mount location X offset for 3D processing
+    sonaryoffset        = struct.unpack('f', data.read(4))[0] # Sonar mount location Y offset for 3D processing
+    sonarzoffset        = struct.unpack('f', data.read(4))[0] # Sonar mount location Z offset for 3D processing
+    tmatrix = array.array('f')                                # 3D processing transformation matrix
+    for i in range(16):
+        tmatrix.append(struct.unpack('f', data.read(4))[0])
+    samplerate          = struct.unpack('f', data.read(4))[0] # Calculated as 1e6/SamplePeriod
+    accellx             = struct.unpack('f', data.read(4))[0] # X-axis sonar acceleration
+    accelly             = struct.unpack('f', data.read(4))[0] # Y-axis sonar acceleration
+    accellz             = struct.unpack('f', data.read(4))[0] # Z-axis sonar acceleration
+    pingmode            = struct.unpack('I', data.read(4))[0] # ARIS ping mode [1..12]
+    frequencyhilow      = struct.unpack('I', data.read(4))[0] # 1 = HF, 0 = LF
+    pulsewidth          = struct.unpack('I', data.read(4))[0] # Width of transmit pulse in usec, [4..100]
+    cycleperiod         = struct.unpack('I', data.read(4))[0] # Ping cycle time in usec, [1802..65535]
+    sampleperiod        = struct.unpack('I', data.read(4))[0] # Downrange sample rate in usec, [4..100]
+    transmitenable      = struct.unpack('I', data.read(4))[0] # 1 = Transmit ON, 0 = Transmit OFF
+    framerate           = struct.unpack('f', data.read(4))[0] # Instantaneous frame rate between frame N and frame N-1
+    soundspeed          = struct.unpack('f', data.read(4))[0] # Sound velocity in water calculated from water temperature and salinity setting
+    samplesperbeam      = struct.unpack('I', data.read(4))[0] # Number of downrange samples in each beam
+    enable150v          = struct.unpack('I', data.read(4))[0] # 1 = 150V ON (Max Power), 0 = 150V OFF (Min Power, 12V)
+    samplestartdelay    = struct.unpack('I', data.read(4))[0] # Delay from transmit until start of sampling (window start) in usec, [930..65535]
+    largelens           = struct.unpack('I', data.read(4))[0] # 1 = telephoto lens (large lens, big lens, hi-res lens) present
+    thesystemtype       = struct.unpack('I', data.read(4))[0] # 1 = ARIS 3000, 0 = ARIS 1800, 2 = ARIS 1200
+    sonarserialnumber   = struct.unpack('I', data.read(4))[0] # Sonar serial number as labeled on housing
+    encryptedkey        = struct.unpack('Q', data.read(8))[0] # Reserved for future use
+    ariserrorflagsuint  = struct.unpack('I', data.read(4))[0] # Error flag code bits
+    missedpackets       = struct.unpack('I', data.read(4))[0] # Missed packet count for Ethernet statistics reporting
+    arisappversion      = struct.unpack('I', data.read(4))[0] # Version number of ArisApp sending frame data
+    available2          = struct.unpack('I', data.read(4))[0] # Reserved for future use
+    reorderedsamples    = struct.unpack('I', data.read(4))[0] # 1 = frame data already ordered into [beam,sample] array, 0 = needs reordering
+    salinity            = struct.unpack('I', data.read(4))[0] # Water salinity code:  0 = fresh, 15 = brackish, 35 = salt
+    pressure            = struct.unpack('f', data.read(4))[0] # Depth sensor output in meters (psi)
+    batteryvoltage      = struct.unpack('f', data.read(4))[0] # Battery input voltage before power steering
+    mainvoltage         = struct.unpack('f', data.read(4))[0] # Main cable input voltage before power steering
+    switchvoltage       = struct.unpack('f', data.read(4))[0] # Input voltage after power steering
+    focusmotormoving    = struct.unpack('I', data.read(4))[0] # Added 14-Aug-2012 for AutomaticRecording
+    voltagechanging     = struct.unpack('I', data.read(4))[0] # Added 16-Aug (first two bits = 12V, second two bits = 150V, 00 = not changing, 01 = turning on, 10 = turning off)
+    focustimeoutfault   = struct.unpack('I', data.read(4))[0]
+    focusovercurrentfault = struct.unpack('I', data.read(4))[0]
+    focusnotfoundfault  = struct.unpack('I', data.read(4))[0]
+    focusstalledfault   = struct.unpack('I', data.read(4))[0]
+    fpgatimeoutfault    = struct.unpack('I', data.read(4))[0]
+    fpgabusyfault       = struct.unpack('I', data.read(4))[0]
+    fpgastuckfault      = struct.unpack('I', data.read(4))[0]
+    cputempfault        = struct.unpack('I', data.read(4))[0]
+    psutempfault        = struct.unpack('I', data.read(4))[0]
+    watertempfault      = struct.unpack('I', data.read(4))[0]
+    humidityfault       = struct.unpack('I', data.read(4))[0]
+    pressurefault       = struct.unpack('I', data.read(4))[0]
+    voltagereadfault    = struct.unpack('I', data.read(4))[0]
+    voltagewritefault   = struct.unpack('I', data.read(4))[0]
+    focuscurrentposition = struct.unpack('I', data.read(4))[0] # Focus shaft current position in motor units [0.1000]
+    targetpan           = struct.unpack('f', data.read(4))[0] # Commanded pan position
+    targettilt          = struct.unpack('f', data.read(4))[0] # Commanded tilt position
+    targetroll          = struct.unpack('f', data.read(4))[0] # Commanded roll position
+    panmotorerrorcode   = struct.unpack('I', data.read(4))[0]
+    tiltmotorerrorcode  = struct.unpack('I', data.read(4))[0]
+    rollmotorerrorcode  = struct.unpack('I', data.read(4))[0]
+    panabsposition      = struct.unpack('f', data.read(4))[0] # Low-resolution magnetic encoder absolute pan position
+    tiltabsposition     = struct.unpack('f', data.read(4))[0] # Low-resolution magnetic encoder absolute tilt position
+    rollabsposition     = struct.unpack('f', data.read(4))[0] # Low-resolution magnetic encoder absolute roll position
+    panaccelx           = struct.unpack('f', data.read(4))[0] # Accelerometer outputs from AR2 CPU board sensor
+    panaccely           = struct.unpack('f', data.read(4))[0]
+    panaccelz           = struct.unpack('f', data.read(4))[0]
+    tiltaccelx          = struct.unpack('f', data.read(4))[0]
+    tiltaccely          = struct.unpack('f', data.read(4))[0]
+    tiltaccelz          = struct.unpack('f', data.read(4))[0]
+    rollaccelx          = struct.unpack('f', data.read(4))[0]
+    rollaccely          = struct.unpack('f', data.read(4))[0]
+    rollaccelz          = struct.unpack('f', data.read(4))[0]
+    appliedsettings     = struct.unpack('I', data.read(4))[0] # Cookie indices for command acknowlege in frame header
+    constrainedsettings = struct.unpack('I', data.read(4))[0]
+    invalidsettings     = struct.unpack('I', data.read(4))[0]
+    enableinterpacketdelay = struct.unpack('I', data.read(4))[0] # If true delay is added between sending out image data packets
+    interpacketdelayperiod = struct.unpack('I', data.read(4))[0] # packet delay factor in us (does not include function overhead time)
+    uptime              = struct.unpack('I', data.read(4))[0] # Total number of seconds sonar has been running
+    arisappversionmajor = struct.unpack('H', data.read(2))[0] # Major version number
+    arisappversionminor = struct.unpack('H', data.read(2))[0] # Minor version number
+    gotime              = struct.unpack('Q', data.read(8))[0] # Sonar time when frame cycle is initiated in hardware
+    panvelocity         = struct.unpack('f', data.read(4))[0] # AR2 pan velocity in degrees/second
+    tiltvelocity        = struct.unpack('f', data.read(4))[0] # AR2 tilt velocity in degrees/second
+    rollvelocity        = struct.unpack('f', data.read(4))[0] # AR2 roll velocity in degrees/second
+    sentinel            = struct.unpack('I', data.read(4))[0] # Used to measure the frame header size
+
+    #Create the ARIS_frame data structure and add the meta-data
+    output = ARIS_Frame(frameindex, frametime, version, status, sonartimestamp, tsday, tshour, tsminute, tssecond, tshsecond, transmitmode,
+                 windowstart, windowlength, threshold, intensity, receivergain, degc1, degc2, humidity, focus, battery, uservalue1, uservalue2,
+                 uservalue3,  uservalue4,  uservalue5, uservalue6, uservalue7, uservalue8,  velocity, depth, altitude, pitch, pitchrate, roll,
+                 rollrate, heading, headingrate, compassheading, compasspitch, compassroll, latitude, longitude, sonarposition, configflags,
+                 beamtilt, targetrange, targetbearing, targetpresent, firmwarerevision, flags, sourceframe, watertemp, timerperiod, sonarx,
+                 sonary, sonarz, sonarpan, sonartilt, sonarroll, panpnnl, tiltpnnl, rollpnnl, vehicletime, timeggk, dateggk, qualityggk, numsatsggk,
+                 dopggk, ehtggk, heavetss, yeargps, monthgps, daygps, hourgps, minutegps, secondgps, hsecondgps, sonarpanoffset, sonartiltoffset,
+                 sonarrolloffset, sonarxoffset, sonaryoffset, sonarzoffset, tmatrix, samplerate, accellx, accelly, accellz, pingmode, frequencyhilow,
+                 pulsewidth, cycleperiod, sampleperiod, transmitenable, framerate, soundspeed, samplesperbeam, enable150v, samplestartdelay, largelens,
+                 thesystemtype, sonarserialnumber, encryptedkey, ariserrorflagsuint, missedpackets, arisappversion, available2, reorderedsamples,
+                 salinity, pressure, batteryvoltage, mainvoltage, switchvoltage, focusmotormoving, voltagechanging, focustimeoutfault, focusovercurrentfault,
+                 focusnotfoundfault, focusstalledfault, fpgatimeoutfault, fpgabusyfault, fpgastuckfault, cputempfault, psutempfault, watertempfault,
+                 humidityfault, pressurefault, voltagereadfault, voltagewritefault, focuscurrentposition, targetpan, targettilt, targetroll, panmotorerrorcode,
+                 tiltmotorerrorcode, rollmotorerrorcode, panabsposition, tiltabsposition, rollabsposition, panaccelx, panaccely, panaccelz, tiltaccelx,
+                 tiltaccely, tiltaccelz, rollaccelx, rollaccely, rollaccelz, appliedsettings, constrainedsettings, invalidsettings, enableinterpacketdelay,
+                 interpacketdelayperiod, uptime, arisappversionmajor, arisappversionminor, gotime, panvelocity, tiltvelocity, rollvelocity, sentinel)
+
+
+    #Add the frame data
+    if pingmode in [1,2]:
+        ARIS_Frame.BeamCount = 48
+    if pingmode in [3,4,5]:
+        ARIS_Frame.BeamCount = 96
+    if pingmode in [6,7,8]:
+        ARIS_Frame.BeamCount = 64
+    if pingmode in [9,10,11,12]:
+        ARIS_Frame.BeamCount = 128
+
+    data.seek(frameoffset+1024, 0)
+    frame = np.empty([samplesperbeam, ARIS_Frame.BeamCount], dtype=float)
+    for r in range(len(frame)):
+        for c in range(len(frame[r])):
+            frame[r][c] = struct.unpack('B', data.read(1))[0]
+    frame = np.fliplr(frame)
+
+    #Remap the data from 0-255 to 0-80 dB
+    #remap = lambda t: (t * 80)/255
+    #vfunc = np.vectorize(remap)
+    #frame = vfunc(frame)
+
+    output.frame_data = frame
+    output.WinStart = output.samplestartdelay * 0.000001 * output.soundspeed / 2
+
+    #Close the data file
+    data.close()
+
+    return output
+
+
+def get_box_for_sample(beam_num, bin_num, frame, beam_data):
+    """ Get the box coordinates (in meters) for a sample.
+    This is a non-axis aligned box.
+    Returns:
+        back left, back right, front right, front left
+    """
+
+    sample_start_delay = frame.samplestartdelay # usec
+    sound_speed = frame.soundspeed # meters / sec
+    sample_period = frame.sampleperiod # usec
+
+    WindowStart = sample_start_delay * 1e-6 * sound_speed / 2 # meters
+    sample_length = sample_period * 1e-6 * sound_speed / 2. # meters
+
+    bin_front_edge_distance = WindowStart + sample_length * bin_num
+    bin_back_edge_distance = WindowStart + sample_length* (bin_num + 1)
+
+    beam_angles = beam_data[beam_data['beam_num'] == beam_num]
+    a1 = beam_angles['beam_left'].iloc[0]
+    a2 = beam_angles['beam_right'].iloc[0]
+    c = beam_angles['beam_center'].iloc[0]
+
+    # I can't figure out whats going on with the beam spacing in the files.
+    # Once the center point crosses 0, the ordering of the left and right angles swap...
+    # For now I'll assume the y axis is the common line. Positive angles go to the left,
+    # negative angles go to the right
+    left = max(a1, a2)
+    right = min(a1, a2)
+
+    # Left Edge
+    beam_left_angle = np.deg2rad(left)
+    rot_matrix = np.array([[np.cos(beam_left_angle), -np.sin(beam_left_angle)], [np.sin(beam_left_angle), np.cos(beam_left_angle)]])
+
+    vec = np.array([0, bin_back_edge_distance])
+    bin_left_back_point = np.matmul(rot_matrix, vec)
+
+    vec = np.array([0, bin_front_edge_distance])
+    bin_left_front_point = np.matmul(rot_matrix, vec)
+
+    # Right Edge
+    beam_right_angle = np.deg2rad(right)
+    rot_matrix = np.array([[np.cos(beam_right_angle), -np.sin(beam_right_angle)], [np.sin(beam_right_angle), np.cos(beam_right_angle)]])
+
+    vec = np.array([0, bin_front_edge_distance])
+    bin_right_front_point = np.matmul(rot_matrix, vec)
+
+    vec = np.array([0, bin_back_edge_distance])
+    bin_right_back_point = np.matmul(rot_matrix, vec)
+
+
+    return bin_left_back_point, bin_right_back_point, bin_right_front_point, bin_left_front_point
+
+
+def xy_to_sample(x, y, frame, beam_data):
+    """ Convert an x,y location (in meters) to a beam sample.
+    Returns:
+        beam num
+        bin num
+    """
+
+    # Get the angle
+    angle = np.rad2deg(np.arctan(x / y))
+
+    beam_num = beam_data[(beam_data['beam_left'] <= angle) & (angle <= beam_data['beam_right'])]
+
+    if beam_num.shape[0] == 0:
+        return None, None
+
+    beam_num = beam_num['beam_num'].iloc[0]
+
+    # Get the distance
+    hyp =  y / np.cos(np.arctan(x / y))
+
+    # Take into account the window start
+    hyp -= frame.WinStart
+
+    # Sample length
+    bin_length = frame.sampleperiod * 0.000001 * frame.soundspeed / 2.
+
+    # Convert to bins
+    bin_num = int(hyp / bin_length)
+
+    if bin_num < 0 or bin_num > (frame.BeamCount - 1):
+        return None, None
+
+    return beam_num, bin_num
+
+
+def get_minimum_pixel_meter_size(frame, beam_width_data):
+    """ Compute the smallest pixel size that will bound a sample.
+    """
+
+    all_widths = []
+    all_heights = []
+
+    for beam_num in range(frame.BeamCount):
+        bl, br, fr, fl = get_box_for_sample(beam_num, 0, frame, beam_width_data)
+
+        # determine the axis aligned box around this sample box.
+        xs = [bl[0], br[0], fr[0], fl[0]]
+        ys = [bl[1], br[1], fr[1], fl[1]]
+        min_x = min(xs)
+        max_x = max(xs)
+        min_y = min(ys)
+        max_y = max(ys)
+
+        width = max_x - min_x
+        height = max_y - min_y
+
+        all_widths.append(width)
+        all_heights.append(height)
+
+    min_width = min(all_widths)
+    min_height = min(all_heights)
+
+    return min(min_width, min_height)
+
+def compute_image_bounds(pixel_meter_size, frame, beam_width_data, additional_pixel_padding_x=0, additional_pixel_padding_y=0):
+    """ Given the size of a pixel in meters, compute the bounds of an image that will contain the frame.
+    """
+
+    # Compute the projected locations of all samples so that we can get the extent
+    all_bl = []
+    all_br = []
+    all_fr = []
+    all_fl = []
+
+    for beam_num in [0, frame.BeamCount / 2, frame.BeamCount - 1]:
+        for bin_num in  [0, frame.samplesperbeam - 1]:
+            bl, br, fr, fl = get_box_for_sample(beam_num, bin_num, frame, beam_width_data)
+
+            all_bl.append(bl)
+            all_br.append(br)
+            all_fr.append(fr)
+            all_fl.append(fl)
+
+    all_bl = np.array(all_bl)
+    all_br = np.array(all_br)
+    all_fr = np.array(all_fr)
+    all_fl = np.array(all_fl)
+
+    # Get the xdim extent
+    min_back_left = np.min(all_bl[:,0])
+    min_back_right = np.min(all_br[:,0])
+    min_front_left = np.min(all_fl[:,0])
+    min_front_right = np.min(all_fr[:,0])
+    assert min_back_left < min_back_right
+    assert min_back_left < min_front_left
+    assert min_back_left < min_front_right
+
+    max_back_left = np.max(all_bl[:,0])
+    max_back_right = np.max(all_br[:,0])
+    max_front_left = np.max(all_fl[:,0])
+    max_front_right = np.max(all_fr[:,0])
+    assert max_back_right > max_back_left
+    assert max_back_right > max_front_left
+    assert max_back_right > max_front_right
+
+    xdim_extent = np.array([min_back_left, max_back_right])
+
+
+    # Get the ydim extent
+    min_back_left = np.min(all_bl[:,1])
+    min_back_right = np.min(all_br[:,1])
+    min_front_left = np.min(all_fl[:,1])
+    min_front_right = np.min(all_fr[:,1])
+    min_front = min(min_front_left, min_front_right)
+    assert min_front < min_back_right
+    assert min_front < min_back_left
+
+
+    max_back_left = np.max(all_bl[:,1])
+    max_back_right = np.max(all_br[:,1])
+    max_front_left = np.max(all_fl[:,1])
+    max_front_right = np.max(all_fr[:,1])
+    max_back = max(max_back_left, max_back_right)
+    assert max_back > max_front_right
+    assert max_back > max_front_left
+
+    ydim_extent = np.array([min_front, max_back])
+
+    # Determine which meter location corresponds to our "target center"
+    bl, br, fr, fl = get_box_for_sample(frame.BeamCount / 2, 0, frame, beam_width_data)
+    target_center_x = (fl[0] + fr[0]) / 2.
+    target_center_y = (bl[1] + fl[1]) / 2.
+
+    # Determine the x dimension size and what this corresponds to in meters
+    extra_padding_x = pixel_meter_size + pixel_meter_size * additional_pixel_padding_x
+
+    # X Min
+    xmin_len = target_center_x - xdim_extent[0]
+    xp = xmin_len % pixel_meter_size
+    xmin_padded = xdim_extent[0] - (extra_padding_x - xp)
+    xmin_len = target_center_x - xmin_padded
+    x_min_cells = np.abs(xmin_len / pixel_meter_size)
+    x_min_meters = target_center_x - xmin_len
+    assert x_min_meters <= xdim_extent[0]
+
+
+    # X Max
+    xmax_len = xdim_extent[1] - target_center_x
+    xp = xmax_len % pixel_meter_size
+    xmax_padded = xdim_extent[1] + (extra_padding_x - xp)
+    xmax_len = xmax_padded - target_center_x
+    x_max_cells = np.abs(xmax_len / pixel_meter_size)
+    x_max_meters = target_center_x + xmax_len
+    assert x_max_meters >= xdim_extent[1]
+
+
+    # if we want a specific beam to be the in the middle of the image then we should take the max?
+    xdim = int(x_min_cells + x_max_cells)
+    x_meter_start = x_min_meters
+    x_meter_stop = x_max_meters
+
+    # Determine the y dimension size and what this corresponds to in meters
+    extra_padding_y = pixel_meter_size + pixel_meter_size * additional_pixel_padding_y
+
+    # Y Min
+    ymin_len = target_center_y - ydim_extent[0]
+    yp = ymin_len % pixel_meter_size
+    ymin_padded = ydim_extent[0] - ( extra_padding_y - yp)
+    ymin_len = target_center_y - ymin_padded
+    y_min_cells = np.abs(ymin_len / pixel_meter_size)
+    y_min_meters = target_center_y - ymin_len
+    assert y_min_meters <= ydim_extent[0]
+
+    # Y Max
+    ymax_len = ydim_extent[1] - target_center_y
+    yp = ymax_len % pixel_meter_size
+    ymax_padded = ydim_extent[1] + (extra_padding_y - yp)
+    ymax_len = ymax_padded - target_center_y
+    y_max_cells = np.abs(ymax_len / pixel_meter_size)
+    y_max_meters = target_center_y + ymax_len
+    assert y_max_meters >= ydim_extent[1]
+
+    ydim = int(y_min_cells + y_max_cells)
+    y_meter_start = y_max_meters
+    y_meter_stop = y_min_meters
+
+    return xdim, ydim, x_meter_start, y_meter_start, x_meter_stop, y_meter_stop
+
+
+def compute_mapping_from_sample_to_image(pixel_meter_size, xdim, ydim, x_meter_start, y_meter_start, frame, beam_width_data):
+
+    x_meter_values = np.array([x_meter_start + i * pixel_meter_size for i in range(xdim)])
+    y_meter_values = np.array([y_meter_start - i * pixel_meter_size for i in range(ydim)])
+
+    YY, XX = np.meshgrid(y_meter_values, x_meter_values, indexing='ij')
+    XYpairs = np.vstack([ XX.reshape(-1), YY.reshape(-1) ]).T
+
+    II, JJ = np.meshgrid(np.arange(ydim), np.arange(xdim), indexing='ij')
+    IJpairs = np.vstack([ II.reshape(-1), JJ.reshape(-1)]).T
+
+    # Get the angle of the xy pairs
+    angles = np.rad2deg(np.arctan(XYpairs[:,0] / XYpairs[:,1]))
+
+    # Discard pairs that have an angle that is out of range
+    min_angle = beam_width_data['beam_left'].min()
+    max_angle = beam_width_data['beam_right'].max()
+    valid_pairs = (angles > min_angle) & (angles < max_angle)
+    angles = angles[valid_pairs]
+    XYpairs = XYpairs[valid_pairs]
+    IJpairs = IJpairs[valid_pairs]
+
+    # Get the distance of the xy pairs
+    hyp =  XYpairs[:,1] / np.cos(np.arctan(XYpairs[:,0] / XYpairs[:,1]))
+
+    # Take into account the window start
+    hyp -= frame.WinStart
+
+    # Sample length
+    bin_length = frame.sampleperiod * 0.000001 * frame.soundspeed / 2.
+
+    # Convert to bins
+    bin_nums = (hyp / bin_length).astype(int)
+
+    # Discard pairs that have a distance that is out of range
+    valid_pairs = (bin_nums >= 0) & (bin_nums < frame.samplesperbeam)
+    bin_nums = bin_nums[valid_pairs]
+    angles = angles[valid_pairs]
+    XYpairs = XYpairs[valid_pairs]
+    IJpairs = IJpairs[valid_pairs]
+
+
+    beam_edges = beam_width_data['beam_left'].to_numpy()
+    beam_nums = np.digitize(angles, beam_edges) - 1
+
+    # For each valid x,y pair compute which beam it falls into
+    write_to = [] # (i, j) of image
+    read_from = [] # (bin_num, beam_num) of frame data
+    for index in range(XYpairs.shape[0]):
+
+        bin_num = bin_nums[index]
+        beam_num = beam_nums[index]
+
+        write_to.append(IJpairs[index])
+        read_from.append((bin_num, beam_num))
+
+    read_from = np.array(read_from)
+    read_from_rows = np.array(read_from[:,0])
+    read_from_cols = np.array(read_from[:,1])
+
+    write_to = np.array(write_to)
+    write_to_rows = np.array(write_to[:,0])
+    write_to_cols = np.array(write_to[:,1])
+
+    return read_from_rows, read_from_cols, write_to_rows, write_to_cols
+
+
+def make_video(data,
+    xdim, ydim, sample_read_rows, sample_read_cols, image_write_rows, image_write_cols,
+    directory, filename, fps = 24.0, start_frame = 1, end_frame = None, timestamp = False, fontsize = 30, ts_pos = (0,0), save_raw = False):
+    """Output video using the ffmpeg pipeline. The current implementation
+    outputs compresses png files and outputs a mp4.
+
+    Parameters
+    -----------
+    data : (Str) ARIS data structure returned via pyARIS.DataImport()
+    filename : (Str) output filename.  Must include file extension (i.e. 'video.mp4')
+    fps : (Float) Output video frame rate (frames per second). Default = 24 fps
+    start_frame, end_frame : (Int) Range of frames included in the output video
+    timestamp : (Bool) Add the timestamp from the sonar to the video frames
+    fontsize : (Int) Size of timestamp font
+    ts_pos : (Tuple) (x,y) location of the timestamp
+
+    Returns
+    -------
+    Returns a video into the current working directory
+
+    Notes
+    ------
+    Currently this function looks for ffmpeg.exe in the current working directory.
+    Must have the '*.mp4' file extension.
+    Uses the tqdm package to display a status bar.
+
+    Example
+    -------
+    >>> pyARIS.VideoExport(data, 'test_video.mp4', fps = 24)
+
+    """
+
+    #Command to send via the command prompt which specifies the pipe parameters
+    # command = ['ffmpeg',
+    #        '-y', # (optional) overwrite output file if it exists
+    #        '-f', 'image2pipe',
+    #        '-vcodec', 'mjpeg', #'mjpeg',
+    #        '-r', '1',
+    #        '-r', str(fps), # frames per second
+    #        '-i', '-', # The input comes from a pipe
+    #        '-an', # Tells FFMPEG not to expect any audio
+    #        '-vcodec', 'mpeg4',
+    #        '-b:v', '5000k',
+    #        directory + filename + "/"+filename+".mp4",
+    #        '-hide_banner',
+    #        '-loglevel', 'panic']
+
+    # Create directories if they don't exist
+    if not os.path.exists(os.path.join(directory, filename, 'frames/')):
+        os.makedirs(os.path.join(directory, filename, 'frames/'))
+    if save_raw and not os.path.exists(os.path.join(directory, filename, 'frames-raw/')):
+        os.makedirs(os.path.join(directory, filename, 'frames-raw/'))
+
+    if end_frame == None:
+        end_frame = data.FrameCount
+
+    cm = colormap.get_cmap('viridis')
+
+    for i, frame_offset in enumerate(tqdm.tqdm(range(start_frame, end_frame))):
+        frame = FrameRead(data, frame_offset)
+        frame_image = np.zeros([ydim, xdim], dtype=np.uint8)
+        frame_image[image_write_rows, image_write_cols] = frame.frame_data[sample_read_rows, sample_read_cols]
+
+        rgb_im = Image.fromarray(cm(frame_image, bytes=True)).convert('RGB')
+        rgb_im.save(os.path.join(directory, filename, 'frames/', f'{i}.jpg'), 'JPEG')
+
+        if save_raw:
+            Image.fromarray(np.uint8(frame.frame_data), mode='L').save(os.path.join(directory, filename, 'frames-raw/', f'{i}.jpg'), 'JPEG')

lib/fish_eye/sort.py

@@ -0,0 +1,238 @@
+"""
+    SORT: A Simple, Online and Realtime Tracker
+    Copyright (C) 2016-2020 Alex Bewley alex@bewley.ai
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+from filterpy.kalman import KalmanFilter
+import numpy as np
+
+def linear_assignment(cost_matrix):
+    try:
+        import lap
+        _, x, y = lap.lapjv(cost_matrix, extend_cost=True)
+        return np.array([[y[i],i] for i in x if i >= 0]) #
+    except ImportError:
+        from scipy.optimize import linear_sum_assignment
+        x, y = linear_sum_assignment(cost_matrix)
+        return np.array(list(zip(x, y)))
+
+
+def iou_batch(bb_test, bb_gt):                                                                                                   
+    """                                                                                                                      
+    From SORT: Computes IOU between two bboxes in the form [l,t,w,h]                                                         
+    """                                                                                                                      
+    bb_gt = np.expand_dims(bb_gt, 0)                                                                                         
+    bb_test = np.expand_dims(bb_test, 1)                                                                                     
+                                                                                                                            
+    xx1 = np.maximum(bb_test[..., 0], bb_gt[..., 0])                                                                         
+    yy1 = np.maximum(bb_test[..., 1], bb_gt[..., 1])                                                                         
+    xx2 = np.minimum(bb_test[..., 2], bb_gt[..., 2])                                                                         
+    yy2 = np.minimum(bb_test[..., 3], bb_gt[..., 3])                                                                         
+    w = np.maximum(0., xx2 - xx1)                                                                                            
+    h = np.maximum(0., yy2 - yy1)                                                                                            
+    wh = w * h                                                                                                               
+    o = wh / ((bb_test[..., 2] - bb_test[..., 0]) * (bb_test[..., 3] - bb_test[..., 1])                                      
+        + (bb_gt[..., 2] - bb_gt[..., 0]) * (bb_gt[..., 3] - bb_gt[..., 1]) - wh)                                              
+    return(o)  
+
+
+def convert_bbox_to_z(bbox):
+    """
+    Takes a bounding box in the form [x1,y1,x2,y2] and returns z in the form
+        [x,y,s,r] where x,y is the centre of the box and s is the scale/area and r is
+        the aspect ratio
+    """
+    w = bbox[2] - bbox[0]
+    h = bbox[3] - bbox[1]
+    x = bbox[0] + w/2.
+    y = bbox[1] + h/2.
+    s = w * h    #scale is just area
+    r = w / float(h)
+    return np.array([x, y, s, r]).reshape((4, 1))
+
+
+def convert_x_to_bbox(x,score=None):
+    """
+    Takes a bounding box in the centre form [x,y,s,r] and returns it in the form
+        [x1,y1,x2,y2] where x1,y1 is the top left and x2,y2 is the bottom right
+    """
+    w = np.sqrt(x[2] * x[3])
+    h = x[2] / w
+    if(score==None):
+        return np.array([x[0]-w/2.,x[1]-h/2.,x[0]+w/2.,x[1]+h/2.]).reshape((1,4))
+    else:
+        return np.array([x[0]-w/2.,x[1]-h/2.,x[0]+w/2.,x[1]+h/2.,score]).reshape((1,5))
+
+
+class KalmanBoxTracker(object):
+    """
+    This class represents the internal state of individual tracked objects observed as bbox.
+    """
+    count = 0
+    def __init__(self,bbox):
+        """
+        Initialises a tracker using initial bounding box.
+        """
+        #define constant velocity model
+        self.kf = KalmanFilter(dim_x=7, dim_z=4) 
+        self.kf.F = np.array([[1,0,0,0,1,0,0],[0,1,0,0,0,1,0],[0,0,1,0,0,0,1],[0,0,0,1,0,0,0],  [0,0,0,0,1,0,0],[0,0,0,0,0,1,0],[0,0,0,0,0,0,1]])
+        self.kf.H = np.array([[1,0,0,0,0,0,0],[0,1,0,0,0,0,0],[0,0,1,0,0,0,0],[0,0,0,1,0,0,0]])
+
+        self.kf.R[2:,2:] *= 10.
+        self.kf.P[4:,4:] *= 1000. #give high uncertainty to the unobservable initial velocities
+        self.kf.P *= 10.
+        self.kf.Q[-1,-1] *= 0.01
+        self.kf.Q[4:,4:] *= 0.01
+
+        self.kf.x[:4] = convert_bbox_to_z(bbox)
+        self.time_since_update = 0
+        self.id = KalmanBoxTracker.count
+        KalmanBoxTracker.count += 1
+        self.history = []
+        self.hits = 0
+        self.hit_streak = 0
+        self.age = 0
+
+    def update(self,bbox):
+        """
+        Updates the state vector with observed bbox.
+        """
+        self.time_since_update = 0
+        self.history = []
+        self.hits += 1
+        self.hit_streak += 1
+        self.kf.update(convert_bbox_to_z(bbox))
+
+    def predict(self):
+        """
+        Advances the state vector and returns the predicted bounding box estimate.
+        """
+        if((self.kf.x[6]+self.kf.x[2])<=0):
+            self.kf.x[6] *= 0.0
+        self.kf.predict()
+        self.age += 1
+        if(self.time_since_update>0):
+            self.hit_streak = 0
+        self.time_since_update += 1
+        self.history.append(convert_x_to_bbox(self.kf.x))
+        return self.history[-1]
+
+    def get_state(self):
+        """
+        Returns the current bounding box estimate.
+        """
+        return convert_x_to_bbox(self.kf.x)
+
+
+def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):
+    """
+    Assigns detections to tracked object (both represented as bounding boxes)
+
+    Returns 3 lists of matches, unmatched_detections and unmatched_trackers
+    """
+    if(len(trackers)==0):
+        return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)
+
+    iou_matrix = iou_batch(detections, trackers)
+
+    if min(iou_matrix.shape) > 0:
+        a = (iou_matrix > iou_threshold).astype(np.int32)
+        if a.sum(1).max() == 1 and a.sum(0).max() == 1:
+            matched_indices = np.stack(np.where(a), axis=1)
+        else:
+            matched_indices = linear_assignment(-iou_matrix)
+    else:
+        matched_indices = np.empty(shape=(0,2))
+
+    unmatched_detections = []
+    for d, _ in enumerate(detections):
+        if(d not in matched_indices[:,0]):
+            unmatched_detections.append(d)
+    unmatched_trackers = []
+    for t, _ in enumerate(trackers):
+        if(t not in matched_indices[:,1]):
+            unmatched_trackers.append(t)
+
+  #filter out matched with low IOU
+    matches = []
+    for m in matched_indices:
+        if(iou_matrix[m[0], m[1]]<iou_threshold):
+            unmatched_detections.append(m[0])
+            unmatched_trackers.append(m[1])
+        else:
+            matches.append(m.reshape(1,2))
+    if(len(matches)==0):
+        matches = np.empty((0,2),dtype=int)
+    else:
+        matches = np.concatenate(matches,axis=0)
+
+    return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
+
+
+class Sort(object):
+    def __init__(self, max_age=1, min_hits=3, iou_threshold=0.3):
+        """
+        Sets key parameters for SORT
+        """
+        self.max_age = max_age
+        self.min_hits = min_hits
+        self.iou_threshold = iou_threshold
+        self.trackers = []
+        self.frame_count = 0
+
+    def update(self, dets=np.empty((0, 5))):
+        """
+        Params:
+        dets - a numpy array of detections in the format [[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...]
+        Requires: this method must be called once for each frame even with empty detections (use np.empty((0, 5)) for frames without detections).
+        Returns the a similar array, where the last column is the object ID.
+
+        NOTE: The number of objects returned may differ from the number of detections provided.
+        """
+        self.frame_count += 1
+        # get predicted locations from existing trackers.
+        trks = np.zeros((len(self.trackers), 5))
+        to_del = []
+        ret = []
+        for t, trk in enumerate(trks):
+            pos = self.trackers[t].predict()[0]
+            trk[:] = [pos[0], pos[1], pos[2], pos[3], 0]
+            if np.any(np.isnan(pos)):
+                to_del.append(t)
+        trks = np.ma.compress_rows(np.ma.masked_invalid(trks))
+        for t in reversed(to_del):
+            self.trackers.pop(t)
+        matched, unmatched_dets, unmatched_trks = associate_detections_to_trackers(dets,trks, self.iou_threshold)
+
+        # update matched trackers with assigned detections
+        for m in matched:
+            self.trackers[m[1]].update(dets[m[0], :])
+
+        # create and initialise new trackers for unmatched detections
+        for i in unmatched_dets:
+            trk = KalmanBoxTracker(dets[i,:])
+            self.trackers.append(trk)
+        i = len(self.trackers)
+        for trk in reversed(self.trackers):
+            d = trk.get_state()[0]
+            if (trk.time_since_update < 1) and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits):
+                ret.append(np.concatenate((d,[trk.id+1])).reshape(1,-1)) # +1 as MOT benchmark requires positive
+            i -= 1
+            # remove dead tracklet
+            if(trk.time_since_update > self.max_age):
+                self.trackers.pop(i)
+        if(len(ret)>0):
+            return np.concatenate(ret)
+        return np.empty((0,5))

lib/fish_eye/tracker.py

@@ -0,0 +1,162 @@
+from collections import Counter
+from colorsys import hls_to_rgb
+from copy import deepcopy
+import json
+import numpy as np
+
+from fish_length import Fish_Length
+from sort import Sort
+
+class Tracker:
+    def __init__(self, clip_info, algorithm=Sort, args={'max_age':1, 'min_hits':0, 'iou_threshold':0.05}, min_hits=3):
+        self.algorithm = algorithm(**args)
+        self.fish_ids = Counter()
+        self.min_hits = min_hits
+        self.json_data = deepcopy(clip_info)
+        self.frame_id = self.json_data['start_frame']
+        self.json_data['frames'] = []
+
+    # Boxes should be given in normalized [x1,y1,x2,y2,c]
+    def update(self, dets=np.empty((0, 5))):
+        new_frame_entries = []
+        for track in self.algorithm.update(dets):
+            self.fish_ids[int(track[4])] += 1
+            new_frame_entries.append({
+            'fish_id': int(track[4]),
+            'bbox': list(track[:4]),
+            'visible': 1,
+            'human_labeled': 0
+            })
+        new_frame_entries = sorted(new_frame_entries, key=lambda k: k['fish_id']) 
+
+        self.json_data['frames'].append(
+            {
+                'frame_num': self.frame_id,
+                'fish': new_frame_entries
+            })
+        self.frame_id += 1
+    
+    def finalize(self, output_path=None, min_length=-1.0): # vert_margin=0.0
+        json_data = deepcopy(self.json_data)
+            
+        # map (valid) fish IDs to 0, 1, 2, ...
+        fish_id_map = {}
+        for fish_id, count in self.fish_ids.items():
+            if count >= self.min_hits:
+                fish_id_map[fish_id] = len(fish_id_map)
+
+        # separate frame boxes into tracks, keyed by mapped IDs
+        # each track is a list of tuples ( bbox, frame_num )
+        tracks = { v : [] for _, v in fish_id_map.items() }
+        for frame in json_data['frames']:
+            for bbox in frame['fish']:
+                # check if valid
+                if bbox['fish_id'] in fish_id_map.keys():
+                    track_id = fish_id_map[bbox['fish_id']]
+                    tracks[track_id].append((bbox['bbox'], frame['frame_num']))
+
+        # map IDs and keep frame['fish'] sorted by ID
+        for i, frame in enumerate(json_data['frames']):
+            new_frame_entries = []
+            for frame_entry in frame['fish']:
+                if frame_entry['fish_id'] in fish_id_map:
+                    frame_entry['fish_id'] = fish_id_map[frame_entry['fish_id']]
+                    new_frame_entries.append(frame_entry)
+            frame['fish'] = sorted(new_frame_entries, key=lambda k: k['fish_id'])
+
+        # create summary 'fish' entry for json data
+        json_data['fish'] = []
+        for track_id, boxes in tracks.items():
+            fish_entry = {}
+            fish_entry['id'] = track_id
+            fish_entry['length'] = -1
+            
+            # top = False
+            # bottom = False
+            # for frame in json_data['frames']:
+            #     for frame_entry in frame['fish']:
+            #         if frame_entry['fish_id'] == track_id:
+            #             if frame_entry['bbox'][3] > vert_margin:
+            #                 top = True
+            #             if frame_entry['bbox'][1] < 1 - vert_margin:
+            #                 bottom = True
+            #             break
+
+            # if not top or not bottom:
+            #     continue
+            
+            start_bbox = boxes[0][0]
+            end_bbox = boxes[-1][0]
+            fish_entry['direction'] = Tracker.get_direction(start_bbox, end_bbox)
+            
+            fish_entry['start_frame_index'] = boxes[0][1]
+            fish_entry['end_frame_index'] = boxes[-1][1]
+            fish_entry['color'] = Tracker.selectColor(track_id)
+
+            json_data['fish'].append(fish_entry)
+
+        # filter 'fish' field by fish length
+        json_data = Fish_Length.add_lengths(json_data)
+        invalid_ids = []
+        if min_length != -1.0:
+            new_fish = []
+            for fish in json_data['fish']:
+                if fish['length'] > min_length:
+                    new_fish.append(fish)
+                else:
+                    invalid_ids.append(fish['id'])
+            json_data['fish'] = new_fish
+        
+        # filter 'frames' field by fish length
+        if len(invalid_ids):
+            for frame in json_data['frames']:
+                new_fish = []
+                for fish in frame['fish']:
+                    if fish['fish_id'] not in invalid_ids:
+                        new_fish.append(fish)
+                frame['fish'] = new_fish
+            
+        if output_path is not None:
+            with open(output_path,'w') as output:
+                json.dump(json_data, output, indent=2)
+
+        return json_data
+
+    def state(self, output_path=None):
+        json_data = deepcopy(self.json_data)
+
+        if output_path is not None:
+            with open(output_path,'w') as output:
+                json.dump(json_data, output, indent=2)
+        
+        return json_data
+
+    @staticmethod
+    def selectColor(number):
+        hue = ((number * 137.508 + 60) % 360) / 360
+        return '#{0:02x}{1:02x}{2:02x}'.format(*(int(n * 255) for n in hls_to_rgb(hue, 0.5, 0.75)))
+
+    @staticmethod
+    def get_direction(start_bbox, end_bbox):
+        start_center = (start_bbox[2] + start_bbox[0])/2
+        end_center = (end_bbox[2] + end_bbox[0])/2
+        if start_center < 0.5 and end_center >= 0.5:
+            return 'right'
+        elif start_center >= 0.5 and end_center < 0.5:
+            return 'left'
+        else:
+            return 'none'
+
+    @staticmethod
+    def count_dirs(json_data):
+        right = 0
+        left = 0
+        none = 0
+        for fish_entry in json_data['fish']:
+            if fish_entry['direction'] == 'right':
+                right += 1
+            elif fish_entry['direction'] == 'left':
+                left += 1
+            else:
+                none += 1
+        return (right, left, none)

models/download_model.sh

@@ -0,0 +1 @@
+aws s3 cp s3://fishcounting/Models/2021-10-yolov5/v5m_896_300best.pt .

models/v5m_896_300best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14e26883b08b5f07854c67d4ee17b5521eb98f7e0b88d25716542a5cf6dde10f
+size 167806440

scripts/infer.py

@@ -0,0 +1,18 @@
+import project_path
+import argparse
+from predict import predict_task
+from datetime import datetime
+
+
+def main(args):
+    predict_task(args.aris, weights=args.weights)
+
+def argument_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--aris", required=True, help="Path to ARIS file. Required.")
+    parser.add_argument("--weights", default='../models/v5m_896_300best.pt', help="Path to saved YOLOv5 weights. Default: ../models/v5m_896_300best.pt")
+    return parser
+
+if __name__ == "__main__":
+    args = argument_parser().parse_args()
+    main(args)

scripts/project_path.py

@@ -0,0 +1,8 @@
+import sys
+import os
+
+current_dir = os.path.dirname(os.path.realpath(__file__))
+pardir = os.path.dirname(current_dir)
+for d in [pardir, current_dir, os.path.join(pardir, "lib/fish_eye/"), os.path.join(pardir, "lib/"), os.path.join(pardir, "lib/yolov5/")]:
+    if d not in sys.path:
+        sys.path.append(d)

static/css/style.css

@@ -0,0 +1,138 @@
+:root {
+    --fisheye_color: #58df94;
+    --caltech_orange: #FF6C0C;
+}
+
+html,
+body {
+    height: 100%;
+}
+
+body {
+/*     padding-top: 40px; */
+    padding-bottom: 40px;
+    background-color: #f5f5f5; 
+}
+
+#content {
+    padding-top: 40px;
+}
+
+#home_banner * {
+    transition: all .2s ease-in-out;
+}
+#home_banner:hover > svg {
+    transform: scale(1.3) rotate(180deg);
+}
+#home_banner:hover #banner_svg_eye {
+    fill: var(--fisheye_color)
+}
+#home_banner:hover #banner_svg_slit {
+    fill: #231F20;
+}
+#home_banner:hover #banner_svg_pupil {
+    fill: #FFFFFF;
+}
+#home_banner > span {
+    color: black;
+    font-style: italic;
+}
+#home_banner:hover > span {
+    transform: translateX(6px);
+}
+#home_banner:hover #banner_text_caltech {
+    /*color: var(--caltech_orange);*/
+}
+#home_banner:hover #banner_text_fisheye {
+    /*color: var(--fisheye_color);*/
+}
+
+.mode_screen {
+    width: calc(100% - 280px); 
+    display: none;
+    max-height: 100vh;
+    overflow-y: scroll;
+    position: absolute;
+    top: 0px;
+    left: 280px;
+}
+.page_image {
+    max-width: min(95%, 600px);
+}
+.result-download {
+    color:gray;
+    font-size: 20px;
+}
+.result-download:hover {
+    color:black;
+}
+.result-analysis {
+    width: 25px;
+    margin-top: -5px;
+}
+.result-analysis path {
+    fill:gray;
+}
+.result-analysis:hover path {
+    fill:black;
+}
+
+
+#analysis_table {
+    width: 50%;
+    margin-left: 25%
+}
+#analysis_table th {
+    padding: 2px;
+    width: 200px;
+    text-align: right;
+    padding-right: 10px;
+}
+#analysis_table td {
+    padding: 2px;
+    width: 200px;
+    text-align: left;
+    padding-left: 10px;
+}
+
+#sidebar {
+    width: 280px; 
+    height: 100vh; 
+    border: lightgray; 
+    border-right-style: solid;
+}
+
+
+
+
+
+
+
+
+
+
+
+analysis-fishstick {
+    width: 80%;
+    height: 40px;
+    display: block;
+    margin-left: 10%;
+    position: relative;
+}
+.fishstick_line {
+    position: absolute;
+    width: 100%;
+    height: 8px;
+    top: 50%;
+    translate: 0 -50%;
+    background-color: blue;
+}
+.fishstick_token {
+    position: absolute;
+    width: 20px;
+    height: 20px;
+    top: 50%;
+    border-radius: 50%;
+    background-color: orange;
+    translate: -50% -50%;
+}