Skip to content

Add object detection, tracking, mobile notifications, and search to any security camera.

remove experimental for now

roryclear116a4e72fbef
diff --git a/experimental/__pycache__/aes.cpython-313.pyc b/experimental/__pycache__/aes.cpython-313.pyc
deleted file mode 100644
index 024c842..0000000
Binary files a/experimental/__pycache__/aes.cpython-313.pyc and /dev/null differ
diff --git a/experimental/aes.py b/experimental/aes.py
deleted file mode 100644
index 2f56ca4..0000000
--- a/experimental/aes.py
+++ /dev/null
@@ -1,210 +0,0 @@
-# The MIT License (MIT)
-#
-# Copyright (c) 2014 Richard Moore
-#
-# 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.
-
-# This is a pure-Python implementation of the AES algorithm and AES common
-# modes of operation.
-
-# See: https://en.wikipedia.org/wiki/Advanced_Encryption_Standard
-
-# Honestly, the best description of the modes of operations are the wonderful
-# diagrams on Wikipedia. They explain in moments what my words could never
-# achieve. Hence the inline documentation here is sparer than I'd prefer.
-# See: https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation
-
-# Also useful, PyCrypto, a crypto library implemented in C with Python bindings:
-# https://www.dlitz.net/software/pycrypto/
-
-
-# Supported key sizes:
-# 128-bit
-# 192-bit
-# 256-bit
-
-
-# Supported modes of operation:
-# ECB - Electronic Codebook
-# CBC - Cipher-Block Chaining
-# CFB - Cipher Feedback
-# OFB - Output Feedback
-# CTR - Counter
-
-
-# See the README.md for API details and general information.
-
-
-import copy
-import struct
-
-__all__ = ["AES"]
-
-
-def _compact_word(word):
- return (word[0] << 24) | (word[1] << 16) | (word[2] << 8) | word[3]
-
-
-# Python 3 compatibility
-try:
- xrange
-except Exception:
- xrange = range
-
-# Based *largely* on the Rijndael implementation
-# See: http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
-class AES(object):
- '''Encapsulates the AES block cipher.
-
- You generally should not need this. Use the AESModeOfOperation classes
- below instead.'''
-
- # Number of rounds by keysize
- number_of_rounds = {16: 10, 24: 12, 32: 14}
-
- # Round constant words
- rcon = [ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 ]
-
- # S-box and Inverse S-box (S is for Substitution)
- S = [ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ]
- Si =[ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d ]
-
- # Transformations for encryption
- T1 = [ 0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a ]
- T2 = [ 0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0xec41adad, 0x67b3d4d4, 0xfd5fa2a2, 0xea45afaf, 0xbf239c9c, 0xf753a4a4, 0x96e47272, 0x5b9bc0c0, 0xc275b7b7, 0x1ce1fdfd, 0xae3d9393, 0x6a4c2626, 0x5a6c3636, 0x417e3f3f, 0x02f5f7f7, 0x4f83cccc, 0x5c683434, 0xf451a5a5, 0x34d1e5e5, 0x08f9f1f1, 0x93e27171, 0x73abd8d8, 0x53623131, 0x3f2a1515, 0x0c080404, 0x5295c7c7, 0x65462323, 0x5e9dc3c3, 0x28301818, 0xa1379696, 0x0f0a0505, 0xb52f9a9a, 0x090e0707, 0x36241212, 0x9b1b8080, 0x3ddfe2e2, 0x26cdebeb, 0x694e2727, 0xcd7fb2b2, 0x9fea7575, 0x1b120909, 0x9e1d8383, 0x74582c2c, 0x2e341a1a, 0x2d361b1b, 0xb2dc6e6e, 0xeeb45a5a, 0xfb5ba0a0, 0xf6a45252, 0x4d763b3b, 0x61b7d6d6, 0xce7db3b3, 0x7b522929, 0x3edde3e3, 0x715e2f2f, 0x97138484, 0xf5a65353, 0x68b9d1d1, 0x00000000, 0x2cc1eded, 0x60402020, 0x1fe3fcfc, 0xc879b1b1, 0xedb65b5b, 0xbed46a6a, 0x468dcbcb, 0xd967bebe, 0x4b723939, 0xde944a4a, 0xd4984c4c, 0xe8b05858, 0x4a85cfcf, 0x6bbbd0d0, 0x2ac5efef, 0xe54faaaa, 0x16edfbfb, 0xc5864343, 0xd79a4d4d, 0x55663333, 0x94118585, 0xcf8a4545, 0x10e9f9f9, 0x06040202, 0x81fe7f7f, 0xf0a05050, 0x44783c3c, 0xba259f9f, 0xe34ba8a8, 0xf3a25151, 0xfe5da3a3, 0xc0804040, 0x8a058f8f, 0xad3f9292, 0xbc219d9d, 0x48703838, 0x04f1f5f5, 0xdf63bcbc, 0xc177b6b6, 0x75afdada, 0x63422121, 0x30201010, 0x1ae5ffff, 0x0efdf3f3, 0x6dbfd2d2, 0x4c81cdcd, 0x14180c0c, 0x35261313, 0x2fc3ecec, 0xe1be5f5f, 0xa2359797, 0xcc884444, 0x392e1717, 0x5793c4c4, 0xf255a7a7, 0x82fc7e7e, 0x477a3d3d, 0xacc86464, 0xe7ba5d5d, 0x2b321919, 0x95e67373, 0xa0c06060, 0x98198181, 0xd19e4f4f, 0x7fa3dcdc, 0x66442222, 0x7e542a2a, 0xab3b9090, 0x830b8888, 0xca8c4646, 0x29c7eeee, 0xd36bb8b8, 0x3c281414, 0x79a7dede, 0xe2bc5e5e, 0x1d160b0b, 0x76addbdb, 0x3bdbe0e0, 0x56643232, 0x4e743a3a, 0x1e140a0a, 0xdb924949, 0x0a0c0606, 0x6c482424, 0xe4b85c5c, 0x5d9fc2c2, 0x6ebdd3d3, 0xef43acac, 0xa6c46262, 0xa8399191, 0xa4319595, 0x37d3e4e4, 0x8bf27979, 0x32d5e7e7, 0x438bc8c8, 0x596e3737, 0xb7da6d6d, 0x8c018d8d, 0x64b1d5d5, 0xd29c4e4e, 0xe049a9a9, 0xb4d86c6c, 0xfaac5656, 0x07f3f4f4, 0x25cfeaea, 0xafca6565, 0x8ef47a7a, 0xe947aeae, 0x18100808, 0xd56fbaba, 0x88f07878, 0x6f4a2525, 0x725c2e2e, 0x24381c1c, 0xf157a6a6, 0xc773b4b4, 0x5197c6c6, 0x23cbe8e8, 0x7ca1dddd, 0x9ce87474, 0x213e1f1f, 0xdd964b4b, 0xdc61bdbd, 0x860d8b8b, 0x850f8a8a, 0x90e07070, 0x427c3e3e, 0xc471b5b5, 0xaacc6666, 0xd8904848, 0x05060303, 0x01f7f6f6, 0x121c0e0e, 0xa3c26161, 0x5f6a3535, 0xf9ae5757, 0xd069b9b9, 0x91178686, 0x5899c1c1, 0x273a1d1d, 0xb9279e9e, 0x38d9e1e1, 0x13ebf8f8, 0xb32b9898, 0x33221111, 0xbbd26969, 0x70a9d9d9, 0x89078e8e, 0xa7339494, 0xb62d9b9b, 0x223c1e1e, 0x92158787, 0x20c9e9e9, 0x4987cece, 0xffaa5555, 0x78502828, 0x7aa5dfdf, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616 ]
- T3 = [ 0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xadec41ad, 0xd467b3d4, 0xa2fd5fa2, 0xafea45af, 0x9cbf239c, 0xa4f753a4, 0x7296e472, 0xc05b9bc0, 0xb7c275b7, 0xfd1ce1fd, 0x93ae3d93, 0x266a4c26, 0x365a6c36, 0x3f417e3f, 0xf702f5f7, 0xcc4f83cc, 0x345c6834, 0xa5f451a5, 0xe534d1e5, 0xf108f9f1, 0x7193e271, 0xd873abd8, 0x31536231, 0x153f2a15, 0x040c0804, 0xc75295c7, 0x23654623, 0xc35e9dc3, 0x18283018, 0x96a13796, 0x050f0a05, 0x9ab52f9a, 0x07090e07, 0x12362412, 0x809b1b80, 0xe23ddfe2, 0xeb26cdeb, 0x27694e27, 0xb2cd7fb2, 0x759fea75, 0x091b1209, 0x839e1d83, 0x2c74582c, 0x1a2e341a, 0x1b2d361b, 0x6eb2dc6e, 0x5aeeb45a, 0xa0fb5ba0, 0x52f6a452, 0x3b4d763b, 0xd661b7d6, 0xb3ce7db3, 0x297b5229, 0xe33edde3, 0x2f715e2f, 0x84971384, 0x53f5a653, 0xd168b9d1, 0x00000000, 0xed2cc1ed, 0x20604020, 0xfc1fe3fc, 0xb1c879b1, 0x5bedb65b, 0x6abed46a, 0xcb468dcb, 0xbed967be, 0x394b7239, 0x4ade944a, 0x4cd4984c, 0x58e8b058, 0xcf4a85cf, 0xd06bbbd0, 0xef2ac5ef, 0xaae54faa, 0xfb16edfb, 0x43c58643, 0x4dd79a4d, 0x33556633, 0x85941185, 0x45cf8a45, 0xf910e9f9, 0x02060402, 0x7f81fe7f, 0x50f0a050, 0x3c44783c, 0x9fba259f, 0xa8e34ba8, 0x51f3a251, 0xa3fe5da3, 0x40c08040, 0x8f8a058f, 0x92ad3f92, 0x9dbc219d, 0x38487038, 0xf504f1f5, 0xbcdf63bc, 0xb6c177b6, 0xda75afda, 0x21634221, 0x10302010, 0xff1ae5ff, 0xf30efdf3, 0xd26dbfd2, 0xcd4c81cd, 0x0c14180c, 0x13352613, 0xec2fc3ec, 0x5fe1be5f, 0x97a23597, 0x44cc8844, 0x17392e17, 0xc45793c4, 0xa7f255a7, 0x7e82fc7e, 0x3d477a3d, 0x64acc864, 0x5de7ba5d, 0x192b3219, 0x7395e673, 0x60a0c060, 0x81981981, 0x4fd19e4f, 0xdc7fa3dc, 0x22664422, 0x2a7e542a, 0x90ab3b90, 0x88830b88, 0x46ca8c46, 0xee29c7ee, 0xb8d36bb8, 0x143c2814, 0xde79a7de, 0x5ee2bc5e, 0x0b1d160b, 0xdb76addb, 0xe03bdbe0, 0x32566432, 0x3a4e743a, 0x0a1e140a, 0x49db9249, 0x060a0c06, 0x246c4824, 0x5ce4b85c, 0xc25d9fc2, 0xd36ebdd3, 0xacef43ac, 0x62a6c462, 0x91a83991, 0x95a43195, 0xe437d3e4, 0x798bf279, 0xe732d5e7, 0xc8438bc8, 0x37596e37, 0x6db7da6d, 0x8d8c018d, 0xd564b1d5, 0x4ed29c4e, 0xa9e049a9, 0x6cb4d86c, 0x56faac56, 0xf407f3f4, 0xea25cfea, 0x65afca65, 0x7a8ef47a, 0xaee947ae, 0x08181008, 0xbad56fba, 0x7888f078, 0x256f4a25, 0x2e725c2e, 0x1c24381c, 0xa6f157a6, 0xb4c773b4, 0xc65197c6, 0xe823cbe8, 0xdd7ca1dd, 0x749ce874, 0x1f213e1f, 0x4bdd964b, 0xbddc61bd, 0x8b860d8b, 0x8a850f8a, 0x7090e070, 0x3e427c3e, 0xb5c471b5, 0x66aacc66, 0x48d89048, 0x03050603, 0xf601f7f6, 0x0e121c0e, 0x61a3c261, 0x355f6a35, 0x57f9ae57, 0xb9d069b9, 0x86911786, 0xc15899c1, 0x1d273a1d, 0x9eb9279e, 0xe138d9e1, 0xf813ebf8, 0x98b32b98, 0x11332211, 0x69bbd269, 0xd970a9d9, 0x8e89078e, 0x94a73394, 0x9bb62d9b, 0x1e223c1e, 0x87921587, 0xe920c9e9, 0xce4987ce, 0x55ffaa55, 0x28785028, 0xdf7aa5df, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16 ]
- T4 = [ 0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xadadec41, 0xd4d467b3, 0xa2a2fd5f, 0xafafea45, 0x9c9cbf23, 0xa4a4f753, 0x727296e4, 0xc0c05b9b, 0xb7b7c275, 0xfdfd1ce1, 0x9393ae3d, 0x26266a4c, 0x36365a6c, 0x3f3f417e, 0xf7f702f5, 0xcccc4f83, 0x34345c68, 0xa5a5f451, 0xe5e534d1, 0xf1f108f9, 0x717193e2, 0xd8d873ab, 0x31315362, 0x15153f2a, 0x04040c08, 0xc7c75295, 0x23236546, 0xc3c35e9d, 0x18182830, 0x9696a137, 0x05050f0a, 0x9a9ab52f, 0x0707090e, 0x12123624, 0x80809b1b, 0xe2e23ddf, 0xebeb26cd, 0x2727694e, 0xb2b2cd7f, 0x75759fea, 0x09091b12, 0x83839e1d, 0x2c2c7458, 0x1a1a2e34, 0x1b1b2d36, 0x6e6eb2dc, 0x5a5aeeb4, 0xa0a0fb5b, 0x5252f6a4, 0x3b3b4d76, 0xd6d661b7, 0xb3b3ce7d, 0x29297b52, 0xe3e33edd, 0x2f2f715e, 0x84849713, 0x5353f5a6, 0xd1d168b9, 0x00000000, 0xeded2cc1, 0x20206040, 0xfcfc1fe3, 0xb1b1c879, 0x5b5bedb6, 0x6a6abed4, 0xcbcb468d, 0xbebed967, 0x39394b72, 0x4a4ade94, 0x4c4cd498, 0x5858e8b0, 0xcfcf4a85, 0xd0d06bbb, 0xefef2ac5, 0xaaaae54f, 0xfbfb16ed, 0x4343c586, 0x4d4dd79a, 0x33335566, 0x85859411, 0x4545cf8a, 0xf9f910e9, 0x02020604, 0x7f7f81fe, 0x5050f0a0, 0x3c3c4478, 0x9f9fba25, 0xa8a8e34b, 0x5151f3a2, 0xa3a3fe5d, 0x4040c080, 0x8f8f8a05, 0x9292ad3f, 0x9d9dbc21, 0x38384870, 0xf5f504f1, 0xbcbcdf63, 0xb6b6c177, 0xdada75af, 0x21216342, 0x10103020, 0xffff1ae5, 0xf3f30efd, 0xd2d26dbf, 0xcdcd4c81, 0x0c0c1418, 0x13133526, 0xecec2fc3, 0x5f5fe1be, 0x9797a235, 0x4444cc88, 0x1717392e, 0xc4c45793, 0xa7a7f255, 0x7e7e82fc, 0x3d3d477a, 0x6464acc8, 0x5d5de7ba, 0x19192b32, 0x737395e6, 0x6060a0c0, 0x81819819, 0x4f4fd19e, 0xdcdc7fa3, 0x22226644, 0x2a2a7e54, 0x9090ab3b, 0x8888830b, 0x4646ca8c, 0xeeee29c7, 0xb8b8d36b, 0x14143c28, 0xdede79a7, 0x5e5ee2bc, 0x0b0b1d16, 0xdbdb76ad, 0xe0e03bdb, 0x32325664, 0x3a3a4e74, 0x0a0a1e14, 0x4949db92, 0x06060a0c, 0x24246c48, 0x5c5ce4b8, 0xc2c25d9f, 0xd3d36ebd, 0xacacef43, 0x6262a6c4, 0x9191a839, 0x9595a431, 0xe4e437d3, 0x79798bf2, 0xe7e732d5, 0xc8c8438b, 0x3737596e, 0x6d6db7da, 0x8d8d8c01, 0xd5d564b1, 0x4e4ed29c, 0xa9a9e049, 0x6c6cb4d8, 0x5656faac, 0xf4f407f3, 0xeaea25cf, 0x6565afca, 0x7a7a8ef4, 0xaeaee947, 0x08081810, 0xbabad56f, 0x787888f0, 0x25256f4a, 0x2e2e725c, 0x1c1c2438, 0xa6a6f157, 0xb4b4c773, 0xc6c65197, 0xe8e823cb, 0xdddd7ca1, 0x74749ce8, 0x1f1f213e, 0x4b4bdd96, 0xbdbddc61, 0x8b8b860d, 0x8a8a850f, 0x707090e0, 0x3e3e427c, 0xb5b5c471, 0x6666aacc, 0x4848d890, 0x03030506, 0xf6f601f7, 0x0e0e121c, 0x6161a3c2, 0x35355f6a, 0x5757f9ae, 0xb9b9d069, 0x86869117, 0xc1c15899, 0x1d1d273a, 0x9e9eb927, 0xe1e138d9, 0xf8f813eb, 0x9898b32b, 0x11113322, 0x6969bbd2, 0xd9d970a9, 0x8e8e8907, 0x9494a733, 0x9b9bb62d, 0x1e1e223c, 0x87879215, 0xe9e920c9, 0xcece4987, 0x5555ffaa, 0x28287850, 0xdfdf7aa5, 0x8c8c8f03, 0xa1a1f859, 0x89898009, 0x0d0d171a, 0xbfbfda65, 0xe6e631d7, 0x4242c684, 0x6868b8d0, 0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e, 0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c ]
-
- # Transformations for decryption
- T5 = [ 0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742 ]
- T6 = [ 0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0xe7038f5f, 0x9515929c, 0xebbf6d7a, 0xda955259, 0x2dd4be83, 0xd3587421, 0x2949e069, 0x448ec9c8, 0x6a75c289, 0x78f48e79, 0x6b99583e, 0xdd27b971, 0xb6bee14f, 0x17f088ad, 0x66c920ac, 0xb47dce3a, 0x1863df4a, 0x82e51a31, 0x60975133, 0x4562537f, 0xe0b16477, 0x84bb6bae, 0x1cfe81a0, 0x94f9082b, 0x58704868, 0x198f45fd, 0x8794de6c, 0xb7527bf8, 0x23ab73d3, 0xe2724b02, 0x57e31f8f, 0x2a6655ab, 0x07b2eb28, 0x032fb5c2, 0x9a86c57b, 0xa5d33708, 0xf2302887, 0xb223bfa5, 0xba02036a, 0x5ced1682, 0x2b8acf1c, 0x92a779b4, 0xf0f307f2, 0xa14e69e2, 0xcd65daf4, 0xd50605be, 0x1fd13462, 0x8ac4a6fe, 0x9d342e53, 0xa0a2f355, 0x32058ae1, 0x75a4f6eb, 0x390b83ec, 0xaa4060ef, 0x065e719f, 0x51bd6e10, 0xf93e218a, 0x3d96dd06, 0xaedd3e05, 0x464de6bd, 0xb591548d, 0x0571c45d, 0x6f0406d4, 0xff605015, 0x241998fb, 0x97d6bde9, 0xcc894043, 0x7767d99e, 0xbdb0e842, 0x8807898b, 0x38e7195b, 0xdb79c8ee, 0x47a17c0a, 0xe97c420f, 0xc9f8841e, 0x00000000, 0x83098086, 0x48322bed, 0xac1e1170, 0x4e6c5a72, 0xfbfd0eff, 0x560f8538, 0x1e3daed5, 0x27362d39, 0x640a0fd9, 0x21685ca6, 0xd19b5b54, 0x3a24362e, 0xb10c0a67, 0x0f9357e7, 0xd2b4ee96, 0x9e1b9b91, 0x4f80c0c5, 0xa261dc20, 0x695a774b, 0x161c121a, 0x0ae293ba, 0xe5c0a02a, 0x433c22e0, 0x1d121b17, 0x0b0e090d, 0xadf28bc7, 0xb92db6a8, 0xc8141ea9, 0x8557f119, 0x4caf7507, 0xbbee99dd, 0xfda37f60, 0x9ff70126, 0xbc5c72f5, 0xc544663b, 0x345bfb7e, 0x768b4329, 0xdccb23c6, 0x68b6edfc, 0x63b8e4f1, 0xcad731dc, 0x10426385, 0x40139722, 0x2084c611, 0x7d854a24, 0xf8d2bb3d, 0x11aef932, 0x6dc729a1, 0x4b1d9e2f, 0xf3dcb230, 0xec0d8652, 0xd077c1e3, 0x6c2bb316, 0x99a970b9, 0xfa119448, 0x2247e964, 0xc4a8fc8c, 0x1aa0f03f, 0xd8567d2c, 0xef223390, 0xc787494e, 0xc1d938d1, 0xfe8ccaa2, 0x3698d40b, 0xcfa6f581, 0x28a57ade, 0x26dab78e, 0xa43fadbf, 0xe42c3a9d, 0x0d507892, 0x9b6a5fcc, 0x62547e46, 0xc2f68d13, 0xe890d8b8, 0x5e2e39f7, 0xf582c3af, 0xbe9f5d80, 0x7c69d093, 0xa96fd52d, 0xb3cf2512, 0x3bc8ac99, 0xa710187d, 0x6ee89c63, 0x7bdb3bbb, 0x09cd2678, 0xf46e5918, 0x01ec9ab7, 0xa8834f9a, 0x65e6956e, 0x7eaaffe6, 0x0821bccf, 0xe6ef15e8, 0xd9bae79b, 0xce4a6f36, 0xd4ea9f09, 0xd629b07c, 0xaf31a4b2, 0x312a3f23, 0x30c6a594, 0xc035a266, 0x37744ebc, 0xa6fc82ca, 0xb0e090d0, 0x1533a7d8, 0x4af10498, 0xf741ecda, 0x0e7fcd50, 0x2f1791f6, 0x8d764dd6, 0x4d43efb0, 0x54ccaa4d, 0xdfe49604, 0xe39ed1b5, 0x1b4c6a88, 0xb8c12c1f, 0x7f466551, 0x049d5eea, 0x5d018c35, 0x73fa8774, 0x2efb0b41, 0x5ab3671d, 0x5292dbd2, 0x33e91056, 0x136dd647, 0x8c9ad761, 0x7a37a10c, 0x8e59f814, 0x89eb133c, 0xeecea927, 0x35b761c9, 0xede11ce5, 0x3c7a47b1, 0x599cd2df, 0x3f55f273, 0x791814ce, 0xbf73c737, 0xea53f7cd, 0x5b5ffdaa, 0x14df3d6f, 0x867844db, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857 ]
- T7 = [ 0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5fe7038f, 0x9c951592, 0x7aebbf6d, 0x59da9552, 0x832dd4be, 0x21d35874, 0x692949e0, 0xc8448ec9, 0x896a75c2, 0x7978f48e, 0x3e6b9958, 0x71dd27b9, 0x4fb6bee1, 0xad17f088, 0xac66c920, 0x3ab47dce, 0x4a1863df, 0x3182e51a, 0x33609751, 0x7f456253, 0x77e0b164, 0xae84bb6b, 0xa01cfe81, 0x2b94f908, 0x68587048, 0xfd198f45, 0x6c8794de, 0xf8b7527b, 0xd323ab73, 0x02e2724b, 0x8f57e31f, 0xab2a6655, 0x2807b2eb, 0xc2032fb5, 0x7b9a86c5, 0x08a5d337, 0x87f23028, 0xa5b223bf, 0x6aba0203, 0x825ced16, 0x1c2b8acf, 0xb492a779, 0xf2f0f307, 0xe2a14e69, 0xf4cd65da, 0xbed50605, 0x621fd134, 0xfe8ac4a6, 0x539d342e, 0x55a0a2f3, 0xe132058a, 0xeb75a4f6, 0xec390b83, 0xefaa4060, 0x9f065e71, 0x1051bd6e, 0x8af93e21, 0x063d96dd, 0x05aedd3e, 0xbd464de6, 0x8db59154, 0x5d0571c4, 0xd46f0406, 0x15ff6050, 0xfb241998, 0xe997d6bd, 0x43cc8940, 0x9e7767d9, 0x42bdb0e8, 0x8b880789, 0x5b38e719, 0xeedb79c8, 0x0a47a17c, 0x0fe97c42, 0x1ec9f884, 0x00000000, 0x86830980, 0xed48322b, 0x70ac1e11, 0x724e6c5a, 0xfffbfd0e, 0x38560f85, 0xd51e3dae, 0x3927362d, 0xd9640a0f, 0xa621685c, 0x54d19b5b, 0x2e3a2436, 0x67b10c0a, 0xe70f9357, 0x96d2b4ee, 0x919e1b9b, 0xc54f80c0, 0x20a261dc, 0x4b695a77, 0x1a161c12, 0xba0ae293, 0x2ae5c0a0, 0xe0433c22, 0x171d121b, 0x0d0b0e09, 0xc7adf28b, 0xa8b92db6, 0xa9c8141e, 0x198557f1, 0x074caf75, 0xddbbee99, 0x60fda37f, 0x269ff701, 0xf5bc5c72, 0x3bc54466, 0x7e345bfb, 0x29768b43, 0xc6dccb23, 0xfc68b6ed, 0xf163b8e4, 0xdccad731, 0x85104263, 0x22401397, 0x112084c6, 0x247d854a, 0x3df8d2bb, 0x3211aef9, 0xa16dc729, 0x2f4b1d9e, 0x30f3dcb2, 0x52ec0d86, 0xe3d077c1, 0x166c2bb3, 0xb999a970, 0x48fa1194, 0x642247e9, 0x8cc4a8fc, 0x3f1aa0f0, 0x2cd8567d, 0x90ef2233, 0x4ec78749, 0xd1c1d938, 0xa2fe8cca, 0x0b3698d4, 0x81cfa6f5, 0xde28a57a, 0x8e26dab7, 0xbfa43fad, 0x9de42c3a, 0x920d5078, 0xcc9b6a5f, 0x4662547e, 0x13c2f68d, 0xb8e890d8, 0xf75e2e39, 0xaff582c3, 0x80be9f5d, 0x937c69d0, 0x2da96fd5, 0x12b3cf25, 0x993bc8ac, 0x7da71018, 0x636ee89c, 0xbb7bdb3b, 0x7809cd26, 0x18f46e59, 0xb701ec9a, 0x9aa8834f, 0x6e65e695, 0xe67eaaff, 0xcf0821bc, 0xe8e6ef15, 0x9bd9bae7, 0x36ce4a6f, 0x09d4ea9f, 0x7cd629b0, 0xb2af31a4, 0x23312a3f, 0x9430c6a5, 0x66c035a2, 0xbc37744e, 0xcaa6fc82, 0xd0b0e090, 0xd81533a7, 0x984af104, 0xdaf741ec, 0x500e7fcd, 0xf62f1791, 0xd68d764d, 0xb04d43ef, 0x4d54ccaa, 0x04dfe496, 0xb5e39ed1, 0x881b4c6a, 0x1fb8c12c, 0x517f4665, 0xea049d5e, 0x355d018c, 0x7473fa87, 0x412efb0b, 0x1d5ab367, 0xd25292db, 0x5633e910, 0x47136dd6, 0x618c9ad7, 0x0c7a37a1, 0x148e59f8, 0x3c89eb13, 0x27eecea9, 0xc935b761, 0xe5ede11c, 0xb13c7a47, 0xdf599cd2, 0x733f55f2, 0xce791814, 0x37bf73c7, 0xcdea53f7, 0xaa5b5ffd, 0x6f14df3d, 0xdb867844, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8 ]
- T8 = [ 0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0x8f5fe703, 0x929c9515, 0x6d7aebbf, 0x5259da95, 0xbe832dd4, 0x7421d358, 0xe0692949, 0xc9c8448e, 0xc2896a75, 0x8e7978f4, 0x583e6b99, 0xb971dd27, 0xe14fb6be, 0x88ad17f0, 0x20ac66c9, 0xce3ab47d, 0xdf4a1863, 0x1a3182e5, 0x51336097, 0x537f4562, 0x6477e0b1, 0x6bae84bb, 0x81a01cfe, 0x082b94f9, 0x48685870, 0x45fd198f, 0xde6c8794, 0x7bf8b752, 0x73d323ab, 0x4b02e272, 0x1f8f57e3, 0x55ab2a66, 0xeb2807b2, 0xb5c2032f, 0xc57b9a86, 0x3708a5d3, 0x2887f230, 0xbfa5b223, 0x036aba02, 0x16825ced, 0xcf1c2b8a, 0x79b492a7, 0x07f2f0f3, 0x69e2a14e, 0xdaf4cd65, 0x05bed506, 0x34621fd1, 0xa6fe8ac4, 0x2e539d34, 0xf355a0a2, 0x8ae13205, 0xf6eb75a4, 0x83ec390b, 0x60efaa40, 0x719f065e, 0x6e1051bd, 0x218af93e, 0xdd063d96, 0x3e05aedd, 0xe6bd464d, 0x548db591, 0xc45d0571, 0x06d46f04, 0x5015ff60, 0x98fb2419, 0xbde997d6, 0x4043cc89, 0xd99e7767, 0xe842bdb0, 0x898b8807, 0x195b38e7, 0xc8eedb79, 0x7c0a47a1, 0x420fe97c, 0x841ec9f8, 0x00000000, 0x80868309, 0x2bed4832, 0x1170ac1e, 0x5a724e6c, 0x0efffbfd, 0x8538560f, 0xaed51e3d, 0x2d392736, 0x0fd9640a, 0x5ca62168, 0x5b54d19b, 0x362e3a24, 0x0a67b10c, 0x57e70f93, 0xee96d2b4, 0x9b919e1b, 0xc0c54f80, 0xdc20a261, 0x774b695a, 0x121a161c, 0x93ba0ae2, 0xa02ae5c0, 0x22e0433c, 0x1b171d12, 0x090d0b0e, 0x8bc7adf2, 0xb6a8b92d, 0x1ea9c814, 0xf1198557, 0x75074caf, 0x99ddbbee, 0x7f60fda3, 0x01269ff7, 0x72f5bc5c, 0x663bc544, 0xfb7e345b, 0x4329768b, 0x23c6dccb, 0xedfc68b6, 0xe4f163b8, 0x31dccad7, 0x63851042, 0x97224013, 0xc6112084, 0x4a247d85, 0xbb3df8d2, 0xf93211ae, 0x29a16dc7, 0x9e2f4b1d, 0xb230f3dc, 0x8652ec0d, 0xc1e3d077, 0xb3166c2b, 0x70b999a9, 0x9448fa11, 0xe9642247, 0xfc8cc4a8, 0xf03f1aa0, 0x7d2cd856, 0x3390ef22, 0x494ec787, 0x38d1c1d9, 0xcaa2fe8c, 0xd40b3698, 0xf581cfa6, 0x7ade28a5, 0xb78e26da, 0xadbfa43f, 0x3a9de42c, 0x78920d50, 0x5fcc9b6a, 0x7e466254, 0x8d13c2f6, 0xd8b8e890, 0x39f75e2e, 0xc3aff582, 0x5d80be9f, 0xd0937c69, 0xd52da96f, 0x2512b3cf, 0xac993bc8, 0x187da710, 0x9c636ee8, 0x3bbb7bdb, 0x267809cd, 0x5918f46e, 0x9ab701ec, 0x4f9aa883, 0x956e65e6, 0xffe67eaa, 0xbccf0821, 0x15e8e6ef, 0xe79bd9ba, 0x6f36ce4a, 0x9f09d4ea, 0xb07cd629, 0xa4b2af31, 0x3f23312a, 0xa59430c6, 0xa266c035, 0x4ebc3774, 0x82caa6fc, 0x90d0b0e0, 0xa7d81533, 0x04984af1, 0xecdaf741, 0xcd500e7f, 0x91f62f17, 0x4dd68d76, 0xefb04d43, 0xaa4d54cc, 0x9604dfe4, 0xd1b5e39e, 0x6a881b4c, 0x2c1fb8c1, 0x65517f46, 0x5eea049d, 0x8c355d01, 0x877473fa, 0x0b412efb, 0x671d5ab3, 0xdbd25292, 0x105633e9, 0xd647136d, 0xd7618c9a, 0xa10c7a37, 0xf8148e59, 0x133c89eb, 0xa927eece, 0x61c935b7, 0x1ce5ede1, 0x47b13c7a, 0xd2df599c, 0xf2733f55, 0x14ce7918, 0xc737bf73, 0xf7cdea53, 0xfdaa5b5f, 0x3d6f14df, 0x44db8678, 0xaff381ca, 0x68c43eb9, 0x24342c38, 0xa3405fc2, 0x1dc37216, 0xe2250cbc, 0x3c498b28, 0x0d9541ff, 0xa8017139, 0x0cb3de08, 0xb4e49cd8, 0x56c19064, 0xcb84617b, 0x32b670d5, 0x6c5c7448, 0xb85742d0 ]
-
- # Transformations for decryption key expansion
- U1 = [ 0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3 ]
- U2 = [ 0x00000000, 0x0b0e090d, 0x161c121a, 0x1d121b17, 0x2c382434, 0x27362d39, 0x3a24362e, 0x312a3f23, 0x58704868, 0x537e4165, 0x4e6c5a72, 0x4562537f, 0x74486c5c, 0x7f466551, 0x62547e46, 0x695a774b, 0xb0e090d0, 0xbbee99dd, 0xa6fc82ca, 0xadf28bc7, 0x9cd8b4e4, 0x97d6bde9, 0x8ac4a6fe, 0x81caaff3, 0xe890d8b8, 0xe39ed1b5, 0xfe8ccaa2, 0xf582c3af, 0xc4a8fc8c, 0xcfa6f581, 0xd2b4ee96, 0xd9bae79b, 0x7bdb3bbb, 0x70d532b6, 0x6dc729a1, 0x66c920ac, 0x57e31f8f, 0x5ced1682, 0x41ff0d95, 0x4af10498, 0x23ab73d3, 0x28a57ade, 0x35b761c9, 0x3eb968c4, 0x0f9357e7, 0x049d5eea, 0x198f45fd, 0x12814cf0, 0xcb3bab6b, 0xc035a266, 0xdd27b971, 0xd629b07c, 0xe7038f5f, 0xec0d8652, 0xf11f9d45, 0xfa119448, 0x934be303, 0x9845ea0e, 0x8557f119, 0x8e59f814, 0xbf73c737, 0xb47dce3a, 0xa96fd52d, 0xa261dc20, 0xf6ad766d, 0xfda37f60, 0xe0b16477, 0xebbf6d7a, 0xda955259, 0xd19b5b54, 0xcc894043, 0xc787494e, 0xaedd3e05, 0xa5d33708, 0xb8c12c1f, 0xb3cf2512, 0x82e51a31, 0x89eb133c, 0x94f9082b, 0x9ff70126, 0x464de6bd, 0x4d43efb0, 0x5051f4a7, 0x5b5ffdaa, 0x6a75c289, 0x617bcb84, 0x7c69d093, 0x7767d99e, 0x1e3daed5, 0x1533a7d8, 0x0821bccf, 0x032fb5c2, 0x32058ae1, 0x390b83ec, 0x241998fb, 0x2f1791f6, 0x8d764dd6, 0x867844db, 0x9b6a5fcc, 0x906456c1, 0xa14e69e2, 0xaa4060ef, 0xb7527bf8, 0xbc5c72f5, 0xd50605be, 0xde080cb3, 0xc31a17a4, 0xc8141ea9, 0xf93e218a, 0xf2302887, 0xef223390, 0xe42c3a9d, 0x3d96dd06, 0x3698d40b, 0x2b8acf1c, 0x2084c611, 0x11aef932, 0x1aa0f03f, 0x07b2eb28, 0x0cbce225, 0x65e6956e, 0x6ee89c63, 0x73fa8774, 0x78f48e79, 0x49deb15a, 0x42d0b857, 0x5fc2a340, 0x54ccaa4d, 0xf741ecda, 0xfc4fe5d7, 0xe15dfec0, 0xea53f7cd, 0xdb79c8ee, 0xd077c1e3, 0xcd65daf4, 0xc66bd3f9, 0xaf31a4b2, 0xa43fadbf, 0xb92db6a8, 0xb223bfa5, 0x83098086, 0x8807898b, 0x9515929c, 0x9e1b9b91, 0x47a17c0a, 0x4caf7507, 0x51bd6e10, 0x5ab3671d, 0x6b99583e, 0x60975133, 0x7d854a24, 0x768b4329, 0x1fd13462, 0x14df3d6f, 0x09cd2678, 0x02c32f75, 0x33e91056, 0x38e7195b, 0x25f5024c, 0x2efb0b41, 0x8c9ad761, 0x8794de6c, 0x9a86c57b, 0x9188cc76, 0xa0a2f355, 0xabacfa58, 0xb6bee14f, 0xbdb0e842, 0xd4ea9f09, 0xdfe49604, 0xc2f68d13, 0xc9f8841e, 0xf8d2bb3d, 0xf3dcb230, 0xeecea927, 0xe5c0a02a, 0x3c7a47b1, 0x37744ebc, 0x2a6655ab, 0x21685ca6, 0x10426385, 0x1b4c6a88, 0x065e719f, 0x0d507892, 0x640a0fd9, 0x6f0406d4, 0x72161dc3, 0x791814ce, 0x48322bed, 0x433c22e0, 0x5e2e39f7, 0x552030fa, 0x01ec9ab7, 0x0ae293ba, 0x17f088ad, 0x1cfe81a0, 0x2dd4be83, 0x26dab78e, 0x3bc8ac99, 0x30c6a594, 0x599cd2df, 0x5292dbd2, 0x4f80c0c5, 0x448ec9c8, 0x75a4f6eb, 0x7eaaffe6, 0x63b8e4f1, 0x68b6edfc, 0xb10c0a67, 0xba02036a, 0xa710187d, 0xac1e1170, 0x9d342e53, 0x963a275e, 0x8b283c49, 0x80263544, 0xe97c420f, 0xe2724b02, 0xff605015, 0xf46e5918, 0xc544663b, 0xce4a6f36, 0xd3587421, 0xd8567d2c, 0x7a37a10c, 0x7139a801, 0x6c2bb316, 0x6725ba1b, 0x560f8538, 0x5d018c35, 0x40139722, 0x4b1d9e2f, 0x2247e964, 0x2949e069, 0x345bfb7e, 0x3f55f273, 0x0e7fcd50, 0x0571c45d, 0x1863df4a, 0x136dd647, 0xcad731dc, 0xc1d938d1, 0xdccb23c6, 0xd7c52acb, 0xe6ef15e8, 0xede11ce5, 0xf0f307f2, 0xfbfd0eff, 0x92a779b4, 0x99a970b9, 0x84bb6bae, 0x8fb562a3, 0xbe9f5d80, 0xb591548d, 0xa8834f9a, 0xa38d4697 ]
- U3 = [ 0x00000000, 0x0d0b0e09, 0x1a161c12, 0x171d121b, 0x342c3824, 0x3927362d, 0x2e3a2436, 0x23312a3f, 0x68587048, 0x65537e41, 0x724e6c5a, 0x7f456253, 0x5c74486c, 0x517f4665, 0x4662547e, 0x4b695a77, 0xd0b0e090, 0xddbbee99, 0xcaa6fc82, 0xc7adf28b, 0xe49cd8b4, 0xe997d6bd, 0xfe8ac4a6, 0xf381caaf, 0xb8e890d8, 0xb5e39ed1, 0xa2fe8cca, 0xaff582c3, 0x8cc4a8fc, 0x81cfa6f5, 0x96d2b4ee, 0x9bd9bae7, 0xbb7bdb3b, 0xb670d532, 0xa16dc729, 0xac66c920, 0x8f57e31f, 0x825ced16, 0x9541ff0d, 0x984af104, 0xd323ab73, 0xde28a57a, 0xc935b761, 0xc43eb968, 0xe70f9357, 0xea049d5e, 0xfd198f45, 0xf012814c, 0x6bcb3bab, 0x66c035a2, 0x71dd27b9, 0x7cd629b0, 0x5fe7038f, 0x52ec0d86, 0x45f11f9d, 0x48fa1194, 0x03934be3, 0x0e9845ea, 0x198557f1, 0x148e59f8, 0x37bf73c7, 0x3ab47dce, 0x2da96fd5, 0x20a261dc, 0x6df6ad76, 0x60fda37f, 0x77e0b164, 0x7aebbf6d, 0x59da9552, 0x54d19b5b, 0x43cc8940, 0x4ec78749, 0x05aedd3e, 0x08a5d337, 0x1fb8c12c, 0x12b3cf25, 0x3182e51a, 0x3c89eb13, 0x2b94f908, 0x269ff701, 0xbd464de6, 0xb04d43ef, 0xa75051f4, 0xaa5b5ffd, 0x896a75c2, 0x84617bcb, 0x937c69d0, 0x9e7767d9, 0xd51e3dae, 0xd81533a7, 0xcf0821bc, 0xc2032fb5, 0xe132058a, 0xec390b83, 0xfb241998, 0xf62f1791, 0xd68d764d, 0xdb867844, 0xcc9b6a5f, 0xc1906456, 0xe2a14e69, 0xefaa4060, 0xf8b7527b, 0xf5bc5c72, 0xbed50605, 0xb3de080c, 0xa4c31a17, 0xa9c8141e, 0x8af93e21, 0x87f23028, 0x90ef2233, 0x9de42c3a, 0x063d96dd, 0x0b3698d4, 0x1c2b8acf, 0x112084c6, 0x3211aef9, 0x3f1aa0f0, 0x2807b2eb, 0x250cbce2, 0x6e65e695, 0x636ee89c, 0x7473fa87, 0x7978f48e, 0x5a49deb1, 0x5742d0b8, 0x405fc2a3, 0x4d54ccaa, 0xdaf741ec, 0xd7fc4fe5, 0xc0e15dfe, 0xcdea53f7, 0xeedb79c8, 0xe3d077c1, 0xf4cd65da, 0xf9c66bd3, 0xb2af31a4, 0xbfa43fad, 0xa8b92db6, 0xa5b223bf, 0x86830980, 0x8b880789, 0x9c951592, 0x919e1b9b, 0x0a47a17c, 0x074caf75, 0x1051bd6e, 0x1d5ab367, 0x3e6b9958, 0x33609751, 0x247d854a, 0x29768b43, 0x621fd134, 0x6f14df3d, 0x7809cd26, 0x7502c32f, 0x5633e910, 0x5b38e719, 0x4c25f502, 0x412efb0b, 0x618c9ad7, 0x6c8794de, 0x7b9a86c5, 0x769188cc, 0x55a0a2f3, 0x58abacfa, 0x4fb6bee1, 0x42bdb0e8, 0x09d4ea9f, 0x04dfe496, 0x13c2f68d, 0x1ec9f884, 0x3df8d2bb, 0x30f3dcb2, 0x27eecea9, 0x2ae5c0a0, 0xb13c7a47, 0xbc37744e, 0xab2a6655, 0xa621685c, 0x85104263, 0x881b4c6a, 0x9f065e71, 0x920d5078, 0xd9640a0f, 0xd46f0406, 0xc372161d, 0xce791814, 0xed48322b, 0xe0433c22, 0xf75e2e39, 0xfa552030, 0xb701ec9a, 0xba0ae293, 0xad17f088, 0xa01cfe81, 0x832dd4be, 0x8e26dab7, 0x993bc8ac, 0x9430c6a5, 0xdf599cd2, 0xd25292db, 0xc54f80c0, 0xc8448ec9, 0xeb75a4f6, 0xe67eaaff, 0xf163b8e4, 0xfc68b6ed, 0x67b10c0a, 0x6aba0203, 0x7da71018, 0x70ac1e11, 0x539d342e, 0x5e963a27, 0x498b283c, 0x44802635, 0x0fe97c42, 0x02e2724b, 0x15ff6050, 0x18f46e59, 0x3bc54466, 0x36ce4a6f, 0x21d35874, 0x2cd8567d, 0x0c7a37a1, 0x017139a8, 0x166c2bb3, 0x1b6725ba, 0x38560f85, 0x355d018c, 0x22401397, 0x2f4b1d9e, 0x642247e9, 0x692949e0, 0x7e345bfb, 0x733f55f2, 0x500e7fcd, 0x5d0571c4, 0x4a1863df, 0x47136dd6, 0xdccad731, 0xd1c1d938, 0xc6dccb23, 0xcbd7c52a, 0xe8e6ef15, 0xe5ede11c, 0xf2f0f307, 0xfffbfd0e, 0xb492a779, 0xb999a970, 0xae84bb6b, 0xa38fb562, 0x80be9f5d, 0x8db59154, 0x9aa8834f, 0x97a38d46 ]
- U4 = [ 0x00000000, 0x090d0b0e, 0x121a161c, 0x1b171d12, 0x24342c38, 0x2d392736, 0x362e3a24, 0x3f23312a, 0x48685870, 0x4165537e, 0x5a724e6c, 0x537f4562, 0x6c5c7448, 0x65517f46, 0x7e466254, 0x774b695a, 0x90d0b0e0, 0x99ddbbee, 0x82caa6fc, 0x8bc7adf2, 0xb4e49cd8, 0xbde997d6, 0xa6fe8ac4, 0xaff381ca, 0xd8b8e890, 0xd1b5e39e, 0xcaa2fe8c, 0xc3aff582, 0xfc8cc4a8, 0xf581cfa6, 0xee96d2b4, 0xe79bd9ba, 0x3bbb7bdb, 0x32b670d5, 0x29a16dc7, 0x20ac66c9, 0x1f8f57e3, 0x16825ced, 0x0d9541ff, 0x04984af1, 0x73d323ab, 0x7ade28a5, 0x61c935b7, 0x68c43eb9, 0x57e70f93, 0x5eea049d, 0x45fd198f, 0x4cf01281, 0xab6bcb3b, 0xa266c035, 0xb971dd27, 0xb07cd629, 0x8f5fe703, 0x8652ec0d, 0x9d45f11f, 0x9448fa11, 0xe303934b, 0xea0e9845, 0xf1198557, 0xf8148e59, 0xc737bf73, 0xce3ab47d, 0xd52da96f, 0xdc20a261, 0x766df6ad, 0x7f60fda3, 0x6477e0b1, 0x6d7aebbf, 0x5259da95, 0x5b54d19b, 0x4043cc89, 0x494ec787, 0x3e05aedd, 0x3708a5d3, 0x2c1fb8c1, 0x2512b3cf, 0x1a3182e5, 0x133c89eb, 0x082b94f9, 0x01269ff7, 0xe6bd464d, 0xefb04d43, 0xf4a75051, 0xfdaa5b5f, 0xc2896a75, 0xcb84617b, 0xd0937c69, 0xd99e7767, 0xaed51e3d, 0xa7d81533, 0xbccf0821, 0xb5c2032f, 0x8ae13205, 0x83ec390b, 0x98fb2419, 0x91f62f17, 0x4dd68d76, 0x44db8678, 0x5fcc9b6a, 0x56c19064, 0x69e2a14e, 0x60efaa40, 0x7bf8b752, 0x72f5bc5c, 0x05bed506, 0x0cb3de08, 0x17a4c31a, 0x1ea9c814, 0x218af93e, 0x2887f230, 0x3390ef22, 0x3a9de42c, 0xdd063d96, 0xd40b3698, 0xcf1c2b8a, 0xc6112084, 0xf93211ae, 0xf03f1aa0, 0xeb2807b2, 0xe2250cbc, 0x956e65e6, 0x9c636ee8, 0x877473fa, 0x8e7978f4, 0xb15a49de, 0xb85742d0, 0xa3405fc2, 0xaa4d54cc, 0xecdaf741, 0xe5d7fc4f, 0xfec0e15d, 0xf7cdea53, 0xc8eedb79, 0xc1e3d077, 0xdaf4cd65, 0xd3f9c66b, 0xa4b2af31, 0xadbfa43f, 0xb6a8b92d, 0xbfa5b223, 0x80868309, 0x898b8807, 0x929c9515, 0x9b919e1b, 0x7c0a47a1, 0x75074caf, 0x6e1051bd, 0x671d5ab3, 0x583e6b99, 0x51336097, 0x4a247d85, 0x4329768b, 0x34621fd1, 0x3d6f14df, 0x267809cd, 0x2f7502c3, 0x105633e9, 0x195b38e7, 0x024c25f5, 0x0b412efb, 0xd7618c9a, 0xde6c8794, 0xc57b9a86, 0xcc769188, 0xf355a0a2, 0xfa58abac, 0xe14fb6be, 0xe842bdb0, 0x9f09d4ea, 0x9604dfe4, 0x8d13c2f6, 0x841ec9f8, 0xbb3df8d2, 0xb230f3dc, 0xa927eece, 0xa02ae5c0, 0x47b13c7a, 0x4ebc3774, 0x55ab2a66, 0x5ca62168, 0x63851042, 0x6a881b4c, 0x719f065e, 0x78920d50, 0x0fd9640a, 0x06d46f04, 0x1dc37216, 0x14ce7918, 0x2bed4832, 0x22e0433c, 0x39f75e2e, 0x30fa5520, 0x9ab701ec, 0x93ba0ae2, 0x88ad17f0, 0x81a01cfe, 0xbe832dd4, 0xb78e26da, 0xac993bc8, 0xa59430c6, 0xd2df599c, 0xdbd25292, 0xc0c54f80, 0xc9c8448e, 0xf6eb75a4, 0xffe67eaa, 0xe4f163b8, 0xedfc68b6, 0x0a67b10c, 0x036aba02, 0x187da710, 0x1170ac1e, 0x2e539d34, 0x275e963a, 0x3c498b28, 0x35448026, 0x420fe97c, 0x4b02e272, 0x5015ff60, 0x5918f46e, 0x663bc544, 0x6f36ce4a, 0x7421d358, 0x7d2cd856, 0xa10c7a37, 0xa8017139, 0xb3166c2b, 0xba1b6725, 0x8538560f, 0x8c355d01, 0x97224013, 0x9e2f4b1d, 0xe9642247, 0xe0692949, 0xfb7e345b, 0xf2733f55, 0xcd500e7f, 0xc45d0571, 0xdf4a1863, 0xd647136d, 0x31dccad7, 0x38d1c1d9, 0x23c6dccb, 0x2acbd7c5, 0x15e8e6ef, 0x1ce5ede1, 0x07f2f0f3, 0x0efffbfd, 0x79b492a7, 0x70b999a9, 0x6bae84bb, 0x62a38fb5, 0x5d80be9f, 0x548db591, 0x4f9aa883, 0x4697a38d ]
-
- def __init__(self, key):
-
- if len(key) not in (16, 24, 32):
- raise ValueError('Invalid key size')
-
- rounds = self.number_of_rounds[len(key)]
-
- # Encryption round keys
- self._Ke = [[0] * 4 for i in xrange(rounds + 1)]
-
- # Decryption round keys
- self._Kd = [[0] * 4 for i in xrange(rounds + 1)]
-
- round_key_count = (rounds + 1) * 4
- KC = len(key) // 4
-
- # Convert the key into ints
- tk = [ struct.unpack('>i', key[i:i + 4])[0] for i in xrange(0, len(key), 4) ]
-
- # Copy values into round key arrays
- for i in xrange(0, KC):
- self._Ke[i // 4][i % 4] = tk[i]
- self._Kd[rounds - (i // 4)][i % 4] = tk[i]
-
- # Key expansion (fips-197 section 5.2)
- rconpointer = 0
- t = KC
- while t < round_key_count:
-
- tt = tk[KC - 1]
- tk[0] ^= ((self.S[(tt >> 16) & 0xFF] << 24) ^
- (self.S[(tt >> 8) & 0xFF] << 16) ^
- (self.S[ tt & 0xFF] << 8) ^
- self.S[(tt >> 24) & 0xFF] ^
- (self.rcon[rconpointer] << 24))
- rconpointer += 1
-
- if KC != 8:
- for i in xrange(1, KC):
- tk[i] ^= tk[i - 1]
-
- # Key expansion for 256-bit keys is "slightly different" (fips-197)
- else:
- for i in xrange(1, KC // 2):
- tk[i] ^= tk[i - 1]
- tt = tk[KC // 2 - 1]
-
- tk[KC // 2] ^= (self.S[ tt & 0xFF] ^
- (self.S[(tt >> 8) & 0xFF] << 8) ^
- (self.S[(tt >> 16) & 0xFF] << 16) ^
- (self.S[(tt >> 24) & 0xFF] << 24))
-
- for i in xrange(KC // 2 + 1, KC):
- tk[i] ^= tk[i - 1]
-
- # Copy values into round key arrays
- j = 0
- while j < KC and t < round_key_count:
- self._Ke[t // 4][t % 4] = tk[j]
- self._Kd[rounds - (t // 4)][t % 4] = tk[j]
- j += 1
- t += 1
-
- # Inverse-Cipher-ify the decryption round key (fips-197 section 5.3)
- for r in xrange(1, rounds):
- for j in xrange(0, 4):
- tt = self._Kd[r][j]
- self._Kd[r][j] = (self.U1[(tt >> 24) & 0xFF] ^
- self.U2[(tt >> 16) & 0xFF] ^
- self.U3[(tt >> 8) & 0xFF] ^
- self.U4[ tt & 0xFF])
-
- def encrypt(self, plaintext):
- 'Encrypt a block of plain text using the AES block cipher.'
-
- if len(plaintext) != 16:
- raise ValueError('wrong block length')
-
- rounds = len(self._Ke) - 1
- (s1, s2, s3) = [1, 2, 3]
- a = [0, 0, 0, 0]
-
- # Convert plaintext to (ints ^ key)
- t = [(_compact_word(plaintext[4 * i:4 * i + 4]) ^ self._Ke[0][i]) for i in xrange(0, 4)]
-
- # Apply round transforms
- for r in xrange(1, rounds):
- for i in xrange(0, 4):
- a[i] = (self.T1[(t[ i ] >> 24) & 0xFF] ^
- self.T2[(t[(i + s1) % 4] >> 16) & 0xFF] ^
- self.T3[(t[(i + s2) % 4] >> 8) & 0xFF] ^
- self.T4[ t[(i + s3) % 4] & 0xFF] ^
- self._Ke[r][i])
- t = copy.copy(a)
-
- # The last round is special
- result = [ ]
- for i in xrange(0, 4):
- tt = self._Ke[rounds][i]
- result.append((self.S[(t[ i ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF)
- result.append((self.S[(t[(i + s1) % 4] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF)
- result.append((self.S[(t[(i + s2) % 4] >> 8) & 0xFF] ^ (tt >> 8)) & 0xFF)
- result.append((self.S[ t[(i + s3) % 4] & 0xFF] ^ tt ) & 0xFF)
-
- return result
\ No newline at end of file
diff --git a/experimental/bytetrack.py b/experimental/bytetrack.py
deleted file mode 100644
index cad097f..0000000
--- a/experimental/bytetrack.py
+++ /dev/null
@@ -1,1277 +0,0 @@
-from tinygrad.nn import Conv2d, BatchNorm2d
-from tinygrad.tensor import Tensor
-from tinygrad.device import is_dtype_supported
-from tinygrad import dtypes
-import numpy as np
-from itertools import chain
-from pathlib import Path
-import cv2
-from collections import defaultdict
-import time, sys
-from tinygrad.helpers import fetch
-from tinygrad.nn.state import safe_load, load_state_dict
-import json
-from tinygrad import TinyJit
-import lap
-from collections import OrderedDict
-import pickle
-
-
-class KalmanFilter(object):
- def __init__(self):
- ndim, dt = 4, 1.
- self._motion_mat = np.eye(2 * ndim, 2 * ndim)
- for i in range(ndim):
- self._motion_mat[i, ndim + i] = dt
- self._update_mat = np.eye(ndim, 2 * ndim)
- self._std_weight_position = 1. / 20
- self._std_weight_velocity = 1. / 160
-
- def initiate(self, measurement):
- mean_pos = measurement
- mean_vel = np.zeros_like(mean_pos)
- mean = np.r_[mean_pos, mean_vel]
-
- std = [
- 2 * self._std_weight_position * measurement[3],
- 2 * self._std_weight_position * measurement[3],
- 1e-2,
- 2 * self._std_weight_position * measurement[3],
- 10 * self._std_weight_velocity * measurement[3],
- 10 * self._std_weight_velocity * measurement[3],
- 1e-5,
- 10 * self._std_weight_velocity * measurement[3]]
- covariance = np.diag(np.square(std))
- return mean, covariance
-
- def project(self, mean, covariance):
- std = [
- self._std_weight_position * mean[3],
- self._std_weight_position * mean[3],
- 1e-1,
- self._std_weight_position * mean[3]]
- innovation_cov = np.diag(np.square(std))
-
- mean = np.dot(self._update_mat, mean)
- covariance = np.linalg.multi_dot((
- self._update_mat, covariance, self._update_mat.T))
- return mean, covariance + innovation_cov
-
- def multi_predict(self, mean, covariance):
- std_pos = [
- self._std_weight_position * mean[:, 3],
- self._std_weight_position * mean[:, 3],
- 1e-2 * np.ones_like(mean[:, 3]),
- self._std_weight_position * mean[:, 3]]
- std_vel = [
- self._std_weight_velocity * mean[:, 3],
- self._std_weight_velocity * mean[:, 3],
- 1e-5 * np.ones_like(mean[:, 3]),
- self._std_weight_velocity * mean[:, 3]]
- sqr = np.square(np.r_[std_pos, std_vel]).T
-
- motion_cov = []
- for i in range(len(mean)):
- motion_cov.append(np.diag(sqr[i]))
- motion_cov = np.asarray(motion_cov)
-
- mean = np.dot(mean, self._motion_mat.T)
- left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
- covariance = np.dot(left, self._motion_mat.T) + motion_cov
-
- return mean, covariance
-
- def update(self, mean, covariance, measurement):
- projected_mean, projected_cov = self.project(mean, covariance)
-
- chol_factor = np.linalg.cholesky(projected_cov)
- y = np.linalg.solve(chol_factor, np.dot(covariance, self._update_mat.T).T)
- kalman_gain = np.linalg.solve(chol_factor.T, y).T
- innovation = measurement - projected_mean
- new_mean = mean + np.dot(innovation, kalman_gain.T)
- new_covariance = covariance - np.linalg.multi_dot((
- kalman_gain, projected_cov, kalman_gain.T))
- return new_mean, new_covariance
-
-class TrackState(object):
- New = 1
- Tracked = 2
- Lost = 3
- Removed = 4
- Replaced = 5
-
-def tlbr_np(values, mean):
- """Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
- `(top left, bottom right)`."""
- if mean is None:
- ret = values[:4].copy()
- else:
- ret = mean[:4].copy()
- ret[2] *= ret[3]
- ret[:2] -= ret[2:] / 2
- ret[2:] += ret[:2]
- return ret
-
-def tlbr_np_batch(tracked_stracks_values, tracked_stracks_means):
- ret = np.empty((len(tracked_stracks_values), 4))
- use_mean = np.array([m is not None for m in tracked_stracks_means], dtype=bool)
- if np.any(use_mean):
- means = np.array([m for m in tracked_stracks_means if m is not None])
- ret[use_mean, :] = means[:, :4].copy()
- ret[use_mean, 2] *= ret[use_mean, 3]
- ret[use_mean, :2] -= ret[use_mean, 2:] / 2
- if not np.all(use_mean):
- ret[~use_mean, :] = tracked_stracks_values[~use_mean, :4].copy()
- ret[:, 2:] += ret[:, :2]
- return ret
-
-def tlwh_np(values,mean):
- """Get current position in bounding box format `(top left x, top left y,
- width, height)`.
- """
- if mean is None:
- return values[:4].copy()
- ret = mean[:4].copy()
- ret[2] *= ret[3]
- ret[:2] -= ret[2:] / 2
- return ret
-
-def tlwh_to_xyah(tlwh):
- """Convert bounding box to format `(center x, center y, aspect ratio,
- height)`, where the aspect ratio is `width / height`.
- """
- ret = np.asarray(tlwh).copy()
- ret[:2] += ret[2:] / 2
- ret[2] /= ret[3]
- return ret
-
-def bbox_ious(boxes, query_boxes):
- N = boxes.shape[0]
- K = query_boxes.shape[0]
-
- boxes_area = (
- (boxes[:, 2] - boxes[:, 0] + 1) *
- (boxes[:, 3] - boxes[:, 1] + 1)
- ).reshape(N, 1)
-
- query_areas = (
- (query_boxes[:, 2] - query_boxes[:, 0] + 1) *
- (query_boxes[:, 3] - query_boxes[:, 1] + 1)
- ).reshape(1, K)
-
- ixmin = np.maximum(boxes[:, 0].reshape(N, 1), query_boxes[:, 0].reshape(1, K))
- iymin = np.maximum(boxes[:, 1].reshape(N, 1), query_boxes[:, 1].reshape(1, K))
- ixmax = np.minimum(boxes[:, 2].reshape(N, 1), query_boxes[:, 2].reshape(1, K))
- iymax = np.minimum(boxes[:, 3].reshape(N, 1), query_boxes[:, 3].reshape(1, K))
-
- iw = np.maximum(ixmax - ixmin + 1, 0)
- ih = np.maximum(iymax - iymin + 1, 0)
- intersection = iw * ih
-
- union = boxes_area + query_areas - intersection
-
- overlaps = np.where(
- (iw > 0) & (ih > 0),
- intersection / union,
- np.zeros_like(intersection)
- )
- return overlaps
-
-class BYTETracker(object):
- def __init__(self, args, frame_rate=30):
- self._count = 0
-
- self.lost_stracks_ids_tg = Tensor.empty()
- self.lost_stracks_fids_tg = Tensor.empty()
- self.lost_stracks_startframes_tg = Tensor.empty()
- self.lost_stracks_states_tg = Tensor.empty()
- self.lost_stracks_bools_tg = Tensor.empty()
- self.lost_stracks_values_tg = Tensor.empty()
- self.lost_stracks_means_tg = Tensor.empty()
- self.lost_stracks_covs_tg = Tensor.empty()
-
- self.tracked_stracks_values = []
- self.lost_stracks_values = []
-
- self.tracked_stracks_means = []
- self.tracked_stracks_bools = []
- self.tracked_stracks_covs = []
- self.tracked_stracks_ids = []
- self.tracked_stracks_fids = []
- self.tracked_stracks_startframes = []
- self.tracked_stracks_states = []
- self.lost_stracks_means = []
- self.lost_stracks_bools = []
- self.lost_stracks_covs = []
- self.lost_stracks_ids = []
- self.lost_stracks_fids = []
- self.lost_stracks_startframes = []
- self.lost_stracks_states = []
-
- self.frame_id = 0
- self.args = args
- self.det_thresh = args.track_thresh + 0.1
- self.buffer_size = int(frame_rate / 30.0 * args.track_buffer)
- self.max_time_lost = self.buffer_size
- self.kalman_filter = KalmanFilter()
-
- def update(self, output_results, img_info, img_size):
- self.frame_id += 1
- activated_stracks_values = []
- activated_stracks_means = []
- activated_stracks_bools = []
- activated_stracks_covs = []
- activated_stracks_ids = []
- activated_stracks_fids = []
- activated_stracks_startframes = []
- activated_stracks_states = []
- refind_stracks_values = []
- refind_stracks_means = []
- refind_stracks_bools = []
- refind_stracks_covs = []
- refind_stracks_ids = []
- refind_stracks_fids = []
- refind_stracks_startframes = []
- refind_stracks_states = []
- lost_stracks_means = []
- lost_stracks_bools = []
- lost_stracks_covs = []
- lost_stracks_values = []
- lost_stracks_startframes = []
- lost_stracks_states = []
- lost_stracks_ids = []
- lost_stracks_fids = []
- removed_stracks_ids = []
-
- classes = output_results[:, 5]
- scores = output_results[:, 4]
- bboxes = output_results[:, :4]
-
- img_h, img_w = img_info[0], img_info[1]
- scale = min(img_size[0] / float(img_h), img_size[1] / float(img_w))
- bboxes = bboxes / scale
-
- remain_inds = scores > self.args.track_thresh
- inds_low = scores > 0.1
- inds_high = scores < self.args.track_thresh
- inds_second = inds_low & inds_high
-
- dets = bboxes * remain_inds.unsqueeze(1)
- dets_second = bboxes * inds_second.unsqueeze(1)
- dets[:, 2:] -= dets[:, :2] #tlbr to tlwh
- dets_second[:, 2:] -= dets_second[:, :2]
- dets_score_classes = dets.cat(scores.reshape(-1,1), dim=1).cat(classes.reshape(-1,1), dim=1)
- dets_score_classes = dets_score_classes.numpy()
- dets_score_classes_second = dets_second.cat(scores.reshape(-1,1), dim=1).cat(classes.reshape(-1,1), dim=1)
- dets_score_classes_second = dets_score_classes_second.numpy()
- detections_means = [None for _ in dets_score_classes]
- detections_bools = [False for _ in dets_score_classes_second]
- detections_cov = [None for _ in dets_score_classes]
- detections_ids = [None for _ in dets_score_classes]
- detections_fids = [None for _ in dets_score_classes]
- detections_startframes = [0 for _ in dets_score_classes]
- detections_states = [TrackState.New for _ in dets_score_classes]
-
- tracked_stracks_means = []
- tracked_stracks_covs = []
-
- mask = np.array(self.tracked_stracks_bools).astype(bool)
- mask_tg = Tensor(mask)
-
- for i in range(len(self.tracked_stracks_ids)):
- mean = self.tracked_stracks_means[i]
- cov = self.tracked_stracks_covs[i]
- if self.tracked_stracks_bools[i]:
- tracked_stracks_means.append(mean)
- tracked_stracks_covs.append(cov)
-
- self.tracked_stracks_ids_tg = Tensor(self.tracked_stracks_ids)
- self.tracked_stracks_fids_tg = Tensor(self.tracked_stracks_fids)
- self.tracked_stracks_bools_tg = Tensor(self.tracked_stracks_bools)
- self.tracked_stracks_startframes_tg = Tensor(self.tracked_stracks_startframes)
- self.tracked_stracks_states_tg = Tensor(self.tracked_stracks_states)
- self.tracked_stracks_values_tg = Tensor(self.tracked_stracks_values)
- self.tracked_stracks_covs_tg = Tensor(self.tracked_stracks_covs)
- self.tracked_stracks_means_tg = Tensor(self.tracked_stracks_means)
-
- tracked_stracks_ids_tg = (self.tracked_stracks_ids_tg * mask_tg)
- tracked_stracks_fids_tg = (self.tracked_stracks_fids_tg * mask_tg)
- tracked_stracks_bools_tg = (self.tracked_stracks_bools_tg * mask_tg)
- tracked_stracks_startframes_tg = (self.tracked_stracks_startframes_tg * mask_tg)
- tracked_stracks_states_tg = (self.tracked_stracks_states_tg * mask_tg)
- tracked_stracks_values_tg = self.tracked_stracks_values_tg * mask_tg.view(-1,1)
-
- unconfirmed_ids_tg = self.tracked_stracks_ids_tg * ~mask_tg
- unconfirmed_values_tg = self.tracked_stracks_values_tg * ~mask_tg.view(-1,1)
- unconfirmed_bools_tg = self.tracked_stracks_bools_tg * ~mask_tg
- unconfirmed_states_tg = self.tracked_stracks_states_tg * ~mask_tg
- unconfirmed_fids_tg = self.tracked_stracks_fids_tg * ~mask_tg
- unconfirmed_startframes_tg = self.tracked_stracks_startframes_tg * ~mask_tg
- unconfirmed_covs_tg = self.tracked_stracks_covs_tg * ~mask_tg.view(-1,1,1)
- unconfirmed_means_tg = self.tracked_stracks_means_tg * ~mask_tg.view(-1,1)
-
- if len(self.lost_stracks_values_tg.shape) > 1 and self.lost_stracks_values_tg.shape[0] > 0:
- tracked_stracks_ids_tg = tracked_stracks_ids_tg.cat(self.lost_stracks_ids_tg)
- tracked_stracks_fids_tg = tracked_stracks_fids_tg.cat(self.lost_stracks_fids_tg)
- tracked_stracks_bools_tg = tracked_stracks_bools_tg.cat(self.lost_stracks_bools_tg)
- tracked_stracks_startframes_tg = tracked_stracks_startframes_tg.cat(self.lost_stracks_startframes_tg)
- tracked_stracks_states_tg = tracked_stracks_states_tg.cat(self.lost_stracks_states_tg)
- tracked_stracks_values_tg = tracked_stracks_values_tg.cat(self.lost_stracks_values_tg)
-
- tracked_stracks_ids = tracked_stracks_ids_tg.numpy()
- id_mask = tracked_stracks_ids != 0
- tracked_stracks_ids = tracked_stracks_ids[id_mask].tolist()
- tracked_stracks_fids = tracked_stracks_fids_tg.numpy()
- tracked_stracks_fids = tracked_stracks_fids[id_mask].tolist()
- tracked_stracks_bools = tracked_stracks_bools_tg.numpy()
- tracked_stracks_bools = tracked_stracks_bools[id_mask].tolist()
- tracked_stracks_startframes = tracked_stracks_startframes_tg.numpy()
- tracked_stracks_startframes = tracked_stracks_startframes[id_mask].tolist()
- tracked_stracks_states = tracked_stracks_states_tg.numpy()
- tracked_stracks_states = tracked_stracks_states[id_mask].tolist()
- tracked_stracks_values = tracked_stracks_values_tg.numpy()
- tracked_stracks_values = tracked_stracks_values[id_mask].tolist()
-
- unconfirmed_ids = unconfirmed_ids_tg.numpy()
- id_mask = unconfirmed_ids != 0
- unconfirmed_ids = unconfirmed_ids[id_mask].tolist()
- unconfirmed_values = unconfirmed_values_tg.numpy()
- unconfirmed_values = unconfirmed_values[id_mask].tolist()
- unconfirmed_bools = unconfirmed_bools_tg.numpy()
- unconfirmed_bools = unconfirmed_bools[id_mask].tolist()
- unconfirmed_states = unconfirmed_states_tg.numpy()
- unconfirmed_states = unconfirmed_states[id_mask].tolist()
- unconfirmed_covs = unconfirmed_covs_tg.numpy()
- unconfirmed_covs = unconfirmed_covs[id_mask].tolist()
- unconfirmed_means = unconfirmed_means_tg.numpy()
- unconfirmed_means = unconfirmed_means[id_mask].tolist()
- unconfirmed_fids = unconfirmed_fids_tg.numpy()
- unconfirmed_fids = unconfirmed_fids[id_mask].tolist()
- unconfirmed_startframes = unconfirmed_startframes_tg.numpy()
- unconfirmed_startframes = unconfirmed_startframes[id_mask].tolist()
- tracked_stracks_means = tracked_stracks_means + list(self.lost_stracks_means)
- tracked_stracks_covs = tracked_stracks_covs + list(self.lost_stracks_covs)
-
- # Predict the current location with KF
- if len(tracked_stracks_ids) > 0:
- multi_mean = np.asarray([st for st in tracked_stracks_means])
- multi_covariance = np.asarray([st for st in tracked_stracks_covs])
- for i in range(len(tracked_stracks_ids)):
- if tracked_stracks_states[i] != TrackState.Tracked:
- multi_mean[i][7] = 0
-
- multi_mean, multi_covariance = self.kalman_filter.multi_predict(multi_mean, multi_covariance)
- for i in range(len(tracked_stracks_ids)):
- tracked_stracks_means[i][:] = multi_mean[i].astype(np.float32)
- tracked_stracks_covs[i][:] = multi_covariance[i]
-
- for i, t in enumerate(self.tracked_stracks_covs):
- for j, p in enumerate(tracked_stracks_covs):
- if t is p:
- self.tracked_stracks_covs[i] = tracked_stracks_covs[j]
-
- atlbrs = tlbr_np_batch(tracked_stracks_values, tracked_stracks_means)
- btlbrs = tlbr_np_batch(dets_score_classes,detections_means)
- dists = iou_distance(atlbrs, btlbrs)
- dists = fuse_score(dists, dets_score_classes)
- matches, u_track, u_detection = linear_assignment(dists, thresh=self.args.match_thresh)
-
- det_values_arr = [dets_score_classes[i] for _, i in matches]
-
- for idx, (itracked, idet) in enumerate(matches):
- det_xyah = tlwh_to_xyah(tlwh_np(det_values_arr[idx], detections_means[idx]))
- x, y = self.kalman_filter.update(tracked_stracks_means[itracked], tracked_stracks_covs[itracked], det_xyah)
- tracked_stracks_covs[itracked][:] = y
- tracked_stracks_means[itracked][:] = x
- tracked_stracks_fids[itracked] = self.frame_id
- if itracked < len(self.tracked_stracks_fids): self.tracked_stracks_fids[itracked] = self.frame_id
-
- if tracked_stracks_states[itracked] == TrackState.Tracked:
- activated_stracks_values.append(tracked_stracks_values[itracked])
- activated_stracks_means.append(tracked_stracks_means[itracked])
- activated_stracks_bools.append(tracked_stracks_bools[itracked])
- activated_stracks_covs.append(tracked_stracks_covs[itracked])
- activated_stracks_ids.append(tracked_stracks_ids[itracked])
- activated_stracks_fids.append(tracked_stracks_fids[itracked])
- activated_stracks_startframes.append(tracked_stracks_startframes[itracked])
- activated_stracks_states.append(tracked_stracks_states[itracked])
- else:
- tracked_stracks_states[itracked] = TrackState.Tracked
- tracked_stracks_bools[itracked] = True
- refind_stracks_values.append(tracked_stracks_values[itracked])
- refind_stracks_means.append(tracked_stracks_means[itracked])
- refind_stracks_bools.append(True)
- refind_stracks_covs.append(tracked_stracks_covs[itracked])
- refind_stracks_ids.append(tracked_stracks_ids[itracked])
- refind_stracks_fids.append(tracked_stracks_fids[itracked])
- refind_stracks_startframes.append(tracked_stracks_startframes[itracked])
- refind_stracks_states.append(tracked_stracks_states[itracked])
-
- r_tracked_stracks_values = []
- r_tracked_stracks_means = []
- r_tracked_stracks_bools = []
- r_tracked_stracks_covs = []
- r_tracked_stracks_ids = []
- r_tracked_stracks_fids = []
- r_tracked_stracks_startframes = []
- r_tracked_stracks_states = []
-
- for i in range(len(u_track)):
- if tracked_stracks_states[u_track[i]] == TrackState.Tracked:
- r_tracked_stracks_values.append(tracked_stracks_values[u_track[i]])
- r_tracked_stracks_means.append(tracked_stracks_means[u_track[i]])
- r_tracked_stracks_bools.append(tracked_stracks_bools[u_track[i]])
- r_tracked_stracks_covs.append(tracked_stracks_covs[u_track[i]])
- r_tracked_stracks_ids.append(tracked_stracks_ids[u_track[i]])
- r_tracked_stracks_fids.append(tracked_stracks_fids[u_track[i]])
- r_tracked_stracks_startframes.append(tracked_stracks_startframes[u_track[i]])
- r_tracked_stracks_states.append(tracked_stracks_states[u_track[i]])
-
- det_values = dets_score_classes_second
- det_means = [None] * len(det_values) # all means are None initially
-
- atlbrs = tlbr_np_batch(r_tracked_stracks_values, r_tracked_stracks_means)
- btlbrs = tlbr_np_batch(det_values, det_means)
- dists = iou_distance(atlbrs, btlbrs)
-
- matches, u_track, _ = linear_assignment(dists, thresh=0.5)
-
- for itracked, idet in matches:
- mean = r_tracked_stracks_means[itracked]
- bool_val = r_tracked_stracks_bools[itracked]
- cov = r_tracked_stracks_covs[itracked]
- startframe = r_tracked_stracks_startframes[itracked]
- state = r_tracked_stracks_states[itracked]
- id_val = r_tracked_stracks_ids[itracked]
- fid = r_tracked_stracks_fids[itracked]
- values = r_tracked_stracks_values[itracked]
- t_val = r_tracked_stracks_values[itracked]
- d_val = det_values[idet]
- d_mean = det_means[idet]
-
- xyah = tlwh_to_xyah(tlwh_np(d_val, d_mean))
- r_tracked_stracks_means[itracked][:], x = self.kalman_filter.update(mean, cov, xyah)
- r_tracked_stracks_covs[itracked][:] = x
- t_val = list(t_val)
- t_val[4] = d_val[4] # Update score
- r_tracked_stracks_values[itracked] = tuple(t_val)
- r_tracked_stracks_fids[itracked] = self.frame_id
-
- # Update tracked_stracks attributes if track exists in tracked_stracks
- for i, t in enumerate(self.tracked_stracks_ids):
- if t is id_val:
- self.tracked_stracks_fids[i] = self.frame_id
- self.tracked_stracks_values[i] = tuple(t_val)
- self.tracked_stracks_means[i] = r_tracked_stracks_means[itracked]
- self.tracked_stracks_covs[i] = r_tracked_stracks_covs[itracked]
- self.tracked_stracks_states[i] = TrackState.Tracked
- break
-
- if state == TrackState.Tracked:
- activated_stracks_values.append(r_tracked_stracks_values[itracked])
- activated_stracks_means.append(r_tracked_stracks_means[itracked])
- activated_stracks_bools.append(bool_val)
- activated_stracks_covs.append(r_tracked_stracks_covs[itracked])
- activated_stracks_ids.append(id_val)
- activated_stracks_fids.append(self.frame_id)
- activated_stracks_startframes.append(startframe)
- activated_stracks_states.append(state)
- else:
- r_tracked_stracks_bools[itracked] = True
- r_tracked_stracks_states[itracked] = TrackState.Tracked
- refind_stracks_values.append(r_tracked_stracks_values[itracked])
- refind_stracks_means.append(r_tracked_stracks_means[itracked])
- refind_stracks_bools.append(True)
- refind_stracks_covs.append(r_tracked_stracks_covs[itracked])
- refind_stracks_ids.append(id_val)
- refind_stracks_fids.append(self.frame_id)
- refind_stracks_startframes.append(startframe)
- refind_stracks_states.append(state)
-
- for i in range(len(u_track)):
- values = r_tracked_stracks_values[u_track[i]]
- mean = r_tracked_stracks_means[u_track[i]]
- bool_val = r_tracked_stracks_bools[u_track[i]]
- cov = r_tracked_stracks_covs[u_track[i]]
- id_val = r_tracked_stracks_ids[u_track[i]]
- fid = r_tracked_stracks_fids[u_track[i]]
- startframe = r_tracked_stracks_startframes[u_track[i]]
- state = r_tracked_stracks_states[u_track[i]]
- if state != TrackState.Lost:
- for j, t in enumerate(self.tracked_stracks_ids):
- if t is id_val:
- self.tracked_stracks_states[j] = TrackState.Lost
- break
- lost_stracks_values.append(values)
- lost_stracks_means.append(mean)
- lost_stracks_bools.append(bool_val)
- lost_stracks_covs.append(cov)
- lost_stracks_ids.append(id_val)
- lost_stracks_fids.append(fid)
- lost_stracks_startframes.append(startframe)
- lost_stracks_states.append(TrackState.Lost)
-
- u_detection_np = np.array(u_detection)
- detections_ids = np.array(detections_ids)[u_detection_np]
- detections_fids = np.array(detections_fids)[u_detection_np]
- detections_bools = np.array(detections_bools)[u_detection_np]
- detections_means = np.array(detections_means)[u_detection_np]
- detections_cov = np.array(detections_cov)[u_detection_np]
- detections_startframes = np.array(detections_startframes)[u_detection_np]
- detections_states = np.array(detections_states)[u_detection_np]
- dets_score_classes_second = np.array(dets_score_classes)[u_detection_np]
-
- atlbrs = tlbr_np_batch(unconfirmed_values, unconfirmed_means)
- btlbrs = tlbr_np_batch(dets_score_classes_second, detections_means)
- dists = iou_distance(atlbrs, btlbrs)
- dists = fuse_score(dists, dets_score_classes_second)
- matches, u_unconfirmed, u_detection = linear_assignment(dists, thresh=0.7)
-
- updated_means = []
- tracks_values = []
- updated_bools = []
- updated_covs = []
- updated_ids = []
- updated_fids = []
- updated_startframes = []
- updated_states = []
-
- if len(matches) > 0:
- matches_arr = np.array(matches)
- itracked_arr = matches_arr[:, 0]
- idet_arr = matches_arr[:, 1]
- ids = [unconfirmed_ids[i] for i in itracked_arr]
- fids = [unconfirmed_fids[i] for i in itracked_arr]
- startframes = [unconfirmed_startframes[i] for i in itracked_arr]
- states = [unconfirmed_states[i] for i in itracked_arr]
- updated_bools = [unconfirmed_bools[i] for i in itracked_arr]
- means = [unconfirmed_means[i] for i in itracked_arr]
- tracks_values = [unconfirmed_values[i] for i in itracked_arr]
-
-
- covariances = [unconfirmed_covs[i] for i in itracked_arr]
- det_values = dets_score_classes_second[idet_arr]
- tlwhs = det_values[:, :4]
- scores = det_values[:, 4]
-
- for mean, cov, tlwh, id, sf, fid, state in zip(means, covariances, tlwhs, ids, startframes, fids, states):
- new_mean, new_cov = self.kalman_filter.update(mean, cov, tlwh_to_xyah(tlwh))
- updated_means.append(new_mean)
- updated_covs.append(new_cov)
- updated_ids.append(id)
- updated_fids.append(fid)
- updated_startframes.append(sf)
- updated_states.append(state)
-
- updated_scores = scores
- frame_id_val = self.frame_id
- for i, (mean, cov, score, values, fids, id) in enumerate(zip(updated_means, updated_covs, updated_scores, tracks_values, updated_fids, updated_ids)):
- covariances[i][:] = cov
- values = list(values)
- values[4] = score
- values = tuple(values)
- updated_fids[i] = frame_id_val
- updated_states[i] = TrackState.Tracked
-
- if id in self.tracked_stracks_ids:
- idx = self.tracked_stracks_ids.index(id)
- self.tracked_stracks_bools[idx] = True
- self.tracked_stracks_states[idx] = TrackState.Tracked
-
- activated_stracks_bools.extend(updated_bools)
- activated_stracks_values.extend(tracks_values)
- activated_stracks_means.extend(updated_means)
- activated_stracks_covs.extend(updated_covs)
- activated_stracks_ids.extend(updated_ids)
- activated_stracks_fids.extend(updated_fids)
- activated_stracks_startframes.extend(updated_startframes)
- activated_stracks_states.extend(updated_states)
-
- u_unconfirmed_np = np.asarray(u_unconfirmed)
- ids = np.fromiter((unconfirmed_ids[key] for key in u_unconfirmed_np), dtype=object)
- if ids.size > 0:
- removed_stracks_ids.extend(ids.tolist())
-
- u_detection = np.asarray(u_detection)
- track_scores = dets_score_classes_second[u_detection, 4] # Direct score access
- valid_mask = track_scores >= self.det_thresh
- valid_indices = u_detection[valid_mask].tolist() # Convert to list of integers
-
- # Get tracks using proper list indexing
-
- valid_values = dets_score_classes_second[valid_indices] # Get corresponding values
- valid_means = [detections_means[i] for i in valid_indices]
- valid_bools = [detections_bools[i] for i in valid_indices]
- valid_covs = [detections_cov[i] for i in valid_indices]
- valid_ids = [detections_ids[i] for i in valid_indices]
- valid_fids = [detections_fids[i] for i in valid_indices]
- valid_startframes = [detections_startframes[i] for i in valid_indices]
- valid_states = [detections_states[i] for i in valid_indices]
-
- for i, (vals, mean) in enumerate(zip(valid_values, valid_means)):
- y = self._count = self._count + 1
- valid_ids[i] = y
- valid_means[i], x = self.kalman_filter.initiate(
- tlwh_to_xyah(vals[:4]))
- valid_covs[i] = x
- if self.frame_id == 1:
- valid_bools[i] = True
- valid_fids[i] = self.frame_id
-
- activated_stracks_means.extend(valid_means)
- activated_stracks_values.extend(valid_values)
- activated_stracks_bools.extend(valid_bools)
- activated_stracks_covs.extend(valid_covs)
- activated_stracks_ids.extend(valid_ids)
- activated_stracks_fids.extend(valid_fids)
- activated_stracks_startframes.extend(valid_startframes)
- activated_stracks_states.extend(valid_states)
- remove_mask = (self.frame_id - np.array(self.lost_stracks_fids)) > self.max_time_lost
- for t in np.array(self.lost_stracks_states)[remove_mask]: t = TrackState.Removed
- self.lost_stracks_means = np.array(self.lost_stracks_means)[~remove_mask]
- self.lost_stracks_bools = np.array(self.lost_stracks_bools)[~remove_mask]
- self.lost_stracks_values = (np.array(self.lost_stracks_values)[~remove_mask])
- self.lost_stracks_covs = np.array(self.lost_stracks_covs)[~remove_mask]
- self.lost_stracks_ids = np.array(self.lost_stracks_ids)[~remove_mask]
- self.lost_stracks_fids = np.array(self.lost_stracks_fids)[~remove_mask]
- self.lost_stracks_startframes = np.array(self.lost_stracks_startframes)[~remove_mask]
- self.lost_stracks_states = np.array(self.lost_stracks_states)[~remove_mask]
-
- self.tracked_stracks_states_tg = Tensor(self.tracked_stracks_states)
- mask_tg = self.tracked_stracks_states_tg == TrackState.Tracked
- self.tracked_stracks_ids_tg = Tensor(self.tracked_stracks_ids)
- self.tracked_stracks_ids_tg *= mask_tg
- self.tracked_stracks_ids = self.tracked_stracks_ids_tg.numpy()
- mask = self.tracked_stracks_ids != 0
-
- self.tracked_stracks_values = np.array(self.tracked_stracks_values)[mask]
- self.tracked_stracks_means = np.array(self.tracked_stracks_means)[mask]
- self.tracked_stracks_bools = np.array(self.tracked_stracks_bools)[mask]
- self.tracked_stracks_covs = np.array(self.tracked_stracks_covs)[mask]
- self.tracked_stracks_fids = np.array(self.tracked_stracks_fids)[mask]
- self.tracked_stracks_ids = np.array(self.tracked_stracks_ids)[mask]
- self.tracked_stracks_startframes = np.array(self.tracked_stracks_startframes)[mask]
- self.tracked_stracks_states = np.array(self.tracked_stracks_states)[mask]
-
- keep_activated = np.where(~np.isin(activated_stracks_ids, self.tracked_stracks_ids))[0]
- keep_activated_tg = Tensor(keep_activated)
-
- self.tracked_stracks_ids_tg = Tensor(self.tracked_stracks_ids,dtype=dtypes.int)
- activated_stracks_ids_tg = Tensor(activated_stracks_ids,dtype=dtypes.int)
- self.tracked_stracks_fids_tg = Tensor(self.tracked_stracks_fids,dtype=dtypes.int)
- activated_stracks_fids_tg = Tensor(activated_stracks_fids,dtype=dtypes.int)
- self.tracked_stracks_states_tg = Tensor(self.tracked_stracks_states,dtype=dtypes.int)
- activated_stracks_states_tg = Tensor(activated_stracks_states,dtype=dtypes.int)
- self.tracked_stracks_startframes_tg = Tensor(self.tracked_stracks_startframes,dtype=dtypes.int)
- activated_stracks_startframes_tg = Tensor(activated_stracks_startframes)
- self.tracked_stracks_bools_tg = Tensor(self.tracked_stracks_bools,dtype=dtypes.bool)
- activated_stracks_bools_tg = Tensor(activated_stracks_bools,dtype=dtypes.bool)
- self.tracked_stracks_values_tg = Tensor(self.tracked_stracks_values,dtype=dtypes.float32)
- activated_stracks_values_tg = Tensor(activated_stracks_values,dtype=dtypes.float32)
- self.tracked_stracks_means_tg = Tensor(self.tracked_stracks_means,dtype=dtypes.float32)
- activated_stracks_means_tg = Tensor(activated_stracks_means,dtype=dtypes.float32)
- self.tracked_stracks_covs_tg = Tensor(self.tracked_stracks_covs,dtype=dtypes.float32)
- activated_stracks_covs_tg = Tensor(activated_stracks_covs,dtype=dtypes.float32)
-
-
- self.tracked_stracks_ids_tg = self.tracked_stracks_ids_tg.cat(activated_stracks_ids_tg[keep_activated_tg])
- self.tracked_stracks_fids_tg = self.tracked_stracks_fids_tg.cat(activated_stracks_fids_tg[keep_activated_tg])
- self.tracked_stracks_states_tg = self.tracked_stracks_states_tg.cat(activated_stracks_states_tg[keep_activated_tg])
- self.tracked_stracks_startframes_tg = self.tracked_stracks_startframes_tg.cat(activated_stracks_startframes_tg[keep_activated_tg])
- self.tracked_stracks_bools_tg = self.tracked_stracks_bools_tg.cat(activated_stracks_bools_tg[keep_activated_tg])
- if self.tracked_stracks_values_tg.shape[0] > 0:
- self.tracked_stracks_values_tg = self.tracked_stracks_values_tg.cat(activated_stracks_values_tg[keep_activated_tg])
- self.tracked_stracks_means_tg = self.tracked_stracks_means_tg.cat(activated_stracks_means_tg[keep_activated_tg])
- self.tracked_stracks_covs_tg = self.tracked_stracks_covs_tg.cat(activated_stracks_covs_tg[keep_activated_tg])
- else:
- self.tracked_stracks_values_tg = activated_stracks_values_tg[keep_activated_tg]
- self.tracked_stracks_means_tg = activated_stracks_means_tg[keep_activated_tg]
- self.tracked_stracks_covs_tg = activated_stracks_covs_tg[keep_activated_tg]
-
- self.tracked_stracks_ids = self.tracked_stracks_ids_tg.numpy()
- self.tracked_stracks_covs = self.tracked_stracks_covs_tg.numpy()
-
- refind_stracks_fids_tg = Tensor(refind_stracks_fids)
- refind_stracks_bools_tg = Tensor(refind_stracks_bools)
- refind_stracks_states_tg = Tensor(refind_stracks_states,dtype=dtypes.int)
- refind_stracks_startframes_tg = Tensor(refind_stracks_startframes)
- refind_stracks_values_tg = Tensor(refind_stracks_values)
- refind_stracks_means_tg = Tensor(refind_stracks_means)
- refind_stracks_covs_tg = Tensor(refind_stracks_covs)
-
- self.tracked_stracks_fids_tg = self.tracked_stracks_fids_tg.cat(refind_stracks_fids_tg)
- self.tracked_stracks_bools_tg = self.tracked_stracks_bools_tg.cat(refind_stracks_bools_tg)
- self.tracked_stracks_states_tg = self.tracked_stracks_states_tg.cat(refind_stracks_states_tg)
- self.tracked_stracks_startframes_tg = self.tracked_stracks_startframes_tg.cat(refind_stracks_startframes_tg)
- if refind_stracks_means_tg.shape[0] > 0:
- self.tracked_stracks_means_tg = self.tracked_stracks_means_tg.cat(refind_stracks_means_tg)
- self.tracked_stracks_values_tg = self.tracked_stracks_values_tg.cat(refind_stracks_values_tg)
- self.tracked_stracks_covs_tg = self.tracked_stracks_covs_tg.cat(refind_stracks_covs_tg)
-
- self.tracked_stracks_ids = np.array(self.tracked_stracks_ids).tolist() + np.array(refind_stracks_ids).tolist()
-
- self.tracked_stracks_fids = self.tracked_stracks_fids_tg.numpy()
- self.tracked_stracks_bools = self.tracked_stracks_bools_tg.numpy()
- self.tracked_stracks_states = self.tracked_stracks_states_tg.numpy()
- self.tracked_stracks_startframes = self.tracked_stracks_startframes_tg.numpy()
- self.tracked_stracks_values = self.tracked_stracks_values_tg.numpy()
- self.tracked_stracks_means = self.tracked_stracks_means_tg.numpy()
- self.tracked_stracks_covs = self.tracked_stracks_covs_tg.numpy()
-
- mask = ~np.isin(self.lost_stracks_ids, self.tracked_stracks_ids)
- mask_tg = Tensor(mask)
-
- self.lost_stracks_ids_tg = Tensor(self.lost_stracks_ids)
- self.lost_stracks_fids_tg = Tensor(self.lost_stracks_fids)
- self.lost_stracks_startframes_tg = Tensor(self.lost_stracks_startframes)
- self.lost_stracks_states_tg = Tensor(self.lost_stracks_states)
- self.lost_stracks_bools_tg = Tensor(self.lost_stracks_bools)
- self.lost_stracks_values_tg = Tensor(self.lost_stracks_values)
- self.lost_stracks_means_tg = Tensor(self.lost_stracks_means)
- self.lost_stracks_covs_tg = Tensor(self.lost_stracks_covs)
-
-
- self.lost_stracks_ids_tg *= mask_tg
- self.lost_stracks_fids_tg *= mask_tg
- self.lost_stracks_startframes_tg *= mask_tg
- self.lost_stracks_states_tg *= mask_tg
- self.lost_stracks_bools_tg *= mask_tg
- self.lost_stracks_values_tg = self.lost_stracks_values_tg * mask_tg.view(-1, 1)
- self.lost_stracks_means_tg = self.lost_stracks_means_tg * mask_tg.view(-1, 1)
- self.lost_stracks_covs_tg = self.lost_stracks_covs_tg * mask_tg.view(-1, 1, 1)
-
- lost_stracks_values_tg = Tensor(lost_stracks_values)
- lost_stracks_means_tg = Tensor(lost_stracks_means)
- lost_stracks_bools_tg = Tensor(lost_stracks_bools)
- lost_stracks_covs_tg = Tensor(lost_stracks_covs)
- lost_stracks_ids_tg = Tensor(lost_stracks_ids)
- lost_stracks_fids_tg = Tensor(lost_stracks_fids)
- lost_stracks_startframes_tg = Tensor(lost_stracks_startframes)
- lost_stracks_states_tg = Tensor(lost_stracks_states)
-
- if self.lost_stracks_values_tg.shape[0] == 0:
- self.lost_stracks_values_tg = lost_stracks_values_tg
- self.lost_stracks_means_tg = lost_stracks_means_tg
- self.lost_stracks_bools_tg = lost_stracks_bools_tg
- self.lost_stracks_covs_tg = lost_stracks_covs_tg
- self.lost_stracks_ids_tg = lost_stracks_ids_tg
- self.lost_stracks_fids_tg = lost_stracks_fids_tg
- self.lost_stracks_startframes_tg = lost_stracks_startframes_tg
- self.lost_stracks_states_tg = lost_stracks_states_tg
- self.lost_stracks_states_tg = lost_stracks_states_tg
- elif lost_stracks_values_tg.shape[0] != 0:
- self.lost_stracks_values_tg = self.lost_stracks_values_tg.cat(lost_stracks_values_tg)
- self.lost_stracks_means_tg = self.lost_stracks_means_tg.cat(lost_stracks_means_tg)
- self.lost_stracks_bools_tg = self.lost_stracks_bools_tg.cat(lost_stracks_bools_tg)
- self.lost_stracks_covs_tg = self.lost_stracks_covs_tg.cat(lost_stracks_covs_tg)
- self.lost_stracks_ids_tg = self.lost_stracks_ids_tg.cat(lost_stracks_ids_tg)
- self.lost_stracks_fids_tg = self.lost_stracks_fids_tg.cat(lost_stracks_fids_tg)
- self.lost_stracks_startframes_tg = self.lost_stracks_startframes_tg.cat(lost_stracks_startframes_tg)
- self.lost_stracks_states_tg = self.lost_stracks_states_tg.cat(lost_stracks_states_tg)
-
- self.lost_stracks_values = self.lost_stracks_values_tg.numpy()
- self.lost_stracks_means = self.lost_stracks_means_tg.numpy()
- self.lost_stracks_bools = self.lost_stracks_bools_tg.numpy()
- self.lost_stracks_covs = self.lost_stracks_covs_tg.numpy()
- self.lost_stracks_ids = self.lost_stracks_ids_tg.numpy()
- self.lost_stracks_fids = self.lost_stracks_fids_tg.numpy()
- self.lost_stracks_startframes = self.lost_stracks_startframes_tg.numpy()
- self.lost_stracks_states = self.lost_stracks_states_tg.numpy()
-
- self.tracked_stracks_bools_tg = Tensor(self.tracked_stracks_bools).unsqueeze(-1)
- self.tracked_stracks_means_tg = Tensor(self.tracked_stracks_means)
- self.tracked_stracks_ids_tg = Tensor(self.tracked_stracks_ids)
- self.tracked_stracks_values_tg = Tensor(self.tracked_stracks_values)
-
-
- output_stracks_means_tg = self.tracked_stracks_means_tg * self.tracked_stracks_bools_tg
- output_stracks_values_tg = self.tracked_stracks_values_tg * self.tracked_stracks_bools_tg
- output_stracks_ids_tg = self.tracked_stracks_ids_tg * self.tracked_stracks_bools_tg.squeeze(-1)
-
- zeros = self.lost_stracks_ids != 0
- self.lost_stracks_ids = self.lost_stracks_ids[zeros]
- self.lost_stracks_fids = self.lost_stracks_fids[zeros]
- self.lost_stracks_startframes = self.lost_stracks_startframes[zeros]
- self.lost_stracks_states = self.lost_stracks_states[zeros]
- self.lost_stracks_bools = self.lost_stracks_bools[zeros]
- self.lost_stracks_values = self.lost_stracks_values[zeros]
- self.lost_stracks_means = self.lost_stracks_means[zeros]
- self.lost_stracks_covs = self.lost_stracks_covs[zeros]
- v,m,i = output_stracks_values_tg.numpy(), output_stracks_means_tg.numpy(), output_stracks_ids_tg.numpy()
- return v,m,i
-
-
-def ious(atlbrs, btlbrs):
- """
- Compute cost based on IoU
- :type atlbrs: list[tlbr] | np.ndarray
- :type atlbrs: list[tlbr] | np.ndarray
-
- :rtype ious np.ndarray
- """
- ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float)
- if ious.size == 0:
- return ious
-
- ious = bbox_ious(np.ascontiguousarray(atlbrs, dtype=np.float), np.ascontiguousarray(btlbrs, dtype=np.float))
- return ious
-
-def iou_distance(atlbrs, btlbrs):
- _ious = ious(atlbrs, btlbrs)
- cost_matrix = 1 - _ious
- return cost_matrix
-
-def fuse_score(cost_matrix, det_values):
- if cost_matrix.size == 0:
- return cost_matrix
- iou_sim = 1 - cost_matrix
- det_scores = np.array([det[4] for det in det_values])
- det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
- fuse_sim = iou_sim * det_scores
- fuse_cost = 1 - fuse_sim
- return fuse_cost
-
-def linear_assignment(cost_matrix, thresh):
- if cost_matrix.size == 0:
- return np.empty((0, 2), dtype=int), np.arange(cost_matrix.shape[0]), np.arange(cost_matrix.shape[1])
- _, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)
- matched_mask = x >= 0
- matches = np.column_stack((np.arange(len(x))[matched_mask],x[matched_mask]))
- unmatched_a = np.where(~matched_mask)[0]
- unmatched_b = np.where(y < 0)[0]
- return matches, unmatched_a, unmatched_b
-
-
-#Model architecture from https://github.com/ultralytics/ultralytics/issues/189
-#The upsampling class has been taken from this pull request https://github.com/tinygrad/tinygrad/pull/784 by dc-dc-dc. Now 2(?) models use upsampling. (retinet and this)
-
-#Pre processing image functions.
-def compute_transform(image, new_shape=(1280, 1280), auto=False, scaleFill=False, scaleup=True, stride=32) -> Tensor:
- shape = image.shape[:2] # current shape [height, width]
- new_shape = (new_shape, new_shape) if isinstance(new_shape, int) else new_shape
- r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
- r = min(r, 1.0) if not scaleup else r
- new_unpad = (int(round(shape[1] * r)), int(round(shape[0] * r)))
- dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
- dw, dh = (np.mod(dw, stride), np.mod(dh, stride)) if auto else (0.0, 0.0)
- new_unpad = (new_shape[1], new_shape[0]) if scaleFill else new_unpad
- dw /= 2
- dh /= 2
- image = cv2.resize(image, new_unpad, interpolation=cv2.INTER_LINEAR) if shape[::-1] != new_unpad else image
- top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
- left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
- image = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))
- return Tensor(image)
-
-def preprocess(im, imgsz=1280, model_stride=32, model_pt=True):
- im = compute_transform(im, new_shape=imgsz, auto=True, stride=model_stride)
- im = im.unsqueeze(0)
- im = im[..., ::-1].permute(0, 3, 1, 2)
- im = im / 255.0
- return im
-
-# utility functions for forward pass.
-def dist2bbox(distance, anchor_points, xywh=True, dim=-1):
- lt, rb = distance.chunk(2, dim)
- x1y1 = anchor_points - lt
- x2y2 = anchor_points + rb
- if xywh:
- c_xy = (x1y1 + x2y2) / 2
- wh = x2y2 - x1y1
- return c_xy.cat(wh, dim=1)
- return x1y1.cat(x2y2, dim=1)
-
-def make_anchors(feats, strides, grid_cell_offset=0.5):
- anchor_points, stride_tensor = [], []
- assert feats is not None
- for i, stride in enumerate(strides):
- _, _, h, w = feats[i].shape
- sx = Tensor.arange(w) + grid_cell_offset
- sy = Tensor.arange(h) + grid_cell_offset
-
- # this is np.meshgrid but in tinygrad
- sx = sx.reshape(1, -1).repeat([h, 1]).reshape(-1)
- sy = sy.reshape(-1, 1).repeat([1, w]).reshape(-1)
-
- anchor_points.append(Tensor.stack(sx, sy, dim=-1).reshape(-1, 2))
- stride_tensor.append(Tensor.full((h * w), stride))
- anchor_points = anchor_points[0].cat(anchor_points[1], anchor_points[2])
- stride_tensor = stride_tensor[0].cat(stride_tensor[1], stride_tensor[2]).unsqueeze(1)
- return anchor_points, stride_tensor
-
-# this function is from the original implementation
-def autopad(k, p=None, d=1): # kernel, padding, dilation
- if d > 1:
- k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k] # actual kernel-size
- if p is None:
- p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad
- return p
-
-def clip_boxes(boxes, shape):
- boxes[..., [0, 2]] = np.clip(boxes[..., [0, 2]], 0, shape[1]) # x1, x2
- boxes[..., [1, 3]] = np.clip(boxes[..., [1, 3]], 0, shape[0]) # y1, y2
- return boxes
-
-def scale_boxes(img1_shape, predictions, img0_shape, ratio_pad=None):
- gain = ratio_pad if ratio_pad else min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])
- pad = ((img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2)
- for pred in predictions:
- boxes_np = pred[:4].numpy() if isinstance(pred[:4], Tensor) else pred[:4]
- boxes_np[..., [0, 2]] -= pad[0]
- boxes_np[..., [1, 3]] -= pad[1]
- boxes_np[..., :4] /= gain
- boxes_np = clip_boxes(boxes_np, img0_shape)
- pred[:4] = boxes_np
- return predictions
-
-def get_variant_multiples(variant):
- return {'n':(0.33, 0.25, 2.0), 's':(0.33, 0.50, 2.0), 'm':(0.67, 0.75, 1.5), 'l':(1.0, 1.0, 1.0), 'x':(1, 1.25, 1.0) }.get(variant, None)
-
-def label_predictions(all_predictions):
- class_index_count = defaultdict(int)
- for pred in all_predictions:
- class_id = int(pred[-1])
- if pred[-2] != 0: class_index_count[class_id] += 1
-
- return dict(class_index_count)
-
-#this is taken from https://github.com/tinygrad/tinygrad/pull/784/files by dc-dc-dc (Now 2 models use upsampling)
-class Upsample:
- def __init__(self, scale_factor:int, mode: str = "nearest") -> None:
- assert mode == "nearest" # only mode supported for now
- self.mode = mode
- self.scale_factor = scale_factor
-
- def __call__(self, x: Tensor) -> Tensor:
- assert len(x.shape) > 2 and len(x.shape) <= 5
- (b, c), _lens = x.shape[:2], len(x.shape[2:])
- tmp = x.reshape([b, c, -1] + [1] * _lens) * Tensor.ones(*[1, 1, 1] + [self.scale_factor] * _lens)
- return tmp.reshape(list(x.shape) + [self.scale_factor] * _lens).permute([0, 1] + list(chain.from_iterable([[y+2, y+2+_lens] for y in range(_lens)]))).reshape([b, c] + [x * self.scale_factor for x in x.shape[2:]])
-
-class Conv_Block:
- def __init__(self, c1, c2, kernel_size=1, stride=1, groups=1, dilation=1, padding=None):
- self.conv = Conv2d(c1,c2, kernel_size, stride, padding=autopad(kernel_size, padding, dilation), bias=False, groups=groups, dilation=dilation)
- self.bn = BatchNorm2d(c2, eps=0.001)
-
- def __call__(self, x):
- return self.bn(self.conv(x)).silu()
-
-class Bottleneck:
- def __init__(self, c1, c2 , shortcut: bool, g=1, kernels: list = (3,3), channel_factor=0.5):
- c_ = int(c2 * channel_factor)
- self.cv1 = Conv_Block(c1, c_, kernel_size=kernels[0], stride=1, padding=None)
- self.cv2 = Conv_Block(c_, c2, kernel_size=kernels[1], stride=1, padding=None, groups=g)
- self.residual = c1 == c2 and shortcut
-
- def __call__(self, x):
- return x + self.cv2(self.cv1(x)) if self.residual else self.cv2(self.cv1(x))
-
-class C2f:
- def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
- self.c = int(c2 * e)
- self.cv1 = Conv_Block(c1, 2 * self.c, 1,)
- self.cv2 = Conv_Block((2 + n) * self.c, c2, 1)
- self.bottleneck = [Bottleneck(self.c, self.c, shortcut, g, kernels=[(3, 3), (3, 3)], channel_factor=1.0) for _ in range(n)]
-
- def __call__(self, x):
- y= list(self.cv1(x).chunk(2, 1))
- y.extend(m(y[-1]) for m in self.bottleneck)
- z = y[0]
- for i in y[1:]: z = z.cat(i, dim=1)
- return self.cv2(z)
-
-class SPPF:
- def __init__(self, c1, c2, k=5):
- c_ = c1 // 2 # hidden channels
- self.cv1 = Conv_Block(c1, c_, 1, 1, padding=None)
- self.cv2 = Conv_Block(c_ * 4, c2, 1, 1, padding=None)
-
- # TODO: this pads with 0s, whereas torch function pads with -infinity. This results in a < 2% difference in prediction which does not make a difference visually.
- self.maxpool = lambda x : x.pad((k // 2, k // 2, k // 2, k // 2)).max_pool2d(kernel_size=k, stride=1)
-
- def __call__(self, x):
- x = self.cv1(x)
- x2 = self.maxpool(x)
- x3 = self.maxpool(x2)
- x4 = self.maxpool(x3)
- return self.cv2(x.cat(x2, x3, x4, dim=1))
-
-class DFL:
- def __init__(self, c1=16):
- self.conv = Conv2d(c1, 1, 1, bias=False)
- x = Tensor.arange(c1)
- self.conv.weight.replace(x.reshape(1, c1, 1, 1))
- self.c1 = c1
-
- def __call__(self, x):
- b, c, a = x.shape # batch, channels, anchors
- return self.conv(x.reshape(b, 4, self.c1, a).transpose(2, 1).softmax(1)).reshape(b, 4, a)
-
-#backbone
-class Darknet:
- def __init__(self, w, r, d):
- self.b1 = [Conv_Block(c1=3, c2= int(64*w), kernel_size=3, stride=2, padding=1), Conv_Block(int(64*w), int(128*w), kernel_size=3, stride=2, padding=1)]
- self.b2 = [C2f(c1=int(128*w), c2=int(128*w), n=round(3*d), shortcut=True), Conv_Block(int(128*w), int(256*w), 3, 2, 1), C2f(int(256*w), int(256*w), round(6*d), True)]
- self.b3 = [Conv_Block(int(256*w), int(512*w), kernel_size=3, stride=2, padding=1), C2f(int(512*w), int(512*w), round(6*d), True)]
- self.b4 = [Conv_Block(int(512*w), int(512*w*r), kernel_size=3, stride=2, padding=1), C2f(int(512*w*r), int(512*w*r), round(3*d), True)]
- self.b5 = [SPPF(int(512*w*r), int(512*w*r), 5)]
-
- def return_modules(self):
- return [*self.b1, *self.b2, *self.b3, *self.b4, *self.b5]
-
- def __call__(self, x):
- x1 = x.sequential(self.b1)
- x2 = x1.sequential(self.b2)
- x3 = x2.sequential(self.b3)
- x4 = x3.sequential(self.b4)
- x5 = x4.sequential(self.b5)
- return (x2, x3, x5)
-
-#yolo fpn (neck)
-class Yolov8NECK:
- def __init__(self, w, r, d): #width_multiple, ratio_multiple, depth_multiple
- self.up = Upsample(2, mode='nearest')
- self.n1 = C2f(c1=int(512*w*(1+r)), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n2 = C2f(c1=int(768*w), c2=int(256*w), n=round(3*d), shortcut=False)
- self.n3 = Conv_Block(c1=int(256*w), c2=int(256*w), kernel_size=3, stride=2, padding=1)
- self.n4 = C2f(c1=int(768*w), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n5 = Conv_Block(c1=int(512* w), c2=int(512 * w), kernel_size=3, stride=2, padding=1)
- self.n6 = C2f(c1=int(512*w*(1+r)), c2=int(512*w*r), n=round(3*d), shortcut=False)
-
- def return_modules(self):
- return [self.n1, self.n2, self.n3, self.n4, self.n5, self.n6]
-
- def __call__(self, p3, p4, p5):
- x = self.n1(self.up(p5).cat(p4, dim=1))
- head_1 = self.n2(self.up(x).cat(p3, dim=1))
- head_2 = self.n4(self.n3(head_1).cat(x, dim=1))
- head_3 = self.n6(self.n5(head_2).cat(p5, dim=1))
- return [head_1, head_2, head_3]
-
-#task specific head.
-class DetectionHead:
- def __init__(self, nc=80, filters=()):
- self.ch = 16
- self.nc = nc # number of classes
- self.nl = len(filters)
- self.no = nc + self.ch * 4 #
- self.stride = [8, 16, 32]
- c1 = max(filters[0], self.nc)
- c2 = max((filters[0] // 4, self.ch * 4))
- self.dfl = DFL(self.ch)
- self.cv3 = [[Conv_Block(x, c1, 3), Conv_Block(c1, c1, 3), Conv2d(c1, self.nc, 1)] for x in filters]
- self.cv2 = [[Conv_Block(x, c2, 3), Conv_Block(c2, c2, 3), Conv2d(c2, 4 * self.ch, 1)] for x in filters]
-
- def __call__(self, x):
- for i in range(self.nl):
- x[i] = (x[i].sequential(self.cv2[i]).cat(x[i].sequential(self.cv3[i]), dim=1))
- self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
- y = [(i.reshape(x[0].shape[0], self.no, -1)) for i in x]
- x_cat = y[0].cat(y[1], y[2], dim=2)
- box, cls = x_cat[:, :self.ch * 4], x_cat[:, self.ch * 4:]
- dbox = dist2bbox(self.dfl(box), self.anchors.unsqueeze(0), xywh=True, dim=1) * self.strides
- z = dbox.cat(cls.sigmoid(), dim=1)
- return z
-
-class YOLOv8:
- def __init__(self, w, r, d, num_classes): #width_multiple, ratio_multiple, depth_multiple
- self.net = Darknet(w, r, d)
- self.fpn = Yolov8NECK(w, r, d)
- self.head = DetectionHead(num_classes, filters=(int(256*w), int(512*w), int(512*w*r)))
-
- def __call__(self, x):
- x = self.net(x)
- x = self.fpn(*x)
- x = self.head(x)
- # TODO: postprocess needs to be in the model to be compiled to webgpu
- return postprocess(x)
-
- def return_all_trainable_modules(self):
- backbone_modules = [*range(10)]
- yolov8neck_modules = [12, 15, 16, 18, 19, 21]
- yolov8_head_weights = [(22, self.head)]
- return [*zip(backbone_modules, self.net.return_modules()), *zip(yolov8neck_modules, self.fpn.return_modules()), *yolov8_head_weights]
-
-def convert_f16_safetensor_to_f32(input_file: Path, output_file: Path):
- with open(input_file, 'rb') as f:
- metadata_length = int.from_bytes(f.read(8), 'little')
- metadata = json.loads(f.read(metadata_length).decode())
- float32_values = np.fromfile(f, dtype=np.float16).astype(np.float32)
-
- for v in metadata.values():
- if v["dtype"] == "F16": v.update({"dtype": "F32", "data_offsets": [offset * 2 for offset in v["data_offsets"]]})
-
- with open(output_file, 'wb') as f:
- new_metadata_bytes = json.dumps(metadata).encode()
- f.write(len(new_metadata_bytes).to_bytes(8, 'little'))
- f.write(new_metadata_bytes)
- float32_values.tofile(f)
-
-def compute_iou_matrix(boxes):
- x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
- areas = (x2 - x1) * (y2 - y1)
- x1 = Tensor.maximum(x1[:, None], x1[None, :])
- y1 = Tensor.maximum(y1[:, None], y1[None, :])
- x2 = Tensor.minimum(x2[:, None], x2[None, :])
- y2 = Tensor.minimum(y2[:, None], y2[None, :])
- w = Tensor.maximum(Tensor(0), x2 - x1)
- h = Tensor.maximum(Tensor(0), y2 - y1)
- intersection = w * h
- union = areas[:, None] + areas[None, :] - intersection
- return intersection / union
-
-def postprocess(output, max_det=300, conf_threshold=0.25, iou_threshold=0.45):
- xc, yc, w, h, class_scores = output[0][0], output[0][1], output[0][2], output[0][3], output[0][4:]
- class_ids = Tensor.argmax(class_scores, axis=0)
- probs = Tensor.max(class_scores, axis=0)
- probs = Tensor.where(probs >= conf_threshold, probs, 0)
- x1 = xc - w / 2
- y1 = yc - h / 2
- x2 = xc + w / 2
- y2 = yc + h / 2
- boxes = Tensor.stack(x1, y1, x2, y2, probs, class_ids, dim=1)
- order = Tensor.topk(probs, max_det)[1]
- boxes = boxes[order]
- iou = compute_iou_matrix(boxes[:, :4])
- iou = Tensor.triu(iou, diagonal=1)
- same_class_mask = boxes[:, -1][:, None] == boxes[:, -1][None, :]
- high_iou_mask = (iou > iou_threshold) & same_class_mask
- no_overlap_mask = high_iou_mask.sum(axis=0) == 0
- boxes = boxes * no_overlap_mask.unsqueeze(-1)
- return boxes
-
-def get_weights_location(yolo_variant: str) -> Path:
- weights_location = Path(__file__).parents[1] / "weights" / f'yolov8{yolo_variant}.safetensors'
- fetch(f'https://gitlab.com/r3sist/yolov8_weights/-/raw/master/yolov8{yolo_variant}.safetensors', weights_location)
- f32_weights = weights_location.with_name(f"{weights_location.stem}_f32.safetensors")
- if not f32_weights.exists(): convert_f16_safetensor_to_f32(weights_location, f32_weights)
- return f32_weights
-
-def draw_predictions_on_frame(frame, predictions, class_labels, color_dict):
- font = cv2.FONT_HERSHEY_SIMPLEX
-
- def is_bright_color(color):
- r, g, b = color
- brightness = (r * 299 + g * 587 + b * 114) / 1000
- return brightness > 127
-
- h, w, _ = frame.shape
- box_thickness = int((h + w) / 400)
- font_scale = (h + w) / 2500
-
- for pred in predictions:
- x1, y1, x2, y2, id, class_id = pred
- x1, y1, x2, y2, class_id = map(int, (x1, y1, x2, y2, class_id))
- color = color_dict[class_labels[class_id]]
- label = f"{class_labels[class_id]} {int(id)}"
- cv2.rectangle(frame, (x1, y1), (x2, y2), color, box_thickness)
- text_size, _ = cv2.getTextSize(label, font, font_scale, 1)
- label_y, bg_y = (y1 - 4, y1 - text_size[1] - 4) if y1 - text_size[1] - 4 > 0 else (y1 + text_size[1], y1)
- cv2.rectangle(frame, (x1, bg_y), (x1 + text_size[0], bg_y + text_size[1]), color, -1)
- font_color = (0, 0, 0) if is_bright_color(color) else (255, 255, 255)
- cv2.putText(frame, label, (x1, label_y), font, font_scale, font_color, 1, cv2.LINE_AA)
-
-
-class Args:
- def __init__(self):
- self.track_thresh = 0.6
- self.track_buffer = 60 #frames, was 30
- self.mot20 = False
- self.match_thresh = 0.9
-
-tracker = BYTETracker(Args())
-
-@TinyJit
-def do_inf(image):
- predictions = yolo_infer(image)
- return predictions
-
-from urllib.request import urlopen, urlretrieve
-
-if __name__ == '__main__':
- if len(sys.argv) < 2:
- print("Error: Video URL or path not provided.")
- sys.exit(1)
-
- video_path = sys.argv[1]
- yolo_variant = sys.argv[2] if len(sys.argv) >= 3 else (print("No variant given, so choosing 'n' as default.") or 'n')
- print(f'Running inference for YOLOv8 variant: {yolo_variant}')
-
- output_folder_path = Path('./video_outputs')
- output_folder_path.mkdir(parents=True, exist_ok=True)
-
- # Download and open the video
- local_video_path = fetch(video_path).as_posix()
- cap = cv2.VideoCapture(local_video_path)
-
- if not cap.isOpened():
- print("Error: Could not open video.")
- sys.exit(1)
-
- fps = int(cap.get(cv2.CAP_PROP_FPS))
- width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
- height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
- out_path = (output_folder_path / f"{Path(local_video_path).stem}_output.mp4").as_posix()
- out_writer = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
-
- # Load YOLOv8 model
- depth, width_mult, ratio = get_variant_multiples(yolo_variant)
- yolo_infer = YOLOv8(w=width_mult, r=ratio, d=depth, num_classes=80)
- state_dict = safe_load(get_weights_location(yolo_variant))
- load_state_dict(yolo_infer, state_dict)
-
- class_labels = fetch('https://raw.githubusercontent.com/pjreddie/darknet/master/data/coco.names').read_text().split("\n")
- color_dict = {label: tuple((((i+1) * 50) % 256, ((i+1) * 100) % 256, ((i+1) * 150) % 256)) for i, label in enumerate(class_labels)}
-
-
- frame_count = 0
- people = set()
- #outs = []
- expected_values = pickle.load(open('values.pkl', 'rb'))
- while True:
- ret, frame = cap.read()
- if not ret:
- break
- frame_count += 1
-
- pre_processed = preprocess(frame)
- predictions = do_inf(pre_processed)
- values, means, track_ids = tracker.update(predictions, [1280,1280], [1280,1280])
- pred_track = np.array([np.append(tlbr_np(v,m), [tid,v[5]]) for v,m,tid in zip(values,means,track_ids)], dtype=np.float32)
-
- # sanity check print people
- for v,tid in zip(values,track_ids):
- if v[5] == 0 and tid != 0:
- people.add(tid)
-
- pred_track = scale_boxes(pre_processed.shape[2:], pred_track, frame.shape)
- predictions = predictions.numpy()
- predictions = scale_boxes(pre_processed.shape[2:], predictions, frame.shape)
-
- # Draw predictions
- #draw_predictions_on_frame(frame, predictions, class_labels, color_dict)
- draw_predictions_on_frame(frame, pred_track, class_labels, color_dict)
-
- out_writer.write(frame)
-
-
- if sys.argv[1] == "https://motchallenge.net/sequenceVideos/MOT17-08-DPM-raw.mp4":
- if not np.array_equal(np.array(expected_values[frame_count - 1]), values):
- print("wrong output")
- exit()
- #outs.append(values)
-
-
- if frame_count % 10 == 0:
- print(f"Processed frame {frame_count}")
- print(len(people))
-
- #pickle.dump(outs, open('values.pkl', 'wb'))
- cap.release()
- out_writer.release()
- print(f"Saved processed video to {out_path}")
-
-#https://motchallenge.net/sequenceVideos/MOT17-08-DPM-raw.mp4 73
-#https://motchallenge.net/sequenceVideos/MOT17-03-FRCNN-raw.mp4 173
-
diff --git a/experimental/clearcam_rtsp.py b/experimental/clearcam_rtsp.py
deleted file mode 100644
index 3762585..0000000
--- a/experimental/clearcam_rtsp.py
+++ /dev/null
@@ -1,2350 +0,0 @@
-from tinygrad.nn import Conv2d, BatchNorm2d
-from tinygrad.tensor import Tensor
-from tinygrad import TinyJit
-from tinygrad.device import is_dtype_supported
-from tinygrad import dtypes
-import numpy as np
-from itertools import chain
-from pathlib import Path
-import cv2
-from collections import defaultdict, deque
-import time, sys
-from tinygrad.helpers import fetch
-from tinygrad.nn.state import safe_load, load_state_dict
-import json
-import http
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from socketserver import ThreadingMixIn
-import threading
-import shutil
-from datetime import datetime, time as time_obj
-import uuid
-import urllib
-from urllib.parse import urlparse, parse_qs
-from pathlib import Path
-import struct
-import pickle
-from urllib.parse import unquote
-from urllib.parse import quote
-
-
-def preprocess(image, new_shape=1280, auto=True, scaleFill=False, scaleup=True, stride=32) -> Tensor:
- shape = image.shape[:2] # current shape [height, width]
- new_shape = (new_shape, new_shape) if isinstance(new_shape, int) else new_shape
- r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
- r = min(r, 1.0) if not scaleup else r
- new_unpad = (int(round(shape[1] * r)), int(round(shape[0] * r)))
- dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
- dw, dh = (np.mod(dw, stride), np.mod(dh, stride)) if auto else (0.0, 0.0)
- new_unpad = (new_shape[1], new_shape[0]) if scaleFill else new_unpad
- dw /= 2
- dh /= 2
- image = cv2.resize(image, new_unpad, interpolation=cv2.INTER_LINEAR) if shape[::-1] != new_unpad else image
- top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
- left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
- image = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))
- return Tensor(image)
-
-def dist2bbox(distance, anchor_points, xywh=True, dim=-1):
- lt, rb = distance.chunk(2, dim)
- x1y1 = anchor_points - lt
- x2y2 = anchor_points + rb
- if xywh:
- c_xy = (x1y1 + x2y2) / 2
- wh = x2y2 - x1y1
- return c_xy.cat(wh, dim=1)
- return x1y1.cat(x2y2, dim=1)
-
-def make_anchors(feats, strides, grid_cell_offset=0.5):
- anchor_points, stride_tensor = [], []
- assert feats is not None
- for i, stride in enumerate(strides):
- _, _, h, w = feats[i].shape
- sx = Tensor.arange(w) + grid_cell_offset
- sy = Tensor.arange(h) + grid_cell_offset
-
- # this is np.meshgrid but in tinygrad
- sx = sx.reshape(1, -1).repeat([h, 1]).reshape(-1)
- sy = sy.reshape(-1, 1).repeat([1, w]).reshape(-1)
-
- anchor_points.append(Tensor.stack(sx, sy, dim=-1).reshape(-1, 2))
- stride_tensor.append(Tensor.full((h * w), stride))
- anchor_points = anchor_points[0].cat(anchor_points[1], anchor_points[2])
- stride_tensor = stride_tensor[0].cat(stride_tensor[1], stride_tensor[2]).unsqueeze(1)
- return anchor_points, stride_tensor
-
-# this function is from the original implementation
-def autopad(k, p=None, d=1): # kernel, padding, dilation
- if d > 1:
- k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k] # actual kernel-size
- if p is None:
- p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad
- return p
-
-def clip_boxes(boxes, shape):
- boxes[..., [0, 2]] = np.clip(boxes[..., [0, 2]], 0, shape[1]) # x1, x2
- boxes[..., [1, 3]] = np.clip(boxes[..., [1, 3]], 0, shape[0]) # y1, y2
- return boxes
-
-def scale_boxes(img1_shape, predictions, img0_shape, ratio_pad=None):
- gain = ratio_pad if ratio_pad else min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])
- pad = ((img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2)
- for pred in predictions:
- boxes_np = pred[:4].numpy() if isinstance(pred[:4], Tensor) else pred[:4]
- boxes_np[..., [0, 2]] -= pad[0]
- boxes_np[..., [1, 3]] -= pad[1]
- boxes_np[..., :4] /= gain
- boxes_np = clip_boxes(boxes_np, img0_shape)
- pred[:4] = boxes_np
- return predictions
-
-def get_variant_multiples(variant):
- return {'n':(0.33, 0.25, 2.0), 's':(0.33, 0.50, 2.0), 'm':(0.67, 0.75, 1.5), 'l':(1.0, 1.0, 1.0), 'x':(1, 1.25, 1.0) }.get(variant, None)
-
-def label_predictions(all_predictions):
- class_index_count = defaultdict(int)
- for pred in all_predictions:
- class_id = int(pred[-1])
- if pred[-2] != 0: class_index_count[class_id] += 1
-
- return dict(class_index_count)
-
-#this is taken from https://github.com/tinygrad/tinygrad/pull/784/files by dc-dc-dc (Now 2 models use upsampling)
-class Upsample:
- def __init__(self, scale_factor:int, mode: str = "nearest") -> None:
- assert mode == "nearest" # only mode supported for now
- self.mode = mode
- self.scale_factor = scale_factor
-
- def __call__(self, x: Tensor) -> Tensor:
- assert len(x.shape) > 2 and len(x.shape) <= 5
- (b, c), _lens = x.shape[:2], len(x.shape[2:])
- tmp = x.reshape([b, c, -1] + [1] * _lens) * Tensor.ones(*[1, 1, 1] + [self.scale_factor] * _lens)
- return tmp.reshape(list(x.shape) + [self.scale_factor] * _lens).permute([0, 1] + list(chain.from_iterable([[y+2, y+2+_lens] for y in range(_lens)]))).reshape([b, c] + [x * self.scale_factor for x in x.shape[2:]])
-
-class Conv_Block:
- def __init__(self, c1, c2, kernel_size=1, stride=1, groups=1, dilation=1, padding=None):
- self.conv = Conv2d(c1,c2, kernel_size, stride, padding=autopad(kernel_size, padding, dilation), bias=False, groups=groups, dilation=dilation)
- self.bn = BatchNorm2d(c2, eps=0.001)
-
- def __call__(self, x):
- return self.bn(self.conv(x)).silu()
-
-class Bottleneck:
- def __init__(self, c1, c2 , shortcut: bool, g=1, kernels: list = (3,3), channel_factor=0.5):
- c_ = int(c2 * channel_factor)
- self.cv1 = Conv_Block(c1, c_, kernel_size=kernels[0], stride=1, padding=None)
- self.cv2 = Conv_Block(c_, c2, kernel_size=kernels[1], stride=1, padding=None, groups=g)
- self.residual = c1 == c2 and shortcut
-
- def __call__(self, x):
- return x + self.cv2(self.cv1(x)) if self.residual else self.cv2(self.cv1(x))
-
-class C2f:
- def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
- self.c = int(c2 * e)
- self.cv1 = Conv_Block(c1, 2 * self.c, 1,)
- self.cv2 = Conv_Block((2 + n) * self.c, c2, 1)
- self.bottleneck = [Bottleneck(self.c, self.c, shortcut, g, kernels=[(3, 3), (3, 3)], channel_factor=1.0) for _ in range(n)]
-
- def __call__(self, x):
- y= list(self.cv1(x).chunk(2, 1))
- y.extend(m(y[-1]) for m in self.bottleneck)
- z = y[0]
- for i in y[1:]: z = z.cat(i, dim=1)
- return self.cv2(z)
-
-class SPPF:
- def __init__(self, c1, c2, k=5):
- c_ = c1 // 2 # hidden channels
- self.cv1 = Conv_Block(c1, c_, 1, 1, padding=None)
- self.cv2 = Conv_Block(c_ * 4, c2, 1, 1, padding=None)
-
- # TODO: this pads with 0s, whereas torch function pads with -infinity. This results in a < 2% difference in prediction which does not make a difference visually.
- self.maxpool = lambda x : x.pad((k // 2, k // 2, k // 2, k // 2)).max_pool2d(kernel_size=k, stride=1)
-
- def __call__(self, x):
- x = self.cv1(x)
- x2 = self.maxpool(x)
- x3 = self.maxpool(x2)
- x4 = self.maxpool(x3)
- return self.cv2(x.cat(x2, x3, x4, dim=1))
-
-class DFL:
- def __init__(self, c1=16):
- self.conv = Conv2d(c1, 1, 1, bias=False)
- x = Tensor.arange(c1)
- self.conv.weight.replace(x.reshape(1, c1, 1, 1))
- self.c1 = c1
-
- def __call__(self, x):
- b, c, a = x.shape # batch, channels, anchors
- return self.conv(x.reshape(b, 4, self.c1, a).transpose(2, 1).softmax(1)).reshape(b, 4, a)
-
-#backbone
-class Darknet:
- def __init__(self, w, r, d):
- self.b1 = [Conv_Block(c1=3, c2= int(64*w), kernel_size=3, stride=2, padding=1), Conv_Block(int(64*w), int(128*w), kernel_size=3, stride=2, padding=1)]
- self.b2 = [C2f(c1=int(128*w), c2=int(128*w), n=round(3*d), shortcut=True), Conv_Block(int(128*w), int(256*w), 3, 2, 1), C2f(int(256*w), int(256*w), round(6*d), True)]
- self.b3 = [Conv_Block(int(256*w), int(512*w), kernel_size=3, stride=2, padding=1), C2f(int(512*w), int(512*w), round(6*d), True)]
- self.b4 = [Conv_Block(int(512*w), int(512*w*r), kernel_size=3, stride=2, padding=1), C2f(int(512*w*r), int(512*w*r), round(3*d), True)]
- self.b5 = [SPPF(int(512*w*r), int(512*w*r), 5)]
-
- def return_modules(self):
- return [*self.b1, *self.b2, *self.b3, *self.b4, *self.b5]
-
- def __call__(self, x):
- x1 = x.sequential(self.b1)
- x2 = x1.sequential(self.b2)
- x3 = x2.sequential(self.b3)
- x4 = x3.sequential(self.b4)
- x5 = x4.sequential(self.b5)
- return (x2, x3, x5)
-
-#yolo fpn (neck)
-class Yolov8NECK:
- def __init__(self, w, r, d): #width_multiple, ratio_multiple, depth_multiple
- self.up = Upsample(2, mode='nearest')
- self.n1 = C2f(c1=int(512*w*(1+r)), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n2 = C2f(c1=int(768*w), c2=int(256*w), n=round(3*d), shortcut=False)
- self.n3 = Conv_Block(c1=int(256*w), c2=int(256*w), kernel_size=3, stride=2, padding=1)
- self.n4 = C2f(c1=int(768*w), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n5 = Conv_Block(c1=int(512* w), c2=int(512 * w), kernel_size=3, stride=2, padding=1)
- self.n6 = C2f(c1=int(512*w*(1+r)), c2=int(512*w*r), n=round(3*d), shortcut=False)
-
- def return_modules(self):
- return [self.n1, self.n2, self.n3, self.n4, self.n5, self.n6]
-
- def __call__(self, p3, p4, p5):
- x = self.n1(self.up(p5).cat(p4, dim=1))
- head_1 = self.n2(self.up(x).cat(p3, dim=1))
- head_2 = self.n4(self.n3(head_1).cat(x, dim=1))
- head_3 = self.n6(self.n5(head_2).cat(p5, dim=1))
- return [head_1, head_2, head_3]
-
-#task specific head.
-class DetectionHead:
- def __init__(self, nc=80, filters=()):
- self.ch = 16
- self.nc = nc # number of classes
- self.nl = len(filters)
- self.no = nc + self.ch * 4 #
- self.stride = [8, 16, 32]
- c1 = max(filters[0], self.nc)
- c2 = max((filters[0] // 4, self.ch * 4))
- self.dfl = DFL(self.ch)
- self.cv3 = [[Conv_Block(x, c1, 3), Conv_Block(c1, c1, 3), Conv2d(c1, self.nc, 1)] for x in filters]
- self.cv2 = [[Conv_Block(x, c2, 3), Conv_Block(c2, c2, 3), Conv2d(c2, 4 * self.ch, 1)] for x in filters]
-
- def __call__(self, x):
- for i in range(self.nl):
- x[i] = (x[i].sequential(self.cv2[i]).cat(x[i].sequential(self.cv3[i]), dim=1))
- self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
- y = [(i.reshape(x[0].shape[0], self.no, -1)) for i in x]
- x_cat = y[0].cat(y[1], y[2], dim=2)
- box, cls = x_cat[:, :self.ch * 4], x_cat[:, self.ch * 4:]
- dbox = dist2bbox(self.dfl(box), self.anchors.unsqueeze(0), xywh=True, dim=1) * self.strides
- z = dbox.cat(cls.sigmoid(), dim=1)
- return z
-
-class YOLOv8:
- def __init__(self, w, r, d, num_classes): #width_multiple, ratio_multiple, depth_multiple
- self.net = Darknet(w, r, d)
- self.fpn = Yolov8NECK(w, r, d)
- self.head = DetectionHead(num_classes, filters=(int(256*w), int(512*w), int(512*w*r)))
-
- def __call__(self, x):
- x = self.net(x)
- x = self.fpn(*x)
- x = self.head(x)
- # TODO: postprocess needs to be in the model to be compiled to webgpu
- return postprocess(x)
-
- def return_all_trainable_modules(self):
- backbone_modules = [*range(10)]
- yolov8neck_modules = [12, 15, 16, 18, 19, 21]
- yolov8_head_weights = [(22, self.head)]
- return [*zip(backbone_modules, self.net.return_modules()), *zip(yolov8neck_modules, self.fpn.return_modules()), *yolov8_head_weights]
-
-def convert_f16_safetensor_to_f32(input_file: Path, output_file: Path):
- with open(input_file, 'rb') as f:
- metadata_length = int.from_bytes(f.read(8), 'little')
- metadata = json.loads(f.read(metadata_length).decode())
- float32_values = np.fromfile(f, dtype=np.float16).astype(np.float32)
-
- for v in metadata.values():
- if v["dtype"] == "F16": v.update({"dtype": "F32", "data_offsets": [offset * 2 for offset in v["data_offsets"]]})
-
- with open(output_file, 'wb') as f:
- new_metadata_bytes = json.dumps(metadata).encode()
- f.write(len(new_metadata_bytes).to_bytes(8, 'little'))
- f.write(new_metadata_bytes)
- float32_values.tofile(f)
-
-def compute_iou_matrix(boxes):
- x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
- areas = (x2 - x1) * (y2 - y1)
- x1 = Tensor.maximum(x1[:, None], x1[None, :])
- y1 = Tensor.maximum(y1[:, None], y1[None, :])
- x2 = Tensor.minimum(x2[:, None], x2[None, :])
- y2 = Tensor.minimum(y2[:, None], y2[None, :])
- w = Tensor.maximum(Tensor(0), x2 - x1)
- h = Tensor.maximum(Tensor(0), y2 - y1)
- intersection = w * h
- union = areas[:, None] + areas[None, :] - intersection
- return intersection / union
-
-def postprocess(output, max_det=300, conf_threshold=0.25, iou_threshold=0.45):
- xc, yc, w, h, class_scores = output[0][0], output[0][1], output[0][2], output[0][3], output[0][4:]
- class_ids = Tensor.argmax(class_scores, axis=0)
- probs = Tensor.max(class_scores, axis=0)
- probs = Tensor.where(probs >= conf_threshold, probs, 0)
- x1 = xc - w / 2
- y1 = yc - h / 2
- x2 = xc + w / 2
- y2 = yc + h / 2
- boxes = Tensor.stack(x1, y1, x2, y2, probs, class_ids, dim=1)
- order = Tensor.topk(probs, max_det)[1]
- boxes = boxes[order]
- iou = compute_iou_matrix(boxes[:, :4])
- iou = Tensor.triu(iou, diagonal=1)
- same_class_mask = boxes[:, -1][:, None] == boxes[:, -1][None, :]
- high_iou_mask = (iou > iou_threshold) & same_class_mask
- no_overlap_mask = high_iou_mask.sum(axis=0) == 0
- boxes = boxes * no_overlap_mask.unsqueeze(-1)
- return boxes
-
-def get_weights_location(yolo_variant: str) -> Path:
- weights_location = Path(__file__).parents[1] / "weights" / f'yolov8{yolo_variant}.safetensors'
- fetch(f'https://gitlab.com/r3sist/yolov8_weights/-/raw/master/yolov8{yolo_variant}.safetensors', weights_location)
- #f16
- return weights_location.with_name(f"{weights_location.stem}.safetensors")
- f32_weights = weights_location.with_name(f"{weights_location.stem}_f32.safetensors")
- if not f32_weights.exists(): convert_f16_safetensor_to_f32(weights_location, f32_weights)
- return f32_weights
-
-@TinyJit
-def do_inf(im):
- im = im.unsqueeze(0)
- im = im[..., ::-1].permute(0, 3, 1, 2)
- im = im / 255.0
- predictions = yolo_infer(im)
- return predictions
-
-# RTSP URL
-# Video capture thread
-import subprocess
-import threading
-import time
-import numpy as np
-import cv2
-from datetime import datetime
-import os
-import threading
-
-CAMERA_BASE_DIR = Path("cameras")
-Path("cameras").mkdir(parents=True, exist_ok=True)
-
-
-class RollingClassCounter:
- def __init__(self, window_seconds=None, max=None, classes=None):
- self.window = window_seconds
- self.data = defaultdict(deque)
- self.max = max
- self.classes = classes
- self.last_det = 0
-
- def add(self, class_id):
- if self.classes is not None and class_id not in self.classes: return
- now = time.time()
- self.data[class_id].append(now)
- self.cleanup(class_id, now)
-
- def cleanup(self, class_id, now):
- q = self.data[class_id]
- while self.window and q and now - q[0] > self.window:
- q.popleft()
-
- def get_counts(self):
- max_reached = False
- now = time.time()
- counts = {}
- for class_id, q in self.data.items():
- while self.window and q and now - q[0] > self.window:
- q.popleft()
- if q:
- counts[class_id] = len(q)
- if self.max and len(q) >= self.max: max_reached = True
- return counts, max_reached
-
-class VideoCapture:
- def __init__(self, src,camera_name="clearcampy"):
- # objects in scene count
- self.counter = RollingClassCounter()
- self.camera_name = camera_name
- self.object_set = set()
-
- self.src = src
- self.width = 1280 # Reduced resolution for better performance
- self.height = 720
- self.proc = None
- self.running = True
-
- self.raw_frame = None
- self.annotated_frame = None
- self.last_preds = []
- self.dir = None
-
- alerts_dir = CAMERA_BASE_DIR / cam_name / "alerts.pkl"
- alerts_dir.parent.mkdir(parents=True, exist_ok=True)
- try:
- with open(alerts_dir, "rb") as f:
- self.alert_counters = pickle.load(f)
- for _,a in self.alert_counters.items():
- for c in a.classes: classes.add(str(c))
- except Exception:
- with open(alerts_dir, 'wb') as f:
- self.alert_counters = dict()
- self.alert_counters[str(uuid.uuid4())] = RollingClassCounter(window_seconds=60, max=1, classes={0,1,2,3,5,7})
- pickle.dump(self.alert_counters, f)
-
- self.lock = threading.Lock()
-
- self._open_ffmpeg()
-
- # Start threads
- threading.Thread(target=self.capture_loop, daemon=True).start()
- threading.Thread(target=self.inference_loop, daemon=True).start()
-
- def _open_ffmpeg(self):
- if self.proc:
- self.proc.kill()
-
- command = [
- "ffmpeg",
- "-i", self.src,
- "-loglevel", "quiet",
- "-reconnect", "1",
- "-reconnect_streamed", "1",
- "-reconnect_delay_max", "2",
- "-an", # No audio
- "-f", "rawvideo",
- "-pix_fmt", "bgr24",
- "-vf", f"scale={self.width}:{self.height}",
- "-timeout", "5000000",
- "-rw_timeout", "15000000",
- "-"
- ]
- self.proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-
- def capture_loop(self):
- frame_size = self.width * self.height * 3
- fail_count = 0
- last_det = -1
- send_det = False
- last_live_check = time.time()
- last_live_seg = time.time()
- last_preview_time = None
- last_counter_update = time.time()
- count = 0
- while self.running:
- if not (CAMERA_BASE_DIR / self.camera_name).is_dir(): os._exit(1) # deleted cam
- try:
- raw_bytes = self.proc.stdout.read(frame_size)
- if len(raw_bytes) != frame_size:
- fail_count += 1
- print(f"FFmpeg frame read failed (count={fail_count}), restarting stream...")
- if fail_count > 5:
- self._open_ffmpeg()
- fail_count = 0
- time.sleep(0.5)
- continue
- fail_count = 0
- frame = np.frombuffer(raw_bytes, np.uint8).reshape((self.height, self.width, 3))
- filtered_preds = [p for p in self.last_preds if p[4] >= yolo_thresh and (classes is None or str(int(p[5])) in classes)]
-
- if count > 10:
- if last_preview_time is None or time.time() - last_preview_time >= 3600: # preview every hour
- last_preview_time = time.time()
- filename = CAMERA_BASE_DIR / f"{self.camera_name}/preview.jpg"
- cv2.imwrite(filename, self.annotated_frame)
- for _,alert in self.alert_counters.items():
- if alert.get_counts()[1]:
- if time.time() - alert.last_det >= alert.window:
- send_det = True
- timestamp = datetime.now().strftime("%Y-%m-%d")
- filepath = CAMERA_BASE_DIR / f"{self.camera_name}/event_images/{timestamp}"
- filepath.mkdir(parents=True, exist_ok=True)
- filename = filepath / f"{int(time.time() - self.streamer.start_time - 10)}.jpg"
- cv2.imwrite(str(filename), self.annotated_frame)
- if userID is not None: threading.Thread(target=send_notif, args=(userID,), daemon=True).start()
- last_det = time.time()
- alert.last_det = time.time()
- if (send_det and userID is not None) and time.time() - last_det >= 15: #send 15ish second clip after
- os.makedirs(CAMERA_BASE_DIR / self.camera_name / "event_clips", exist_ok=True)
- mp4_filename = CAMERA_BASE_DIR / f"{self.camera_name}/event_clips/{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.mp4"
- self.streamer.export_last_segments(Path(mp4_filename))
- encrypt_file(Path(mp4_filename), Path(f"""{mp4_filename}.aes"""), key)
- threading.Thread(target=upload_file, args=(Path(f"""{mp4_filename}.aes"""), userID), daemon=True).start()
- send_det = False
- if userID and (time.time() - last_live_check) >= 5:
- last_live_check = time.time()
- threading.Thread(target=check_upload_link, args=(self.camera_name,), daemon=True).start()
- if (time.time() - last_counter_update) >= 5: #update counter every 5 secs
- counters_dir = CAMERA_BASE_DIR / self.camera_name / "counters.pkl"
- if os.path.exists(counters_dir):
- with open(counters_dir, 'rb') as f:
- counter = pickle.load(f)
- if counter is None: self.counter = RollingClassCounter()
- counter = self.counter
- with open(counters_dir, 'wb') as f:
- pickle.dump(counter, f)
- # delete alerts
- deleted_alerts_dir = CAMERA_BASE_DIR / self.camera_name / "deleted_alerts.pkl"
- if deleted_alerts_dir.exists():
- with open(deleted_alerts_dir, 'rb') as f:
- deleted_alerts = pickle.load(f)
- for a in deleted_alerts:
- if a in self.alert_counters: del self.alert_counters[a]
- deleted_alerts_dir.unlink()
-
- # add new alerts
- added_alerts_dir = CAMERA_BASE_DIR / self.camera_name / "added_alerts.pkl"
- if added_alerts_dir.exists():
- with open(added_alerts_dir, 'rb') as f:
- added_alerts = pickle.load(f)
- for id,a in added_alerts:
- self.alert_counters[id] = a
- for c in a.classes: classes.add(str(c))
- added_alerts_dir.unlink()
-
- if userID and live_link[self.camera_name] and (time.time() - last_live_seg) >= 4:
- last_live_seg = time.time()
- mp4_filename = f"segment.mp4"
- self.streamer.export_last_segments(Path(mp4_filename),last=True)
- encrypt_file(Path(mp4_filename), Path(f"""{mp4_filename}.aes"""), key)
- Path(mp4_filename).unlink()
- threading.Thread(target=upload_to_r2, args=(Path(f"""{mp4_filename}.aes"""), live_link[self.camera_name]), daemon=True).start()
- else:
- count+=1
- with self.lock:
- self.raw_frame = frame.copy()
- self.annotated_frame = self.draw_predictions(frame.copy(), filtered_preds)
- time.sleep(1 / 30)
- except Exception as e:
- print("Error in capture_loop:", e)
- self._open_ffmpeg()
- time.sleep(1)
-
-
- def inference_loop(self):
- prev_time = time.time()
- while self.running:
- with self.lock:
- frame = self.raw_frame.copy() if self.raw_frame is not None else None
- if frame is not None:
- pre = preprocess(frame)
- preds = do_inf(pre).numpy()
- if track:
- online_targets = tracker.update(preds, [1280,1280], [1280,1280])
- preds = []
- for x in online_targets:
- preds.append(np.array([x.tlwh[0],x.tlwh[1],(x.tlwh[0]+x.tlwh[2]),(x.tlwh[1]+x.tlwh[3]),x.score,x.class_id]))
- if int(x.track_id) not in self.object_set and (classes is None or str(int(x.class_id)) in classes):
- self.object_set.add(int(x.track_id))
- self.counter.add(int(x.class_id))
- for _, alert in self.alert_counters.items():
- if not alert.get_counts()[1]:
- alert.add(int(x.class_id)) #only add if empty, don't spam notifs
- preds = np.array(preds)
- preds = scale_boxes(pre.shape[:2], preds, frame.shape)
- with self.lock:
- self.last_preds = preds
- curr_time = time.time()
- fps = 1 / (curr_time - prev_time)
- prev_time = curr_time
- print(f"\rFPS: {fps:.2f}", end="", flush=True)
-
- def is_bright_color(self,color):
- r, g, b = color
- brightness = (r * 299 + g * 587 + b * 114) / 1000
- return brightness > 127
-
- def draw_predictions(self, frame, preds):
- for x1, y1, x2, y2, conf, cls in preds:
- x1, y1, x2, y2 = map(int, [x1, y1, x2, y2])
- label = f"{class_labels[int(cls)]}:{conf:.2f}"
- color = color_dict[class_labels[int(cls)]]
- cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
- (text_width, text_height), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
- font_color = (0, 0, 0) if self.is_bright_color(color) else (255, 255, 255)
- cv2.rectangle(frame, (x1, y1 - text_height - 10), (x1 + text_width + 2, y1), color, -1)
- cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, font_color, 1, cv2.LINE_AA)
- return frame
-
- def get_frame(self):
- with self.lock:
- if self.annotated_frame is not None:
- return self.annotated_frame.copy()
- return None
-
- def release(self):
- self.running = False
- if self.proc:
- self.proc.kill()
-
-class HLSStreamer:
- def __init__(self, video_capture, output_dir="streams", segment_time=4, camera_name="clearcampy"):
- self.camera_name = camera_name
- self.cam = video_capture
- self.output_dir = CAMERA_BASE_DIR / self.camera_name / output_dir
- self.segment_time = segment_time
- self.running = False
- self.ffmpeg_proc = None
- self.start_time = time.time()
-
- self.output_dir.mkdir(parents=True, exist_ok=True)
-
- def _get_new_stream_dir(self):
- timestamp = datetime.now().strftime("%Y-%m-%d")
- stream_dir = self.output_dir / timestamp
- self.cam.dir = stream_dir
- if stream_dir.exists():
- shutil.rmtree(stream_dir)
- stream_dir.mkdir(exist_ok=True)
- return stream_dir
-
- def start(self):
- self.running = True
- self.current_stream_dir = self._get_new_stream_dir()
- self.recent_segments = deque(maxlen=4)
- self.start_time = time.time()
- # Start FFmpeg process for HLS streaming to local files
- ffmpeg_cmd = [
- "ffmpeg",
- "-f", "rawvideo",
- "-pix_fmt", "bgr24",
- "-s", f"{self.cam.width}x{self.cam.height}",
- "-use_wallclock_as_timestamps", "1",
- "-fflags", "+genpts",
- "-i", "-",
- "-c:v", "libx264",
- "-pix_fmt", "yuv420p",
- "-crf", "21",
- "-preset", "veryfast",
- "-g", str(30 * self.segment_time),
- "-vf", "drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:text='%{localtime}':x=w-tw-10:y=10:fontsize=32:fontcolor=white:box=1:boxcolor=black",
- "-f", "hls",
- "-hls_time", str(self.segment_time),
- "-hls_list_size", "0",
- "-hls_flags", "delete_segments",
- "-hls_allow_cache", "0",
- str(self.current_stream_dir / "stream.m3u8")
- ]
-
- self.ffmpeg_proc = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE)
- threading.Thread(target=self._feed_frames, daemon=True).start()
- threading.Thread(target=self._track_segments, daemon=True).start()
-
-
- def export_last_segments(self,output_path: Path,last=False):
- if not self.recent_segments:
- print("No segments available to save.")
- return
-
- concat_list_path = self.current_stream_dir / "concat_list.txt"
- segments_to_use = [self.recent_segments[-1]] if last else self.recent_segments
- with open(concat_list_path, "w") as f:
- f.writelines(f"file '{segment.resolve()}'\n" for segment in segments_to_use)
- output_path.parent.mkdir(parents=True, exist_ok=True)
- if last:
- # Re-encode with scaling and compression
- command = [
- "ffmpeg",
- "-y",
- "-f", "concat",
- "-safe", "0",
- "-i", str(concat_list_path),
- "-vf", "scale=-2:240,fps=24",
- "-c:v", "libx264",
- "-preset", "veryslow",
- "-crf", "32",
- "-an",
- str(output_path)
- ]
- else:
- # Just copy original
- command = [
- "ffmpeg",
- "-y",
- "-f", "concat",
- "-safe", "0",
- "-i", str(concat_list_path),
- "-c", "copy",
- str(output_path)
- ]
- try:
- subprocess.run(command, check=True)
- print(f"Saved detection clip to: {output_path}")
- except subprocess.CalledProcessError as e:
- print(f"Failed to save video: {e}")
-
- def _track_segments(self):
- while self.running:
- segment_files = sorted(self.current_stream_dir.glob("*.ts"), key=os.path.getmtime)
- self.recent_segments.clear()
- self.recent_segments.extend(segment_files[-4:]) # last 3 for now
- time.sleep(self.segment_time / 2)
-
- def _feed_frames(self):
- while self.running:
- frame = self.cam.get_frame()
- if frame is not None:
- try:
- self.ffmpeg_proc.stdin.write(frame.tobytes())
- except BrokenPipeError:
- print("FFmpeg process died, restarting...")
- self.start()
- return
- time.sleep(1/30) # Match the frame rate
-
- def stop(self):
- self.running = False
- if self.ffmpeg_proc:
- self.ffmpeg_proc.terminate()
- try:
- self.ffmpeg_proc.wait(timeout=5)
- except subprocess.TimeoutExpired:
- self.ffmpeg_proc.kill()
-
-
-def append_to_pickle_list(pkl_path, item):
- pkl_path = Path(pkl_path)
- if pkl_path.exists():
- try:
- with open(pkl_path, 'rb') as f:
- data = pickle.load(f)
- except Exception as e:
- data = []
- else:
- data = []
- data.append(item)
- with open(pkl_path, 'wb') as f:
- pickle.dump(data, f)
-
-class HLSRequestHandler(BaseHTTPRequestHandler):
- def __init__(self, *args, **kwargs):
- self.base_dir = CAMERA_BASE_DIR
- super().__init__(*args, **kwargs)
- self.start_cleanup_thread()
-
- def start_cleanup_thread(self):
- def cleanup_task():
- while True:
- self.check_and_cleanup_storage()
- time.sleep(600)
-
- thread = threading.Thread(target=cleanup_task, daemon=True)
- thread.start()
-
- def check_and_cleanup_storage(self):
- try:
- total_size = sum(f.stat().st_size for f in self.base_dir.glob('**/*') if f.is_file())
- size_gb = total_size / (1024 ** 3)
- if size_gb > 30: # todo, hardcoded to 30GB for now
- self.cleanup_oldest_files()
- except Exception as e:
- print(f"Error during storage cleanup: {e}")
-
- def cleanup_oldest_files(self):
- try:
- camera_dirs = []
- for cam_dir in self.base_dir.iterdir():
- if cam_dir.is_dir():
- dir_size = sum(f.stat().st_size for f in cam_dir.glob('**/*') if f.is_file())
- camera_dirs.append((cam_dir, dir_size))
-
- if not camera_dirs:
- return
-
- largest_cam = max(camera_dirs, key=lambda x: x[1])[0]
- streams_dir = largest_cam / "streams"
-
- if not streams_dir.exists():
- # If no streams folder exists, delete the entire camera folder
- shutil.rmtree(largest_cam)
- print(f"Deleted camera folder with no streams: {largest_cam}")
- return
-
- recordings = []
- for rec_dir in streams_dir.iterdir():
- if rec_dir.is_dir():
- recordings.append((rec_dir, rec_dir.stat().st_ctime))
-
- if not recordings:
- # If streams folder exists but is empty, delete the entire camera folder
- shutil.rmtree(largest_cam)
- print(f"Deleted camera folder with empty streams: {largest_cam}")
- return
-
- recordings.sort(key=lambda x: x[1])
- oldest_recording = recordings[0][0]
- shutil.rmtree(oldest_recording)
- print(f"Deleted oldest recording: {oldest_recording}")
-
- except Exception as e:
- print(f"Error during cleanup of oldest files: {e}")
-
- def get_camera_path(self, camera_name=None):
- """Get the path for a specific camera or all cameras"""
- if camera_name:
- return self.base_dir / camera_name / "streams"
- return self.base_dir
-
- def do_GET(self):
- parsed_path = urlparse(unquote(self.path))
- query = parse_qs(parsed_path.query)
-
- if parsed_path.path == "/list_cameras":
- available_cams = [d.name for d in self.base_dir.iterdir() if d.is_dir()]
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(json.dumps(available_cams).encode("utf-8"))
- return
-
- if parsed_path.path == "/add_alert":
- cam_name = query.get("cam", [None])[0]
- window = query.get("window", [None])[0]
- max_count = query.get("max", [None])[0]
- class_ids = query.get("class_ids", [None])[0]
-
- if not cam_name or not window or not max_count or not class_ids:
- self.send_error(400, "Missing parameters")
- return
-
- try:
- window = int(window)
- max_count = int(max_count)
- classes = [int(c.strip()) for c in class_ids.split(",")] # Parse as integers
- alerts_file = CAMERA_BASE_DIR / cam_name / "alerts.pkl"
- added_alerts_file = CAMERA_BASE_DIR / cam_name / "added_alerts.pkl"
- id = str(uuid.uuid4())
- with open(alerts_file, "rb") as f:
- raw_alerts = pickle.load(f)
- raw_alerts[id] = RollingClassCounter(window_seconds=window,max=max_count,classes=classes)
- with open(alerts_file, 'wb') as f: pickle.dump(raw_alerts, f)
- append_to_pickle_list(pkl_path=added_alerts_file,item=[id,RollingClassCounter(window_seconds=window,max=max_count,classes=classes)])
-
- except ValueError as e:
- self.send_error(400, f"Invalid parameters: {e}")
- return
-
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(b'{"status":"ok"}')
- return
-
- if parsed_path.path == '/add_camera':
- camera_name = query.get("cam_name", [None])[0]
- rtsp = query.get("rtsp", [None])[0]
-
- if not camera_name or not rtsp:
- self.send_error(400, "Missing camera_name or rtsp")
- return
-
- start_cam(rtsp=rtsp,cam_name=camera_name)
- cams[camera_name] = rtsp
- with open("cams.pkl", 'wb') as f:
- pickle.dump(cams, f)
-
- # Redirect back to home
- self.send_response(302)
- self.send_header('Location', '/')
- self.end_headers()
- return
-
- if parsed_path.path == "/delete_alert":
- cam_name = query.get("cam", [None])[0]
- alert_id = query.get("id", [None])[0]
-
- if not cam_name or not alert_id:
- self.send_error(400, "Missing cam or id")
- return
-
- alerts_file = CAMERA_BASE_DIR / cam_name / "alerts.pkl"
- print("RORY DELTETING ",alert_id)
- with open(alerts_file, "rb") as f:
- raw_alerts = pickle.load(f)
- print(raw_alerts)
- del raw_alerts[alert_id]
- with open(alerts_file, 'wb') as f: pickle.dump(raw_alerts, f)
- deleted_alerts_file = CAMERA_BASE_DIR / cam_name / "deleted_alerts.pkl"
- append_to_pickle_list(pkl_path=deleted_alerts_file,item=alert_id)
-
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(b'{"status":"ok"}')
- return
-
- if parsed_path.path == "/get_alerts":
- cam_name = query.get("cam", [None])[0]
- if not cam_name:
- self.send_error(400, "Missing cam parameter")
- return
-
- alerts_file = CAMERA_BASE_DIR / cam_name / "alerts.pkl"
- alert_info = []
- if alerts_file.exists():
- try:
- with open(alerts_file, "rb") as f:
- raw_alerts = pickle.load(f)
- for key,alert in raw_alerts.items():
- alert_info.append({
- "window": alert.window,
- "max": alert.max,
- "classes": list(alert.classes),
- "id": str(key)
- })
- except Exception as e:
- self.send_error(500, f"Failed to load alerts: {e}")
- return
-
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(json.dumps(alert_info).encode("utf-8"))
- return
-
- if parsed_path.path == '/delete_camera':
- camera_name = query.get("cam_name", [None])[0]
- if not camera_name:
- self.send_error(400, "Missing cam_name parameter")
- return
-
- cam_path = CAMERA_BASE_DIR / camera_name
- if cam_path.exists() and cam_path.is_dir():
- try:
- shutil.rmtree(cam_path)
- cams.pop(camera_name, None)
- with open("cams.pkl", 'wb') as f:
- pickle.dump(cams, f)
- except Exception as e:
- self.send_error(500, f"Error deleting camera: {e}")
- return
- else:
- self.send_error(404, "Camera not found")
- return
-
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(b'{"status":"deleted"}')
- return
-
- if parsed_path.path == "/get_counts":
- cam_name = query.get("cam", [None])[0]
- if not cam_name:
- self.send_error(400, "Missing cam parameter")
- return
- counters_dir = CAMERA_BASE_DIR / cam_name / "counters.pkl"
- try:
- with open(counters_dir, "rb") as f:
- counter = pickle.load(f)
- except Exception:
- with open(counters_dir, 'wb') as f:
- counter = RollingClassCounter()
- pickle.dump(counter, f)
-
- if not counter:
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(b"{}")
- return
-
- raw_counts = counter.get_counts()[0]
- labeled_counts = {
- class_labels[int(k)]: v
- for k, v in raw_counts.items()
- if int(k) < len(class_labels)
- }
-
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(json.dumps(labeled_counts).encode("utf-8"))
- return
-
- if parsed_path.path == "/shutdown":
- threading.Thread(target=self.server.shutdown).start()
- for proc in active_subprocesses:
- try:
- proc.terminate()
- proc.wait(timeout=5)
- except:
- try:
- proc.kill()
- except:
- pass
- sys.exit(0)
-
- if parsed_path.path == "/reset_counts":
- cam_name = query.get("cam", [None])[0]
- if not cam_name:
- self.send_error(400, "Missing cam parameter")
- return
- counters_dir = CAMERA_BASE_DIR / cam_name / "counters.pkl"
-
- with open(counters_dir, "rb") as f:
- counter = pickle.load(f)
- counter = None
- with open(counters_dir, 'wb') as f:
- pickle.dump(counter, f)
-
- self.send_response(200)
- self.send_header("Content-Type", "application/json")
- self.end_headers()
- self.wfile.write(b"{}")
- return
-
-
- if parsed_path.path == '/' and "cam" not in query:
- available_cams = [d.name for d in self.base_dir.iterdir() if d.is_dir()]
- html = f"""
- <!DOCTYPE html>
- <html>
- <head>
- <style>
- .camera-grid {{
- display: flex;
- flex-wrap: wrap;
- gap: 20px;
- }}
- .camera-card {{
- width: 220px;
- border: 1px solid #ccc;
- border-radius: 8px;
- overflow: hidden;
- box-shadow: 0 2px 4px rgba(0,0,0,0.1);
- text-align: center;
- font-family: sans-serif;
- }}
- .camera-card img {{
- width: 100%;
- display: block;
- }}
- .camera-card div {{
- padding: 8px;
- background: #f9f9f9;
- }}
- .form-section {{
- margin-top: 20px;
- font-family: sans-serif;
- }}
- .form-section input {{
- padding: 6px;
- margin: 4px;
- border: 1px solid #ccc;
- border-radius: 4px;
- width: 200px;
- }}
- .form-section button {{
- padding: 6px 12px;
- background: #007bff;
- color: white;
- border: none;
- border-radius: 4px;
- cursor: pointer;
- }}
- .form-section button:hover {{
- background: #0056b3;
- }}
- .shutdown-wrapper {{
- margin-top: 20px;
- }}
- </style>
- </head>
- <body>
- <div id="cameraList" class="camera-grid">
- </div>
-
- <div class="form-section">
- <form id="addCameraForm">
- <input type="text" name="cam_name" placeholder="Camera Name" required>
- <input type="text" name="rtsp" placeholder="RTSP Link" required>
- <button type="submit">Add Camera</button>
- </form>
- <div class="shutdown-wrapper">
- <button class="shutdown-button" onclick="shutdownServer()">Shutdown Server</button>
- </div>
- </div>
-
- <script>
- async function fetchCameras() {{
- const res = await fetch('/list_cameras');
- const cams = await res.json();
- const container = document.getElementById("cameraList");
- container.innerHTML = cams.map(cam => `
- <div class="camera-card">
- <a href="/?cam=${{cam}}">
- <img src="/${{cam}}/preview.jpg" alt="${{cam}} preview">
- <div>${{cam}}</div>
- </a>
- <button onclick="deleteCamera('${{cam}}')">Delete</button>
- </div>
- `).join('');
- }}
-
-
- async function deleteCamera(cam) {{
- if (!confirm(`Are you sure you want to delete ${{cam}}?`)) return;
- const res = await fetch(`/delete_camera?cam_name=${{cam}}`);
- if (res.ok) {{
- fetchCameras();
- }} else {{
- alert("Failed to delete camera.");
- }}
- }}
-
- async function shutdownServer() {{
- if (!confirm("Are you sure you want to shut down the server?")) return;
- const res = await fetch('/shutdown');
- if (res.ok) {{
- alert("Server is shutting down...");
- }} else {{
- alert("Shutdown failed.");
- }}
- }}
-
- // Refresh list every 5 seconds
- fetchCameras();
- setInterval(fetchCameras, 5000);
-
- // Submit form via fetch, no full-page reload
- document.getElementById("addCameraForm").addEventListener("submit", async (e) => {{
- e.preventDefault();
- const form = e.target;
- const params = new URLSearchParams(new FormData(form)).toString();
- await fetch(`/add_camera?${{params}}`);
- form.reset();
- fetchCameras(); // Immediately refresh
- }});
- </script>
- </body>
- </html>
- """
- self.send_response(200)
- self.send_header('Content-type', 'text/html')
- self.end_headers()
- self.wfile.write(html.encode('utf-8'))
- return
-
- # Get camera name from query parameter or default to first camera
- camera_name = query.get("cam", [None])[0]
- if not camera_name:
- # Try to get camera name from path if not in query
- path_parts = parsed_path.path.strip('/').split('/')
- if path_parts and path_parts[0] in [d.name for d in self.base_dir.iterdir() if d.is_dir()]:
- camera_name = path_parts[0]
-
- # If still no camera name, use the first available camera
- if not camera_name:
- available_cams = [d.name for d in self.base_dir.iterdir() if d.is_dir()]
- if available_cams:
- camera_name = available_cams[0]
- else:
- self.send_error(404, "No cameras found")
- return
-
- hls_dir = self.get_camera_path(camera_name)
- event_image_dir = self.base_dir / camera_name / "event_images"
-
- if parsed_path.path == '/download_clip' or parsed_path.path.endswith('/download_clip'):
- query = parse_qs(parsed_path.query)
- folder = query.get("folder", [None])[0]
- start = query.get("start", [None])[0]
- end = query.get("end", [None])[0]
-
- if not folder or start is None or end is None:
- self.send_error(400, "Missing parameters")
- return
-
- try:
- start = float(start)
- end = float(end)
- except ValueError:
- self.send_error(400, "Invalid start or end time")
- return
-
- stream_path = hls_dir / folder / "stream.m3u8"
- if not stream_path.exists():
- self.send_error(404, "Stream not found")
- return
-
- output_path = Path(f"tmp_clip_{uuid.uuid4().hex}.mp4")
- try:
- command = [
- "ffmpeg",
- "-y",
- "-ss", str(start),
- "-i", str(stream_path),
- "-t", str(end - start),
- "-c", "copy",
- str(output_path)
- ]
- subprocess.run(command, check=True)
-
- self.send_response(200)
- self.send_header("Content-Type", "video/mp4")
- self.send_header("Content-Disposition", f'attachment; filename="clip_{camera_name}_{folder}_{int(start)}_{int(end)}.mp4"')
- self.send_header("Content-Length", str(output_path.stat().st_size))
- self.end_headers()
-
- with open(output_path, "rb") as f:
- shutil.copyfileobj(f, self.wfile)
- except Exception as e:
- self.send_error(500, f"Failed to create clip: {e}")
- finally:
- if output_path.exists():
- output_path.unlink()
- return
-
- if parsed_path.path == '/event_thumbs' or parsed_path.path.endswith('/event_thumbs'):
- selected_dir = parse_qs(parsed_path.query).get("folder", [datetime.now().strftime("%Y-%m-%d")])[0]
- event_image_path = event_image_dir / selected_dir
- event_images = sorted(
- event_image_path.glob("*.jpg"),
- key=lambda p: int(p.stem),
- reverse=True
- ) if event_image_path.exists() else []
-
- image_links = ""
- if event_images:
- for img in event_images:
- ts = int(img.stem)
- image_links += f"""
- <a href="/?cam={camera_name}&folder={selected_dir}&start={ts}">
- <img src="/{img.relative_to(self.base_dir.parent)}" width="160" style="margin: 5px; border: 1px solid #ccc;" />
- </a>
- """
- else:
- image_links = '<p style="text-align:center; color:#666;">No alerts detected yet.</p>'
-
- self.send_response(200)
- self.send_header('Content-type', 'text/html')
- self.end_headers()
- self.wfile.write(image_links.encode('utf-8'))
- return
-
- if parsed_path.path == '/' or parsed_path.path == f'/{camera_name}':
- selected_dir = parse_qs(parsed_path.query).get("folder", [datetime.now().strftime("%Y-%m-%d")])[0]
- start_param = parse_qs(parsed_path.query).get("start", [None])[0]
-
- event_image_path = event_image_dir / selected_dir
- event_images = sorted(event_image_path.glob("*.jpg")) if event_image_path.exists() else []
- image_links = ""
- for img in event_images:
- ts = int(img.stem)
- image_links += f"""
- <a href="/?cam={camera_name}&folder={selected_dir}&start={ts}">
- <img src="/{img.relative_to(self.base_dir.parent)}" width="160" style="margin: 5px; border: 1px solid #ccc;" />
- </a>
- """
-
- try:
- start_time = float(start_param) if start_param is not None else None
- except ValueError:
- start_time = None
-
- available_cams = [d.name for d in self.base_dir.iterdir() if d.is_dir()]
-
- self.send_response(200)
- self.send_header('Content-type', 'text/html')
- self.end_headers()
- html = f"""
- <!DOCTYPE html>
- <html>
- <head>
- <meta name="viewport" content="width=device-width, initial-scale=1.0">
- <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
- <link href="https://fonts.googleapis.com/css2?family=Inter&display=swap" rel="stylesheet">
- <style>
- body {{
- font-family: 'Inter', sans-serif;
- margin: 0;
- padding: 0;
- background-color: #f9f9f9;
- color: #333;
- }}
-
- .checkbox-container {{
- display: grid;
- grid-template-columns: auto auto;
- gap: 8px 16px;
- max-height: 200px;
- overflow-y: auto;
- margin: 0 auto;
- padding: 8px;
- justify-content: center;
- }}
-
- .checkbox-container input[type="checkbox"] {{
- margin: 0;
- width: 16px;
- height: 16px;
- }}
-
- .checkbox-item {{
- display: flex;
- align-items: center;
- gap: 8px;
- margin-left: 10px;
- }}
-
- .checkbox-item input[type="checkbox"] {{
- margin: 0;
- transform: scale(1.2);
- }}
-
- .container {{
- max-width: 900px;
- margin: 0 auto;
- padding: 20px;
- }}
-
- video {{
- width: 100%;
- border-radius: 12px;
- box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
- margin-bottom: 20px;
- }}
-
- .date-picker-container {{
- display: flex;
- justify-content: center;
- align-items: center;
- gap: 10px;
- margin: 20px 0;
- flex-wrap: wrap;
- }}
-
- .date-picker-container input[type="date"],
- .date-picker-container button {{
- height: 40px;
- font-size: 0.95rem;
- padding: 6px 12px;
- border-radius: 6px;
- border: 1px solid #ccc;
- box-sizing: border-box;
- }}
-
- .counts-wrapper {{
- display: flex;
- flex-wrap: wrap;
- justify-content: center;
- align-items: center;
- gap: 20px;
- margin: 20px 0;
- }}
-
- .controls {{
- display: flex;
- flex-wrap: wrap;
- gap: 16px;
- align-items: flex-end;
- justify-content: center;
- margin-bottom: 20px;
- }}
-
- .controls label {{
- font-size: 0.9rem;
- display: flex;
- flex-direction: column;
- flex: 1 1 auto;
- min-width: 120px;
- }}
-
- .time-inputs {{
- display: flex;
- gap: 12px;
- flex-wrap: nowrap;
- justify-content: center;
- flex: 1 1 100%;
- }}
-
- input[type="date"],
- input[type="time"] {{
- padding: 6px 10px;
- border-radius: 8px;
- border: 1px solid #ccc;
- font-size: 1rem;
- }}
-
- button {{
- background-color: #f0f0f0;
- color: #1a73e8;
- padding: 10px 24px;
- border: none;
- border-radius: 6px;
- font-size: 1rem;
- cursor: pointer;
- transition: all 0.3s ease;
- min-width: 100px;
- text-align: center;
- box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
- }}
-
- button:hover {{
- background-color: #e0e0e0;
- box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
- }}
-
- .form-actions button {{
- min-width: 80px;
- }}
-
- #alertsContainer table button {{
- padding: 6px 12px;
- min-width: 90px;
- text-align: center;
- font-size: 0.9rem;
- }}
-
- h3 {{
- font-size: 1.2rem;
- margin: 20px 0 10px;
- }}
-
- #eventImagesContainer {{
- display: flex;
- flex-wrap: wrap;
- justify-content: center;
- gap: 14px;
- }}
-
- #eventImagesContainer img {{
- width: 220px;
- height: auto;
- border-radius: 10px;
- border: 1px solid #ccc;
- transition: transform 0.2s;
- }}
-
- #eventImagesContainer img:hover {{
- transform: scale(1.05);
- }}
-
- /* Modal styles */
- .modal,
- .download-modal {{
- display: none;
- position: fixed;
- z-index: 999;
- left: 0;
- top: 0;
- width: 100%;
- height: 100%;
- background-color: rgba(0, 0, 0, 0.4);
- justify-content: center;
- align-items: center;
- overflow: auto;
- }}
-
- .modal-content {{
- max-height: 80vh;
- overflow-y: auto;
- display: flex;
- flex-direction: column;
- }}
- .form-group.checkbox-group {{
- flex: 1;
- min-height: 0; /* Important for flex children */
- }}
-
- .modal-content,
- .download-modal-content {{
- background-color: #fefefe;
- padding: 20px;
- border-radius: 8px;
- width: 90%;
- max-width: 500px;
- box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
- }}
-
- .modal-header {{
- display: flex;
- justify-content: space-between;
- align-items: center;
- margin-bottom: 15px;
- }}
-
- .modal-header h3 {{
- margin: 0;
- }}
-
- .close {{
- color: #aaa;
- font-size: 28px;
- font-weight: bold;
- cursor: pointer;
- }}
-
- .close:hover {{
- color: black;
- }}
-
- .form-group {{
- margin-bottom: 15px;
- }}
-
- .form-group label {{
- display: block;
- margin-bottom: 5px;
- font-weight: 500;
- }}
-
- .form-group input {{
- width: 100%;
- padding: 8px;
- border: 1px solid #ddd;
- border-radius: 4px;
- box-sizing: border-box;
- }}
-
- .form-actions {{
- display: flex;
- justify-content: flex-end;
- gap: 10px;
- margin-top: 20px;
- }}
-
- .download-controls {{
- display: flex;
- flex-direction: column;
- gap: 15px;
- }}
-
- .download-time-inputs {{
- display: flex;
- gap: 10px;
- }}
-
- @media (max-width: 600px) {{
- button {{
- padding: 8px 16px;
- font-size: 0.9rem;
- min-width: 80px;
- }}
-
- .form-actions button {{
- min-width: 70px;
- }}
-
- input[type="date"] {{
- width: 100%;
- max-width: 200px;
- padding: 6px 8px;
- font-size: 0.9rem;
- }}
-
- input[type="time"] {{
- width: 100px;
- padding: 6px 8px;
- font-size: 0.9rem;
- }}
-
- .modal-content,
- .download-modal-content {{
- width: 95%;
- padding: 15px;
- }}
-
- .form-group input {{
- padding: 6px 8px;
- font-size: 0.9rem;
- }}
-
- #alertsContainer table {{
- font-size: 0.9rem;
- }}
-
- #alertsContainer table button {{
- min-width: 80px;
- padding: 5px 10px;
- font-size: 0.8rem;
- }}
-
- .download-time-inputs {{
- flex-direction: column;
- gap: 8px;
- }}
-
- .controls label {{
- min-width: auto;
- width: 100%;
- }}
-
- .counts-wrapper {{
- flex-direction: column;
- gap: 10px;
- }}
-
- .date-picker-container {{
- flex-wrap: nowrap;
- }}
-
- .date-picker-container input[type="date"],
- .date-picker-container button {{
- height: 36px;
- font-size: 0.85rem;
- padding: 6px 10px;
- }}
- }}
- </style>
- </head>
- <body>
- <div class="container">
- <video id="video" controls></video>
- <div class="date-picker-container">
- <input type="date" id="folderPicker" value="{selected_dir}">
- <button onclick="openDownloadModal()">Download</button>
- </div>
- <h3>Active Alerts</h3>
- <div id="alertsContainer">
- <p>Loading alerts...</p>
- <button onclick="openAlertModal()">Add Alert</button>
- </div>
-
- <!-- The Modal -->
- <div id="alertModal" class="modal">
- <div class="modal-content" style="max-width: 400px;">
- <div class="modal-header">
- <h3>Add New Alert</h3>
- <span class="close" onclick="closeAlertModal()">&times;</span>
- </div>
- <form id="alertForm" onsubmit="addAlert(event)" style="display: flex; flex-direction: column; align-items: center;">
- <div class="form-group" style="width: 90%; text-align: center;">
- <label for="maxCount">Trigger if there are more than</label>
- <input type="number" id="maxCount" name="max" min="1" value="5" required
- style="width: 80px; margin: 0 6px; text-align: center; display: inline-block;">
- <span>objects detected</span>
- </div>
- <div class="form-group checkbox-group" style="width: 90%; text-align: center;">
- <label>of class(es)</label>
- <div id="checkboxContainer" class="checkbox-container">
- <!-- Checkboxes will be inserted here -->
- </div>
- </div>
- <div class="form-group" style="width: 90%; text-align: center;">
- <label for="windowMinutes">within this time window</label>
- <input type="number" id="windowMinutes" name="window" min="1" value="1" required
- style="width: 80px; margin: 0 6px; text-align: center; display: inline-block;">
- <span>minutes</span>
- </div>
- <div class="form-actions" style="display: flex; justify-content: center; gap: 10px; margin-top: 20px; width: 100%;">
- <button type="button" onclick="closeAlertModal()">Cancel</button>
- <button type="submit">Save Alert</button>
- </div>
- </form>
- </div>
- </div>
-
- <!-- Download Modal -->
- <div id="downloadModal" class="download-modal">
- <div class="download-modal-content">
- <div class="modal-header">
- <h3>Download Clip</h3>
- <span class="close" onclick="closeDownloadModal()">&times;</span>
- </div>
- <div class="download-controls" style="display: flex; flex-direction: column; align-items: center; gap: 15px;">
- <div class="download-time-inputs" style="display: flex; justify-content: center; gap: 20px; width: 100%;">
- <div class="form-group" style="text-align: center;">
- <label for="clipStart">Start Time</label>
- <input type="time" id="clipStart" step="1" value="00:00:00" style="text-align: center;">
- </div>
- <div class="form-group" style="text-align: center;">
- <label for="clipEnd">End Time</label>
- <input type="time" id="clipEnd" step="1" value="00:00:10" style="text-align: center;">
- </div>
- </div>
- <div class="form-actions" style="display: flex; justify-content: center; gap: 10px; width: 100%;">
- <button type="button" onclick="closeDownloadModal()">Cancel</button>
- <button type="button" onclick="downloadClip()">Download Now</button>
- </div>
- </div>
- </div>
- </div>
-
- <div class="counts-wrapper">
- <table id="objectCounts" style="font-size: 1rem; border-collapse: collapse;">
- <thead>
- <tr><th style="text-align:left; border-bottom: 1px solid #ccc;">Object</th><th style="text-align:left; border-bottom: 1px solid #ccc;">Count</th></tr>
- </thead>
- <tbody></tbody>
- </table>
- <button onclick="resetCounts()">Reset</button>
- </div>
-
- <h3>Detected Events</h3>
- <div id="eventImagesContainer">
- {image_links}
- </div>
- </div>
-
- <script>
- const classLabels = {class_labels};
- const alertModal = document.getElementById("alertModal");
- const downloadModal = document.getElementById("downloadModal");
- const folderPicker = document.getElementById("folderPicker");
- const video = document.getElementById("video");
- const startTime = {start_time if start_time is not None else 'null'};
- const cameraName = "{camera_name}";
-
- window.onload = function () {{
- const container = document.getElementById('checkboxContainer');
- container.innerHTML = '';
-
- for (let i = 0; i < 80; i++) {{
- const checkbox = document.createElement('input');
- checkbox.type = 'checkbox';
- checkbox.value = i;
- checkbox.name = 'class_ids';
- checkbox.id = 'class_' + i;
-
- const label = document.createElement('label');
- label.htmlFor = 'class_' + i;
- label.textContent = (classLabels[i] !== undefined) ? `${{classLabels[i]}}` : `${{i}}`;
-
- container.appendChild(checkbox);
- container.appendChild(label);
- }}
- }};
-
- function openAlertModal() {{
- alertModal.style.display = "flex";
- }}
-
- function closeAlertModal() {{
- alertModal.style.display = "none";
- }}
-
- function openDownloadModal() {{
- downloadModal.style.display = "flex";
- }}
-
- function closeDownloadModal() {{
- downloadModal.style.display = "none";
- }}
-
- window.addEventListener("click", function(event) {{
- if (event.target === alertModal) closeAlertModal();
- if (event.target === downloadModal) closeDownloadModal();
- }});
-
- function loadStream(folder) {{
- const url = `${{cameraName}}/streams/${{folder}}/stream.m3u8`;
- if (Hls.isSupported()) {{
- const hls = new Hls();
- hls.loadSource(url);
- hls.attachMedia(video);
- hls.on(Hls.Events.MANIFEST_PARSED, function() {{
- if (startTime !== null) video.currentTime = startTime;
- video.play();
- }});
- }} else if (video.canPlayType('application/vnd.apple.mpegurl')) {{
- video.src = url;
- video.addEventListener('loadedmetadata', function() {{
- if (startTime !== null) video.currentTime = startTime;
- video.play();
- }});
- }}
- }}
-
- function loadEventImages(folder) {{
- fetch(`/event_thumbs?cam=${{cameraName}}&folder=${{folder}}`)
- .then(res => res.text())
- .then(html => {{
- const container = document.getElementById("eventImagesContainer");
-
- // Create a temporary div to parse incoming HTML
- const temp = document.createElement("div");
- temp.innerHTML = html.trim();
-
- // Compare child count and content
- const isSameLength = container.children.length === temp.children.length;
- let isSame = isSameLength;
-
- if (isSameLength) {{
- for (let i = 0; i < container.children.length; i++) {{
- if (
- container.children[i].outerHTML.trim() !==
- temp.children[i].outerHTML.trim()
- ) {{
- isSame = false;
- break;
- }}
- }}
- }}
-
- if (!isSame) {{
- container.innerHTML = html;
- }}
- }})
- .catch(err => {{
- console.error("Failed to load images:", err);
- const container = document.getElementById("eventImagesContainer");
- container.innerHTML = "<p>No event images found.</p>";
- }});
- }}
-
- function hmsToSeconds(hms) {{
- const [h, m, s] = hms.split(":").map(Number);
- return h * 3600 + m * 60 + s;
- }}
-
- function downloadClip() {{
- const folder = folderPicker.value;
- const start = hmsToSeconds(document.getElementById("clipStart").value);
- const end = hmsToSeconds(document.getElementById("clipEnd").value);
-
- if (isNaN(start) || isNaN(end) || end <= start) {{
- alert("Please enter a valid start and end time (end must be after start).");
- return;
- }}
-
- const url = `/download_clip?cam=${{cameraName}}&folder=${{folder}}&start=${{start}}&end=${{end}}`;
- const a = document.createElement("a");
- a.href = url;
- a.download = `clip_${{cameraName}}_${{folder}}_${{start}}_${{end}}.mp4`;
- document.body.appendChild(a);
- a.click();
- document.body.removeChild(a);
- }}
-
- function fetchCounts() {{
- fetch(`/get_counts?cam=${{encodeURIComponent(cameraName)}}`)
- .then(res => res.json())
- .then(data => {{
- const tbody = document.querySelector("#objectCounts tbody");
- tbody.innerHTML = "";
-
- const entries = Object.entries(data).sort((a, b) => b[1] - a[1]);
- if (!entries.length) {{
- tbody.innerHTML = "<tr><td colspan='2'>No detections.</td></tr>";
- return;
- }}
-
- for (const [label, count] of entries) {{
- tbody.innerHTML += `
- <tr>
- <td style="padding:6px 12px; border-bottom:1px solid #eee;">${{label}}</td>
- <td style="padding:6px 12px; border-bottom:1px solid #eee;">${{count}}</td>
- </tr>`;
- }}
- }})
- .catch(err => {{
- console.error("Failed to fetch counts:", err);
- document.querySelector("#objectCounts tbody").innerHTML = "<tr><td colspan='2'>Error fetching counts.</td></tr>";
- }});
- }}
-
- function resetCounts() {{
- if (!confirm("Are you sure you want to reset the counts for this camera?")) return;
- fetch(`/reset_counts?cam=${{encodeURIComponent(cameraName)}}`)
- .then(res => res.json())
- .then(() => {{
- console.log("Counts reset");
- fetchCounts();
- }})
- .catch(err => {{
- console.error("Failed to reset counts:", err);
- alert("Failed to reset counts.");
- }});
- }}
-
- function fetchAlerts() {{
- fetch(`/get_alerts?cam=${{encodeURIComponent(cameraName)}}`)
- .then(res => res.json())
- .then(alerts => {{
- const container = document.getElementById("alertsContainer");
- if (!alerts.length) {{
- container.innerHTML = `<p>No alerts configured.</p><button onclick="openAlertModal()">Add New</button>`;
- return;
- }}
-
- let html = `<table style="width:100%; border-collapse:collapse; font-size:0.95rem;">
- <thead>
- <tr>
- <th style="text-align:left; padding:6px; border-bottom:1px solid #ccc;"></th>
- <th style="text-align:left; padding:6px; border-bottom:1px solid #ccc;">Occurances of</th>
- <th style="text-align:left; padding:6px; border-bottom:1px solid #ccc;">Within</th>
- <th style="text-align:left; padding:6px; border-bottom:1px solid #ccc;"></th>
- </tr>
- </thead><tbody>`;
-
- for (const alert of alerts) {{
- const classNames = alert.classes.map(id => classLabels[id] ?? id).join(", ");
- const h = Math.floor(alert.window / 3600);
- const m = Math.floor((alert.window % 3600) / 60);
- const s = alert.window % 60;
- const windowStr = `${{String(h).padStart(2,'0')}}:${{String(m).padStart(2,'0')}}:${{String(s).padStart(2,'0')}}`;
- html += `<tr>
- <td style="padding:6px; border-bottom:1px solid #eee;">${{alert.max}}</td>
- <td style="padding:6px; border-bottom:1px solid #eee;">${{classNames}}</td>
- <td style="padding:6px; border-bottom:1px solid #eee;">${{windowStr}}</td>
- <td style="padding:6px; border-bottom:1px solid #eee;">
- <button onclick="deleteAlert('${{alert.id}}')">Delete</button>
- </td>
- </tr>`;
- }}
-
- html += `</tbody></table>
- <div style="margin-top:10px; text-align:right;">
- <button onclick="openAlertModal()">Add Alert</button>
- </div>`;
- container.innerHTML = html;
- }})
- .catch(err => {{
- console.error("Failed to fetch alerts:", err);
- document.getElementById("alertsContainer").innerHTML = "<p>Error loading alerts.</p>";
- }});
- }}
-
- function deleteAlert(alertId) {{
- fetch(`/delete_alert?cam=${{encodeURIComponent(cameraName)}}&id=${{alertId}}`)
- .then(res => {{
- if (!res.ok) throw new Error("Failed to delete alert");
- fetchAlerts();
- }})
- .catch(err => {{
- console.error("Delete failed:", err);
- alert("Failed to delete alert.");
- }});
- }}
-
- function addAlert(event) {{
- event.preventDefault();
- const form = event.target;
- const formData = new FormData(form);
- const windowMinutes = parseFloat(formData.get('window'));
- const windowSeconds = Math.round(windowMinutes * 60);
-
- // Get all checked class_ids
- const checked = form.querySelectorAll('input[name="class_ids"]:checked');
- const classIds = Array.from(checked).map(cb => cb.value).join(',');
-
- const params = new URLSearchParams({{
- cam: cameraName,
- window: windowSeconds,
- max: formData.get('max'),
- class_ids: classIds,
- }});
-
- fetch(`/add_alert?${{params.toString()}}`)
- .then(res => {{
- if (!res.ok) throw new Error("Failed to add alert");
- return res.json();
- }})
- .then(() => {{
- closeAlertModal();
- form.reset();
- fetchAlerts();
- }})
- .catch(err => {{
- console.error("Add alert failed:", err);
- alert("Failed to add alert.");
- }});
- }}
-
- folderPicker.addEventListener("change", () => {{
- const folder = folderPicker.value;
- loadStream(folder);
- loadEventImages(folder);
- }});
-
- loadStream(folderPicker.value);
- loadEventImages(folderPicker.value);
- fetchAlerts();
- fetchCounts();
- setInterval(fetchCounts, 5000);
- setInterval(() => loadEventImages(folderPicker.value), 5000);
- </script>
- </body>
- </html>
- """
- self.wfile.write(html.encode("utf-8"))
- return
-
- requested_path = parsed_path.path.lstrip('/')
- if requested_path.startswith("cameras/"):
- requested_path = requested_path[len("cameras/"):]
- file_path = self.base_dir / requested_path
-
- if not file_path.exists():
- self.send_error(404)
- return
-
- self.send_response(200)
- if file_path.suffix == '.m3u8':
- self.send_header('Content-Type', 'application/vnd.apple.mpegurl')
- self.send_header('Cache-Control', 'no-cache')
- elif file_path.suffix == '.ts':
- self.send_header('Content-Type', 'video/MP2T')
- elif file_path.suffix == '.jpg':
- self.send_header('Content-Type', 'image/jpeg')
- self.end_headers()
-
- with open(file_path, 'rb') as f:
- shutil.copyfileobj(f, self.wfile)
-
-
-def schedule_daily_restart(hls_streamer, restart_time):
- """Schedule daily restarts at a specific time"""
- while True:
- now = datetime.now().time()
- target = time_obj(restart_time[0], restart_time[1]) # (hour, minute)
-
- # Calculate seconds until next restart
- if now >= target:
- # If time already passed today, schedule for tomorrow
- delta = (24 * 3600) - ((now.hour * 3600 + now.minute * 60 + now.second) - (target.hour * 3600 + target.minute * 60))
- else:
- delta = ((target.hour * 3600 + target.minute * 60) -
- (now.hour * 3600 + now.minute * 60 + now.second))
-
- print(f"Next stream restart scheduled in {delta//3600}h {(delta%3600)//60}m")
- time.sleep(delta)
-
- print("\nPerforming scheduled stream restart...")
- hls_streamer.stop()
- time.sleep(10) # todo can get away with none or less?
- hls_streamer.start()
-
-def send_notif(session_token: str):
- host = "www.rors.ai"
- endpoint = "/send" #/test
- boundary = f"Boundary-{uuid.uuid4()}"
- content_type = f"multipart/form-data; boundary={boundary}"
- lines = [
- f"--{boundary}",
- 'Content-Disposition: form-data; name="session_token"',
- "",
- session_token,
- f"--{boundary}--",
- ""
- ]
- body = "\r\n".join(lines).encode("utf-8")
- conn = http.client.HTTPSConnection(host)
- headers = {"Content-Type": content_type, "Content-Length": str(len(body))}
- try:
- conn.request("POST", endpoint, body, headers)
- response = conn.getresponse()
- print(f"Status: {response.status} {response.reason}")
- print(response.read().decode())
- except Exception as e:
- print(f"Error sending session token: {e}")
- finally:
- conn.close()
-
-import aes
-MAGIC_NUMBER = 0x4D41474943
-HEADER_SIZE = 8
-AES_BLOCK_SIZE = 16
-AES_KEY_SIZE = 32
-
-def prepare_key(key: str) -> bytes:
- key_bytes = key.encode('utf-8')[:AES_KEY_SIZE]
- return key_bytes.ljust(AES_KEY_SIZE, b'\0')
-
-def pkcs7_pad(data: bytes, block_size: int) -> bytes:
- pad_len = block_size - (len(data) % block_size)
- return data + bytes([pad_len] * pad_len)
-
-def encrypt_cbc(data: bytes, key: bytes, iv: bytes) -> bytes:
- aes_cipher = aes.AES(key)
- encrypted = bytearray()
- prev_block = iv
-
- for i in range(0, len(data), AES_BLOCK_SIZE):
- block = data[i:i + AES_BLOCK_SIZE]
- xored = bytes([b ^ p for b, p in zip(block, prev_block)])
- encrypted_block = bytes(aes_cipher.encrypt(xored))
- encrypted += encrypted_block
- prev_block = encrypted_block
- return bytes(encrypted)
-
-def encrypt_file(input_path: Path, output_path: Path, key: str):
- try:
- key_bytes = prepare_key(key)
- iv = os.urandom(AES_BLOCK_SIZE)
-
- with open(input_path, 'rb') as f:
- plaintext = f.read()
-
- # Add MAGIC header and pad
- data = struct.pack('<Q', MAGIC_NUMBER) + plaintext
- padded = pkcs7_pad(data, AES_BLOCK_SIZE)
-
- ciphertext = encrypt_cbc(padded, key_bytes, iv)
-
- with open(output_path, 'wb') as f:
- f.write(iv + ciphertext) # ObjC expects IV prepended
-
- return True
-
- except Exception as e:
- print(f"ENCRYPTION FAILED: {e}")
- return False
-
-def upload_file(file_path: Path, session_token: str):
- if not file_path.exists():
- print(f"File not found: {file_path}")
- return False
-
- try:
- with open(file_path, 'rb') as f:
- file_data = f.read()
- file_name = file_path.name
- file_size = len(file_data)
- except Exception as e:
- print(f"Error reading file: {e}")
- return False
-
- try:
- params = {
- "filename": file_name,
- "session_token": session_token,
- "size": str(file_size)
- }
- query_string = urllib.parse.urlencode(params)
- url = f"https://rors.ai/upload?{query_string}"
-
- req = urllib.request.Request(url)
- with urllib.request.urlopen(req, timeout=10) as response:
- if response.status != 200:
- print(f"Failed to get upload URL: {response.status}")
- return False
- response_data = json.loads(response.read().decode('utf-8'))
- presigned_url = response_data.get("url")
- if not presigned_url:
- print("Invalid response - missing upload URL")
- return False
- except Exception as e:
- print(f"Error getting upload URL: {e}")
- return False
-
- success = False
- for attempt in range(4):
- try:
- url_parts = urllib.parse.urlparse(presigned_url)
- if url_parts.scheme == 'https':
- conn = http.client.HTTPSConnection(url_parts.netloc)
- else:
- conn = http.client.HTTPConnection(url_parts.netloc)
-
- headers = {
- "Content-Type": "application/octet-stream",
- "Content-Length": str(file_size)
- }
- conn.request("PUT", url_parts.path + "?" + url_parts.query, body=file_data, headers=headers)
- upload_response = conn.getresponse()
-
- if 200 <= upload_response.status < 300:
- print(f"File uploaded successfully on attempt {attempt + 1}")
- success = True
- conn.close()
- break
- else:
- print(f"Upload failed with status {upload_response.status} on attempt {attempt + 1}")
- conn.close()
- except Exception as e:
- print(f"Upload error on attempt {attempt + 1}: {e}")
-
- if attempt < 3:
- delay = 3 * (2 ** attempt)
- print(f"Waiting {delay:.1f} seconds before retrying...")
- time.sleep(delay)
-
- try:
- file_path.unlink()
- print(f"Deleted file: {file_path}")
- except Exception as e:
- print(f"Failed to delete file: {e}")
-
- return success
-
-def get_lan_ip():
- s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- try:
- s.connect(("8.8.8.8", 80))
- ip = s.getsockname()[0]
- except Exception:
- ip = '127.0.0.1'
- finally:
- s.close()
- return ip
-
-def start_cam(rtsp,cam_name):
- if not rtsp or not cam_name: return
- args = sys.argv[:]
- script = sys.argv[0]
-
- def upsert_arg(args, key, value):
- prefix = f"--{key}="
- for i, arg in enumerate(args):
- if arg.startswith(prefix):
- args[i] = f"{prefix}{value}"
- return args
- return args + [f"{prefix}{value}"]
-
- args = upsert_arg(args, "cam_name", cam_name)
- args = upsert_arg(args, "rtsp", rtsp)
- proc = subprocess.Popen([sys.executable, script] + args[1:], close_fds=True)
- active_subprocesses.append(proc)
-
-
-live_link = dict()
-is_live_lock = threading.Lock()
-def check_upload_link(camera_name="clearcampy"):
- global live_link
- query_params = urllib.parse.urlencode({
- "name": quote(camera_name),
- "session_token": userID
- })
- url = f"https://rors.ai/get_stream_upload_link?{query_params}"
-
- try:
- req = urllib.request.Request(url)
- with urllib.request.urlopen(req) as response:
- if response.status == 200:
- response_data = json.loads(response.read().decode('utf-8'))
- upload_link = response_data.get("upload_link")
- with is_live_lock: live_link[camera_name] = upload_link
- else:
- raise Exception(f"HTTP Error: {response.status}")
- except Exception as e:
- with is_live_lock:
- if camera_name in live_link: live_link[camera_name] = None
- print(f"Error checking upload link: {e}")
-
-def upload_to_r2(file_path: Path, signed_url: str, max_retries: int = 0) -> bool:
- try:
- url_parts = urllib.parse.urlparse(signed_url)
- if url_parts.scheme == 'https':
- conn = http.client.HTTPSConnection(url_parts.netloc)
- else:
- conn = http.client.HTTPConnection(url_parts.netloc)
-
- with file_path.open('rb') as f:
- file_data = f.read()
- headers = {'Content-Type': 'application/octet-stream'}
- conn.request("PUT", url_parts.path + "?" + url_parts.query, body=file_data, headers=headers)
- response = conn.getresponse()
- if 200 <= response.status < 300:
- return True
- return False
- except Exception as e:
- print(f"Error uploading to R2: {e}")
- return False
-
-cams = dict()
-active_subprocesses = []
-import socket
-class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
- """Serve HTTP requests in separate threads."""
-
-if __name__ == "__main__":
- if os.path.exists("cams.pkl"):
- with open("cams.pkl", 'rb') as f:
- cams = pickle.load(f)
- else:
- with open("cams.pkl", 'wb') as f:
- pickle.dump(cams, f)
-
- rtsp_url = next((arg.split("=", 1)[1] for arg in sys.argv[1:] if arg.startswith("--rtsp=")), None)
- classes = {"0","1","2","7"} # person, bike, car, truck, bird (14)
-
- userID = next((arg.split("=", 1)[1] for arg in sys.argv[1:] if arg.startswith("--userid=")), None)
- key = next((arg.split("=", 1)[1] for arg in sys.argv[1:] if arg.startswith("--key=")), None)
-
- if rtsp_url is None and userID is None:
- userID = input("enter your Clearcam user id or press Enter to skip: ")
- if len(userID) > 0:
- key = ""
- while len(key) < 1: key = input("enter a password for encryption: ")
- new_args = sys.argv + [f"--userid={userID}", f"--key={key}"]
- subprocess.Popen([sys.executable] + new_args, close_fds=True)
- sys.exit(0)
- else: userID = None
-
- if userID is not None and key is None:
- print("Error: key is required when userID is provided")
- sys.exit(1)
- cam_name = next((arg.split("=", 1)[1] for arg in sys.argv[1:] if arg.startswith("--cam_name=")), "my_camera")
-
- track_thresh = 0.5 #default 0.6
- yolo_thresh = 0.5
-
- track = True #for now
- if track:
- from yolox.tracker.byte_tracker import BYTETracker
- class Args:
- def __init__(self):
- self.track_thresh = track_thresh
- self.track_buffer = 60 # frames, was 30
- self.mot20 = False
- self.match_thresh = 0.9
-
- tracker = BYTETracker(Args())
- live_link = dict()
-
-
- if rtsp_url is None:
- for camera_name in cams.keys():
- start_cam(rtsp=cams[camera_name],cam_name=camera_name)
-
- class_labels = fetch('https://raw.githubusercontent.com/pjreddie/darknet/master/data/coco.names').read_text().split("\n")
- yolo_variant = next((arg.split("=", 1)[1] for arg in sys.argv[1:] if arg.startswith("--yolo_size=")), 'n')
- color_dict = {label: tuple((((i+1) * 50) % 256, ((i+1) * 100) % 256, ((i+1) * 150) % 256)) for i, label in enumerate(class_labels)}
- depth, width, ratio = get_variant_multiples(yolo_variant)
- if rtsp_url:
- yolo_infer = YOLOv8(w=width, r=ratio, d=depth, num_classes=80)
- state_dict = safe_load(get_weights_location(yolo_variant))
- load_state_dict(yolo_infer, state_dict)
- cam = VideoCapture(rtsp_url,camera_name=cam_name)
- hls_streamer = HLSStreamer(cam,camera_name=cam_name)
- cam.streamer = hls_streamer
-
- try:
- try:
- server = ThreadedHTTPServer(('0.0.0.0', 8080), HLSRequestHandler)
- print(f"Serving at http://{get_lan_ip()}:8080")
- except OSError as e:
- if e.errno == socket.errno.EADDRINUSE:
- print("Port in use, server not started.")
- server = None
- else:
- raise
-
- if rtsp_url:
- hls_streamer.start()
- restart_time = (0, 0)
- threading.Thread(
- target=schedule_daily_restart,
- args=(hls_streamer, restart_time),
- daemon=True
- ).start()
-
- if server:
- server.serve_forever()
- else:
- while True: time.sleep(3600)
-
- except KeyboardInterrupt:
- if rtsp_url:
- hls_streamer.stop()
- cam.release()
- server.shutdown()
\ No newline at end of file
diff --git a/experimental/rtsp_yolov8.py b/experimental/rtsp_yolov8.py
deleted file mode 100644
index dc9aedb..0000000
--- a/experimental/rtsp_yolov8.py
+++ /dev/null
@@ -1,813 +0,0 @@
-from tinygrad.nn import Conv2d, BatchNorm2d
-from tinygrad.tensor import Tensor
-from tinygrad import TinyJit
-from tinygrad.device import is_dtype_supported
-from tinygrad import dtypes
-import numpy as np
-from itertools import chain
-from pathlib import Path
-import cv2
-from collections import defaultdict, deque
-import time, sys
-from tinygrad.helpers import fetch
-from tinygrad.nn.state import safe_load, load_state_dict
-import json
-import cv2
-import time
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from socketserver import ThreadingMixIn
-import threading
-import shutil
-from datetime import datetime, time as time_obj, timedelta
-
-from yolox.tracker.byte_tracker import BYTETracker
-
-track_thresh = 0.5 # default is 0.6
-yolo_thresh = 0.5
-
-class Args:
- def __init__(self):
- self.track_thresh = track_thresh
- self.track_buffer = 60 #frames, was 30
- self.mot20 = False
- self.match_thresh = 0.9
-
-tracker = BYTETracker(Args())
-
-#Model architecture from https://github.com/ultralytics/ultralytics/issues/189
-#The upsampling class has been taken from this pull request https://github.com/tinygrad/tinygrad/pull/784 by dc-dc-dc. Now 2(?) models use upsampling. (retinet and this)
-
-#Pre processing image functions.
-def compute_transform(image, new_shape=(1280, 1280), auto=False, scaleFill=False, scaleup=True, stride=32) -> Tensor:
- shape = image.shape[:2] # current shape [height, width]
- new_shape = (new_shape, new_shape) if isinstance(new_shape, int) else new_shape
- r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
- r = min(r, 1.0) if not scaleup else r
- new_unpad = (int(round(shape[1] * r)), int(round(shape[0] * r)))
- dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
- dw, dh = (np.mod(dw, stride), np.mod(dh, stride)) if auto else (0.0, 0.0)
- new_unpad = (new_shape[1], new_shape[0]) if scaleFill else new_unpad
- dw /= 2
- dh /= 2
- image = cv2.resize(image, new_unpad, interpolation=cv2.INTER_LINEAR) if shape[::-1] != new_unpad else image
- top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
- left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
- image = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))
- return Tensor(image)
-
-def preprocess(im, imgsz=1280, model_stride=32, model_pt=True): return compute_transform(im, new_shape=imgsz, auto=True, stride=model_stride)
-
-# utility functions for forward pass.
-def dist2bbox(distance, anchor_points, xywh=True, dim=-1):
- lt, rb = distance.chunk(2, dim)
- x1y1 = anchor_points - lt
- x2y2 = anchor_points + rb
- if xywh:
- c_xy = (x1y1 + x2y2) / 2
- wh = x2y2 - x1y1
- return c_xy.cat(wh, dim=1)
- return x1y1.cat(x2y2, dim=1)
-
-def make_anchors(feats, strides, grid_cell_offset=0.5):
- anchor_points, stride_tensor = [], []
- assert feats is not None
- for i, stride in enumerate(strides):
- _, _, h, w = feats[i].shape
- sx = Tensor.arange(w) + grid_cell_offset
- sy = Tensor.arange(h) + grid_cell_offset
-
- # this is np.meshgrid but in tinygrad
- sx = sx.reshape(1, -1).repeat([h, 1]).reshape(-1)
- sy = sy.reshape(-1, 1).repeat([1, w]).reshape(-1)
-
- anchor_points.append(Tensor.stack(sx, sy, dim=-1).reshape(-1, 2))
- stride_tensor.append(Tensor.full((h * w), stride))
- anchor_points = anchor_points[0].cat(anchor_points[1], anchor_points[2])
- stride_tensor = stride_tensor[0].cat(stride_tensor[1], stride_tensor[2]).unsqueeze(1)
- return anchor_points, stride_tensor
-
-# this function is from the original implementation
-def autopad(k, p=None, d=1): # kernel, padding, dilation
- if d > 1:
- k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k] # actual kernel-size
- if p is None:
- p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad
- return p
-
-def clip_boxes(boxes, shape):
- boxes[..., [0, 2]] = np.clip(boxes[..., [0, 2]], 0, shape[1]) # x1, x2
- boxes[..., [1, 3]] = np.clip(boxes[..., [1, 3]], 0, shape[0]) # y1, y2
- return boxes
-
-def scale_boxes(img1_shape, predictions, img0_shape, ratio_pad=None):
- gain = ratio_pad if ratio_pad else min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])
- pad = ((img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2)
- for pred in predictions:
- boxes_np = pred[:4].numpy() if isinstance(pred[:4], Tensor) else pred[:4]
- boxes_np[..., [0, 2]] -= pad[0]
- boxes_np[..., [1, 3]] -= pad[1]
- boxes_np[..., :4] /= gain
- boxes_np = clip_boxes(boxes_np, img0_shape)
- pred[:4] = boxes_np
- return predictions
-
-def get_variant_multiples(variant):
- return {'n':(0.33, 0.25, 2.0), 's':(0.33, 0.50, 2.0), 'm':(0.67, 0.75, 1.5), 'l':(1.0, 1.0, 1.0), 'x':(1, 1.25, 1.0) }.get(variant, None)
-
-def label_predictions(all_predictions):
- class_index_count = defaultdict(int)
- for pred in all_predictions:
- class_id = int(pred[-1])
- if pred[-2] != 0: class_index_count[class_id] += 1
-
- return dict(class_index_count)
-
-#this is taken from https://github.com/tinygrad/tinygrad/pull/784/files by dc-dc-dc (Now 2 models use upsampling)
-class Upsample:
- def __init__(self, scale_factor:int, mode: str = "nearest") -> None:
- assert mode == "nearest" # only mode supported for now
- self.mode = mode
- self.scale_factor = scale_factor
-
- def __call__(self, x: Tensor) -> Tensor:
- assert len(x.shape) > 2 and len(x.shape) <= 5
- (b, c), _lens = x.shape[:2], len(x.shape[2:])
- tmp = x.reshape([b, c, -1] + [1] * _lens) * Tensor.ones(*[1, 1, 1] + [self.scale_factor] * _lens)
- return tmp.reshape(list(x.shape) + [self.scale_factor] * _lens).permute([0, 1] + list(chain.from_iterable([[y+2, y+2+_lens] for y in range(_lens)]))).reshape([b, c] + [x * self.scale_factor for x in x.shape[2:]])
-
-class Conv_Block:
- def __init__(self, c1, c2, kernel_size=1, stride=1, groups=1, dilation=1, padding=None):
- self.conv = Conv2d(c1,c2, kernel_size, stride, padding=autopad(kernel_size, padding, dilation), bias=False, groups=groups, dilation=dilation)
- self.bn = BatchNorm2d(c2, eps=0.001)
-
- def __call__(self, x):
- return self.bn(self.conv(x)).silu()
-
-class Bottleneck:
- def __init__(self, c1, c2 , shortcut: bool, g=1, kernels: list = (3,3), channel_factor=0.5):
- c_ = int(c2 * channel_factor)
- self.cv1 = Conv_Block(c1, c_, kernel_size=kernels[0], stride=1, padding=None)
- self.cv2 = Conv_Block(c_, c2, kernel_size=kernels[1], stride=1, padding=None, groups=g)
- self.residual = c1 == c2 and shortcut
-
- def __call__(self, x):
- return x + self.cv2(self.cv1(x)) if self.residual else self.cv2(self.cv1(x))
-
-class C2f:
- def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
- self.c = int(c2 * e)
- self.cv1 = Conv_Block(c1, 2 * self.c, 1,)
- self.cv2 = Conv_Block((2 + n) * self.c, c2, 1)
- self.bottleneck = [Bottleneck(self.c, self.c, shortcut, g, kernels=[(3, 3), (3, 3)], channel_factor=1.0) for _ in range(n)]
-
- def __call__(self, x):
- y= list(self.cv1(x).chunk(2, 1))
- y.extend(m(y[-1]) for m in self.bottleneck)
- z = y[0]
- for i in y[1:]: z = z.cat(i, dim=1)
- return self.cv2(z)
-
-class SPPF:
- def __init__(self, c1, c2, k=5):
- c_ = c1 // 2 # hidden channels
- self.cv1 = Conv_Block(c1, c_, 1, 1, padding=None)
- self.cv2 = Conv_Block(c_ * 4, c2, 1, 1, padding=None)
-
- # TODO: this pads with 0s, whereas torch function pads with -infinity. This results in a < 2% difference in prediction which does not make a difference visually.
- self.maxpool = lambda x : x.pad((k // 2, k // 2, k // 2, k // 2)).max_pool2d(kernel_size=k, stride=1)
-
- def __call__(self, x):
- x = self.cv1(x)
- x2 = self.maxpool(x)
- x3 = self.maxpool(x2)
- x4 = self.maxpool(x3)
- return self.cv2(x.cat(x2, x3, x4, dim=1))
-
-class DFL:
- def __init__(self, c1=16):
- self.conv = Conv2d(c1, 1, 1, bias=False)
- x = Tensor.arange(c1)
- self.conv.weight.replace(x.reshape(1, c1, 1, 1))
- self.c1 = c1
-
- def __call__(self, x):
- b, c, a = x.shape # batch, channels, anchors
- return self.conv(x.reshape(b, 4, self.c1, a).transpose(2, 1).softmax(1)).reshape(b, 4, a)
-
-#backbone
-class Darknet:
- def __init__(self, w, r, d):
- self.b1 = [Conv_Block(c1=3, c2= int(64*w), kernel_size=3, stride=2, padding=1), Conv_Block(int(64*w), int(128*w), kernel_size=3, stride=2, padding=1)]
- self.b2 = [C2f(c1=int(128*w), c2=int(128*w), n=round(3*d), shortcut=True), Conv_Block(int(128*w), int(256*w), 3, 2, 1), C2f(int(256*w), int(256*w), round(6*d), True)]
- self.b3 = [Conv_Block(int(256*w), int(512*w), kernel_size=3, stride=2, padding=1), C2f(int(512*w), int(512*w), round(6*d), True)]
- self.b4 = [Conv_Block(int(512*w), int(512*w*r), kernel_size=3, stride=2, padding=1), C2f(int(512*w*r), int(512*w*r), round(3*d), True)]
- self.b5 = [SPPF(int(512*w*r), int(512*w*r), 5)]
-
- def return_modules(self):
- return [*self.b1, *self.b2, *self.b3, *self.b4, *self.b5]
-
- def __call__(self, x):
- x1 = x.sequential(self.b1)
- x2 = x1.sequential(self.b2)
- x3 = x2.sequential(self.b3)
- x4 = x3.sequential(self.b4)
- x5 = x4.sequential(self.b5)
- return (x2, x3, x5)
-
-#yolo fpn (neck)
-class Yolov8NECK:
- def __init__(self, w, r, d): #width_multiple, ratio_multiple, depth_multiple
- self.up = Upsample(2, mode='nearest')
- self.n1 = C2f(c1=int(512*w*(1+r)), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n2 = C2f(c1=int(768*w), c2=int(256*w), n=round(3*d), shortcut=False)
- self.n3 = Conv_Block(c1=int(256*w), c2=int(256*w), kernel_size=3, stride=2, padding=1)
- self.n4 = C2f(c1=int(768*w), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n5 = Conv_Block(c1=int(512* w), c2=int(512 * w), kernel_size=3, stride=2, padding=1)
- self.n6 = C2f(c1=int(512*w*(1+r)), c2=int(512*w*r), n=round(3*d), shortcut=False)
-
- def return_modules(self):
- return [self.n1, self.n2, self.n3, self.n4, self.n5, self.n6]
-
- def __call__(self, p3, p4, p5):
- x = self.n1(self.up(p5).cat(p4, dim=1))
- head_1 = self.n2(self.up(x).cat(p3, dim=1))
- head_2 = self.n4(self.n3(head_1).cat(x, dim=1))
- head_3 = self.n6(self.n5(head_2).cat(p5, dim=1))
- return [head_1, head_2, head_3]
-
-#task specific head.
-class DetectionHead:
- def __init__(self, nc=80, filters=()):
- self.ch = 16
- self.nc = nc # number of classes
- self.nl = len(filters)
- self.no = nc + self.ch * 4 #
- self.stride = [8, 16, 32]
- c1 = max(filters[0], self.nc)
- c2 = max((filters[0] // 4, self.ch * 4))
- self.dfl = DFL(self.ch)
- self.cv3 = [[Conv_Block(x, c1, 3), Conv_Block(c1, c1, 3), Conv2d(c1, self.nc, 1)] for x in filters]
- self.cv2 = [[Conv_Block(x, c2, 3), Conv_Block(c2, c2, 3), Conv2d(c2, 4 * self.ch, 1)] for x in filters]
-
- def __call__(self, x):
- for i in range(self.nl):
- x[i] = (x[i].sequential(self.cv2[i]).cat(x[i].sequential(self.cv3[i]), dim=1))
- self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
- y = [(i.reshape(x[0].shape[0], self.no, -1)) for i in x]
- x_cat = y[0].cat(y[1], y[2], dim=2)
- box, cls = x_cat[:, :self.ch * 4], x_cat[:, self.ch * 4:]
- dbox = dist2bbox(self.dfl(box), self.anchors.unsqueeze(0), xywh=True, dim=1) * self.strides
- z = dbox.cat(cls.sigmoid(), dim=1)
- return z
-
-class YOLOv8:
- def __init__(self, w, r, d, num_classes): #width_multiple, ratio_multiple, depth_multiple
- self.net = Darknet(w, r, d)
- self.fpn = Yolov8NECK(w, r, d)
- self.head = DetectionHead(num_classes, filters=(int(256*w), int(512*w), int(512*w*r)))
-
- def __call__(self, x):
- x = self.net(x)
- x = self.fpn(*x)
- x = self.head(x)
- # TODO: postprocess needs to be in the model to be compiled to webgpu
- return postprocess(x)
-
- def return_all_trainable_modules(self):
- backbone_modules = [*range(10)]
- yolov8neck_modules = [12, 15, 16, 18, 19, 21]
- yolov8_head_weights = [(22, self.head)]
- return [*zip(backbone_modules, self.net.return_modules()), *zip(yolov8neck_modules, self.fpn.return_modules()), *yolov8_head_weights]
-
-def convert_f16_safetensor_to_f32(input_file: Path, output_file: Path):
- with open(input_file, 'rb') as f:
- metadata_length = int.from_bytes(f.read(8), 'little')
- metadata = json.loads(f.read(metadata_length).decode())
- float32_values = np.fromfile(f, dtype=np.float16).astype(np.float32)
-
- for v in metadata.values():
- if v["dtype"] == "F16": v.update({"dtype": "F32", "data_offsets": [offset * 2 for offset in v["data_offsets"]]})
-
- with open(output_file, 'wb') as f:
- new_metadata_bytes = json.dumps(metadata).encode()
- f.write(len(new_metadata_bytes).to_bytes(8, 'little'))
- f.write(new_metadata_bytes)
- float32_values.tofile(f)
-
-def compute_iou_matrix(boxes):
- x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
- areas = (x2 - x1) * (y2 - y1)
- x1 = Tensor.maximum(x1[:, None], x1[None, :])
- y1 = Tensor.maximum(y1[:, None], y1[None, :])
- x2 = Tensor.minimum(x2[:, None], x2[None, :])
- y2 = Tensor.minimum(y2[:, None], y2[None, :])
- w = Tensor.maximum(Tensor(0), x2 - x1)
- h = Tensor.maximum(Tensor(0), y2 - y1)
- intersection = w * h
- union = areas[:, None] + areas[None, :] - intersection
- return intersection / union
-
-def postprocess(output, max_det=300, conf_threshold=0.25, iou_threshold=0.45):
- xc, yc, w, h, class_scores = output[0][0], output[0][1], output[0][2], output[0][3], output[0][4:]
- class_ids = Tensor.argmax(class_scores, axis=0)
- probs = Tensor.max(class_scores, axis=0)
- probs = Tensor.where(probs >= conf_threshold, probs, 0)
- x1 = xc - w / 2
- y1 = yc - h / 2
- x2 = xc + w / 2
- y2 = yc + h / 2
- boxes = Tensor.stack(x1, y1, x2, y2, probs, class_ids, dim=1)
- order = Tensor.topk(probs, max_det)[1]
- boxes = boxes[order]
- iou = compute_iou_matrix(boxes[:, :4])
- iou = Tensor.triu(iou, diagonal=1)
- same_class_mask = boxes[:, -1][:, None] == boxes[:, -1][None, :]
- high_iou_mask = (iou > iou_threshold) & same_class_mask
- no_overlap_mask = high_iou_mask.sum(axis=0) == 0
- boxes = boxes * no_overlap_mask.unsqueeze(-1)
- return boxes
-
-def get_weights_location(yolo_variant: str) -> Path:
- weights_location = Path(__file__).parents[1] / "weights" / f'yolov8{yolo_variant}.safetensors'
- fetch(f'https://gitlab.com/r3sist/yolov8_weights/-/raw/master/yolov8{yolo_variant}.safetensors', weights_location)
- #f16
- return weights_location.with_name(f"{weights_location.stem}.safetensors")
- f32_weights = weights_location.with_name(f"{weights_location.stem}_f32.safetensors")
- if not f32_weights.exists(): convert_f16_safetensor_to_f32(weights_location, f32_weights)
- return f32_weights
-
-@TinyJit
-def do_inf(im):
- im = im.unsqueeze(0)
- im = im[..., ::-1].permute(0, 3, 1, 2)
- im = im / 255.0
- predictions = yolo_infer(im)
- return predictions
-
-# RTSP URL
-# Video capture thread
-import subprocess
-import threading
-import time
-import numpy as np
-import cv2
-from datetime import datetime
-import os
-import threading
-
-class RollingClassCounter:
- def __init__(self, window_seconds=3600):
- self.window = window_seconds
- self.data = defaultdict(deque)
-
- def add(self, class_id):
- now = time.time()
- self.data[class_id].append(now)
- self.cleanup(class_id, now)
-
- def cleanup(self, class_id, now):
- q = self.data[class_id]
- while q and now - q[0] > self.window:
- q.popleft()
-
- def get_counts(self):
- now = time.time()
- counts = {}
- for class_id, q in self.data.items():
- # Remove old timestamps
- while q and now - q[0] > self.window:
- q.popleft()
- if q:
- counts[class_id] = len(q)
- return counts
-
-def resolve_youtube_stream_url(youtube_url):
- import yt_dlp
- ydl_opts = {
- 'format': 'best',
- 'quiet': True,
- 'noplaylist': True,
- 'force_generic_extractor': False,
- }
- with yt_dlp.YoutubeDL(ydl_opts) as ydl:
- info = ydl.extract_info(youtube_url, download=False)
- if 'url' in info:
- return info['url']
- elif 'entries' in info and info['entries']:
- return info['entries'][0]['url']
- else:
- raise RuntimeError("Could not resolve YouTube stream URL")
-
-class VideoCapture:
- def __init__(self, src):
- self.counter = RollingClassCounter(window_seconds=3600)
- self.object_set = set()
- self.src = src
- self.width = 1280 # Reduced resolution for better performance
- self.height = 720
- self.proc = None
- self.running = True
-
- self.raw_frame = None
- self.annotated_frame = None
- self.last_preds = []
-
- self.lock = threading.Lock()
-
- self._open_ffmpeg()
-
- # Start threads
- threading.Thread(target=self.capture_loop, daemon=True).start()
- threading.Thread(target=self.inference_loop, daemon=True).start()
-
- def _open_ffmpeg(self):
- if self.proc:
- self.proc.kill()
-
- if "youtube.com" in self.src or "youtu.be" in self.src:
- self.src = resolve_youtube_stream_url(self.src)
-
- command = [
- "ffmpeg",
- "-user_agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
- "-headers", "Referer: https://www.google.com.com/\r\n",
- "-i", self.src,
- "-loglevel", "quiet",
- "-reconnect", "1",
- "-reconnect_streamed", "1",
- "-reconnect_delay_max", "2",
- "-an",
- "-f", "rawvideo",
- "-pix_fmt", "bgr24",
- "-vf", f"scale={self.width}:{self.height}",
- "-timeout", "5000000",
- "-rw_timeout", "15000000",
- "-"
- ]
-
- self.proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-
-
-
- def capture_loop(self):
- frame_size = self.width * self.height * 3
- fail_count = 0
- while self.running:
- try:
- raw_bytes = self.proc.stdout.read(frame_size)
- if len(raw_bytes) != frame_size:
- fail_count += 1
- print(f"FFmpeg frame read failed (count={fail_count}), restarting stream...")
- if fail_count > 5:
- self._open_ffmpeg()
- fail_count = 0
- time.sleep(0.5)
- continue
- fail_count = 0
- frame = np.frombuffer(raw_bytes, np.uint8).reshape((self.height, self.width, 3))
- with self.lock:
- self.raw_frame = frame.copy()
- self.annotated_frame = self.draw_predictions(frame.copy(), self.last_preds)
- time.sleep(1 / 30)
- except Exception as e:
- print("Error in capture_loop:", e)
- self._open_ffmpeg()
- time.sleep(1)
-
- def inference_loop(self):
- prev_time = time.time()
- while self.running:
- with self.lock:
- frame = self.raw_frame.copy() if self.raw_frame is not None else None
- if frame is not None:
- pre = preprocess(frame)
- preds2 = do_inf(pre).numpy()
- online_targets = tracker.update(preds2, [1280,1280], [1280,1280])
- preds2 = []
- for x in online_targets:
- preds2.append(np.array([x.tlwh[0],x.tlwh[1],(x.tlwh[0]+x.tlwh[2]),(x.tlwh[1]+x.tlwh[3]),x.score,x.class_id]))
- if int(x.track_id) not in self.object_set:
- if classes is not None and str(int(x.class_id)) not in classes: continue
- self.object_set.add(int(x.track_id))
- self.counter.add(int(x.class_id))
- preds2 = np.array(preds2)
- preds2 = scale_boxes(pre.shape[:2], preds2, frame.shape)
- with self.lock:
- self.last_preds = preds2
- curr_time = time.time()
- fps = 1 / (curr_time - prev_time)
- prev_time = curr_time
- print(f"\rFPS: {fps:.2f}", end="", flush=True)
-
- def is_bright_color(self,color):
- r, g, b = color
- brightness = (r * 299 + g * 587 + b * 114) / 1000
- return brightness > 127
-
- def draw_predictions(self, frame, preds):
- for x1, y1, x2, y2, conf, cls in preds:
- if conf < yolo_thresh or (classes is not None and str(int(cls)) not in classes):
- continue
- x1, y1, x2, y2 = map(int, [x1, y1, x2, y2])
- label = f"{class_labels[int(cls)]}:{conf:.2f}"
- color = color_dict[class_labels[int(cls)]]
- cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
- (text_width, text_height), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
- font_color = (0, 0, 0) if self.is_bright_color(color) else (255, 255, 255)
- cv2.rectangle(frame, (x1, y1 - text_height - 10), (x1 + text_width + 2, y1), color, -1)
- cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, font_color, 1, cv2.LINE_AA)
-
- counts = self.counter.get_counts()
- if counts:
- top_classes = sorted(counts.items(), key=lambda x: x[1], reverse=True)[:5]
- labels = ["objects in last hour:"] + [class_labels[cls] for cls, _ in top_classes]
- values = [""] + [format(count, ",") for _, count in top_classes]
- labels.append("github.com/roryclear/clearcam")
- values.append("")
- # Font settings
- font = cv2.FONT_HERSHEY_SIMPLEX
- font_scale = 0.5
- font_thickness = 1
- line_height = 15
- padding = 5
-
- # Measure box sizes
- label_width = max(cv2.getTextSize(label, font, font_scale, font_thickness)[0][0] for label in labels)
- value_width = max(cv2.getTextSize(value, font, font_scale, font_thickness)[0][0] for value in values)
-
- box_height = line_height * len(labels) + 2 * padding
- label_box_width = label_width + 2 * padding
- value_box_width = value_width + 2 * padding
- total_width = label_box_width + value_box_width
-
- # Draw background
- x, y = 5, 5
- cv2.rectangle(frame, (x, y), (x + total_width, y + box_height), (50, 50, 50), -1)
-
- # Draw text
- for i, (label, value) in enumerate(zip(labels, values)):
- text_y = y + padding + (i + 1) * line_height - 3
- cv2.putText(frame, label, (x + padding, text_y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
- cv2.putText(frame, value, (x + label_box_width + padding, text_y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
-
- timestamp = (datetime.now() + timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S")
- font = cv2.FONT_HERSHEY_SIMPLEX
- font_scale = 0.7
- thickness = 2
- (text_width, text_height), baseline = cv2.getTextSize(timestamp, font, font_scale, thickness)
- x, y = frame.shape[1] - text_width - 20, 30
- padding = 5
- box_coords = ((x - padding, y - text_height - padding), (x + text_width + padding, y + padding))
- cv2.rectangle(frame, box_coords[0], box_coords[1], (0, 0, 0), thickness=-1)
- cv2.putText(frame, timestamp, (x, y), font, font_scale, (255, 255, 255), thickness, cv2.LINE_AA)
-
-
- return frame
-
- def get_frame(self):
- with self.lock:
- if self.annotated_frame is not None:
- return self.annotated_frame.copy()
- return None
-
- def release(self):
- self.running = False
- if self.proc:
- self.proc.kill()
-
-class HLSStreamer:
- def __init__(self, video_capture, output_dir="hls_output", segment_time=7):
- self.cam = video_capture
- self.output_dir = Path(output_dir)
- self.segment_time = segment_time
- self.running = False
- self.ffmpeg_proc = None
-
- # Clean and create output directory
- if self.output_dir.exists():
- shutil.rmtree(self.output_dir)
- self.output_dir.mkdir()
-
- def _get_new_stream_dir(self):
- timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") # todo ios format
- stream_dir = self.output_dir / timestamp
- stream_dir.mkdir(exist_ok=True)
- return stream_dir
-
- def start(self):
- self.running = True
- self.current_stream_dir = self._get_new_stream_dir()
- # Start FFmpeg process for HLS streaming to local files
- '''
- ffmpeg_cmd = [
- "ffmpeg",
- "-stream_loop", "-1",
- "-i", "lofihiphop.mp3", # Audio input (looped)
- "-f", "rawvideo",
- "-pix_fmt", "bgr24",
- "-s", f"{self.cam.width}x{self.cam.height}",
- "-use_wallclock_as_timestamps", "1",
- "-fflags", "+genpts",
- "-i", "-", # Raw video from stdin
- "-c:v", "libx264",
- "-pix_fmt", "yuv420p",
- "-crf", "21",
- "-preset", "veryfast",
- "-g", str(30 * self.segment_time),
- "-c:a", "aac",
- "-b:a", "128k",
- "-ar", "44100",
- "-f", "hls",
- "-hls_time", str(self.segment_time),
- "-hls_list_size", "0",
- "-hls_flags", "delete_segments",
- "-hls_allow_cache", "0",
- str(self.current_stream_dir / "stream.m3u8")
- ]
- '''
-
-
- stream_url = "rtmp://a.rtmp.youtube.com/live2/aaaaaaaaaaa"
- ffmpeg_cmd = [
- "ffmpeg",
- "-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=44100",
- "-f", "rawvideo",
- "-pix_fmt", "bgr24",
- "-s", f"1280x720",
- "-r", "30",
- "-i", "-",
- "-c:v", "libx264",
- "-preset", "veryfast",
- "-tune", "zerolatency",
- "-pix_fmt", "yuv420p",
- "-crf", "21",
- "-g", str(30 * 7),
- "-c:a", "aac",
- "-b:a", "128k",
- "-ar", "44100",
- "-f", "flv",
- stream_url
- ]
-
-
- self.ffmpeg_proc = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE)
- threading.Thread(target=self._feed_frames, daemon=True).start()
-
- def _feed_frames(self):
- while self.running:
- frame = self.cam.get_frame()
- if frame is not None:
- try:
- self.ffmpeg_proc.stdin.write(frame.tobytes())
- except BrokenPipeError:
- print("FFmpeg process died, restarting...")
- self.start()
- return
- time.sleep(1/30) # Match the frame rate
-
- def stop(self):
- self.running = False
- if self.ffmpeg_proc:
- self.ffmpeg_proc.terminate()
- try:
- self.ffmpeg_proc.wait(timeout=5)
- except subprocess.TimeoutExpired:
- self.ffmpeg_proc.kill()
-
-class HLSRequestHandler(BaseHTTPRequestHandler):
- def __init__(self, *args, **kwargs):
- self.hls_dir = Path("hls_output")
- super().__init__(*args, **kwargs)
-
- def _get_latest_stream(self):
- """Find the most recent stream directory"""
- stream_dirs = list(self.hls_dir.glob("*"))
- if not stream_dirs:
- return None
- return max(stream_dirs, key=os.path.getmtime)
-
- def do_GET(self):
- if self.path == '/':
- # Serve a simple HTML page with a video player
- self.send_response(200)
- self.send_header('Content-type', 'text/html')
- self.end_headers()
-
- html = f"""
- <!DOCTYPE html>
- <html>
- <head>
- <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
- </head>
- <body>
- <video id="video" controls width="{self.server.cam.width}"></video>
- <script>
- if(Hls.isSupported()) {{
- var video = document.getElementById('video');
- var hls = new Hls();
- hls.loadSource('stream.m3u8');
- hls.attachMedia(video);
- hls.on(Hls.Events.MANIFEST_PARSED,function() {{
- video.play();
- }});
- }}
- else if (video.canPlayType('application/vnd.apple.mpegurl')) {{
- video.src = 'stream.m3u8';
- video.addEventListener('loadedmetadata',function() {{
- video.play();
- }});
- }}
- </script>
- </body>
- </html>
- """
- self.wfile.write(html.encode('utf-8'))
- return
-
-
- latest_dir = self._get_latest_stream()
- if not latest_dir:
- self.send_error(404)
- return
-
- file_path = latest_dir / self.path.lstrip('/')
- if not file_path.exists():
- self.send_error(404)
- return
-
- self.send_response(200)
- if file_path.suffix == '.m3u8':
- self.send_header('Content-Type', 'application/vnd.apple.mpegurl')
- self.send_header('Cache-Control', 'no-cache')
- elif file_path.suffix == '.ts':
- self.send_header('Content-Type', 'video/MP2T')
- self.end_headers()
-
- with open(file_path, 'rb') as f:
- shutil.copyfileobj(f, self.wfile)
-
-def schedule_daily_restart(hls_streamer, restart_time):
- """Schedule daily restarts at a specific time"""
- while True:
- now = datetime.now().time()
- target = time_obj(restart_time[0], restart_time[1]) # (hour, minute)
-
- # Calculate seconds until next restart
- if now >= target:
- # If time already passed today, schedule for tomorrow
- delta = (24 * 3600) - ((now.hour * 3600 + now.minute * 60 + now.second) - (target.hour * 3600 + target.minute * 60))
- else:
- delta = ((target.hour * 3600 + target.minute * 60) -
- (now.hour * 3600 + now.minute * 60 + now.second))
-
- print(f"Next stream restart scheduled in {delta//3600}h {(delta%3600)//60}m")
- time.sleep(delta)
-
- print("\nPerforming scheduled stream restart...")
- hls_streamer.stop()
- time.sleep(10) # todo can get away with none or less?
- hls_streamer.start()
-
-class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
- """Serve HTTP requests in separate threads."""
-
-if __name__ == "__main__":
- rtsp_url = sys.argv[1] if len(sys.argv) >= 2 else (print("No rtsp url given") or sys.exit(1))
- classes = {"0","1","2","3","5","7","15","16","24","26","67"}
-
- # Model initialization
- yolo_variant = sys.argv[2] if len(sys.argv) >= 3 else (print("No variant given, so choosing 'n' as the default. Yolov8 has different variants, you can choose from ['n', 's', 'm', 'l', 'x']") or 'n')
- depth, width, ratio = get_variant_multiples(yolo_variant)
- yolo_infer = YOLOv8(w=width, r=ratio, d=depth, num_classes=80)
- state_dict = safe_load(get_weights_location(yolo_variant))
- load_state_dict(yolo_infer, state_dict)
- class_labels = fetch('https://raw.githubusercontent.com/pjreddie/darknet/master/data/coco.names').read_text().split("\n")
- color_dict = {label: tuple((((i+1) * 50) % 256, ((i+1) * 100) % 256, ((i+1) * 150) % 256)) for i, label in enumerate(class_labels)}
-
- cam = VideoCapture(rtsp_url)
- hls_streamer = HLSStreamer(cam)
-
- try:
- server = ThreadedHTTPServer(('0.0.0.0', 8080), HLSRequestHandler)
- server.cam = cam # Pass camera reference to server
-
- hls_streamer.start()
-
- restart_time = (25, 0)
- scheduler = threading.Thread(
- target=schedule_daily_restart,
- args=(hls_streamer, restart_time),
- daemon=True
- )
- scheduler.start()
-
- print("\nServing HLS stream on:")
- print(f" - Web player: http://localhost:8080/")
- print(f" - HLS URL (for VLC): http://localhost:8080/stream.m3u8")
- print("\nPress Ctrl+C to stop...")
- server.serve_forever()
- except KeyboardInterrupt:
- print("\nShutting down...")
- hls_streamer.stop()
- cam.release()
- server.shutdown()
diff --git a/experimental/yolov8.py b/experimental/yolov8.py
deleted file mode 100644
index 07d2561..0000000
--- a/experimental/yolov8.py
+++ /dev/null
@@ -1,504 +0,0 @@
-from tinygrad.nn import Conv2d, BatchNorm2d
-from tinygrad.tensor import Tensor
-from tinygrad import TinyJit
-from tinygrad.device import is_dtype_supported
-from tinygrad import dtypes
-import numpy as np
-from itertools import chain
-from pathlib import Path
-import cv2
-from collections import defaultdict
-import time, sys
-from tinygrad.helpers import fetch
-from tinygrad.nn.state import safe_load, load_state_dict
-import json
-import struct
-from time import monotonic
-from uvicorn import Server, Config
-import asyncio
-from starlette.types import Receive, Send, Scope
-from starlette.responses import Response
-
-#Model architecture from https://github.com/ultralytics/ultralytics/issues/189
-#The upsampling class has been taken from this pull request https://github.com/tinygrad/tinygrad/pull/784 by dc-dc-dc. Now 2(?) models use upsampling. (retinet and this)
-
-#Pre processing image functions.
-def compute_transform(image, new_shape=(640, 640), auto=False, scaleFill=False, scaleup=True, stride=32) -> Tensor:
- shape = image.shape[:2] # current shape [height, width]
- new_shape = (new_shape, new_shape) if isinstance(new_shape, int) else new_shape
- r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
- r = min(r, 1.0) if not scaleup else r
- new_unpad = (int(round(shape[1] * r)), int(round(shape[0] * r)))
- dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
- dw, dh = (np.mod(dw, stride), np.mod(dh, stride)) if auto else (0.0, 0.0)
- new_unpad = (new_shape[1], new_shape[0]) if scaleFill else new_unpad
- dw /= 2
- dh /= 2
- image = cv2.resize(image, new_unpad, interpolation=cv2.INTER_LINEAR) if shape[::-1] != new_unpad else image
- top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
- left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
- image = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))
- return Tensor(image)
-
-def preprocess(im, imgsz=640, model_stride=32, model_pt=True):
- same_shapes = all(x.shape == im[0].shape for x in im)
- auto = same_shapes and model_pt
- im = [compute_transform(x, new_shape=imgsz, auto=auto, stride=model_stride) for x in im]
- im = Tensor.stack(*im) if len(im) > 1 else im[0].unsqueeze(0)
- im = im[..., ::-1].permute(0, 3, 1, 2) # BGR to RGB, BHWC to BCHW, (n, 3, h, w)
- im = im / 255.0 # 0 - 255 to 0.0 - 1.0
- return im
-
-# utility functions for forward pass.
-def dist2bbox(distance, anchor_points, xywh=True, dim=-1):
- lt, rb = distance.chunk(2, dim)
- x1y1 = anchor_points - lt
- x2y2 = anchor_points + rb
- if xywh:
- c_xy = (x1y1 + x2y2) / 2
- wh = x2y2 - x1y1
- return c_xy.cat(wh, dim=1)
- return x1y1.cat(x2y2, dim=1)
-
-def make_anchors(feats, strides, grid_cell_offset=0.5):
- anchor_points, stride_tensor = [], []
- assert feats is not None
- for i, stride in enumerate(strides):
- _, _, h, w = feats[i].shape
- sx = Tensor.arange(w) + grid_cell_offset
- sy = Tensor.arange(h) + grid_cell_offset
-
- # this is np.meshgrid but in tinygrad
- sx = sx.reshape(1, -1).repeat([h, 1]).reshape(-1)
- sy = sy.reshape(-1, 1).repeat([1, w]).reshape(-1)
-
- anchor_points.append(Tensor.stack(sx, sy, dim=-1).reshape(-1, 2))
- stride_tensor.append(Tensor.full((h * w), stride))
- anchor_points = anchor_points[0].cat(anchor_points[1], anchor_points[2])
- stride_tensor = stride_tensor[0].cat(stride_tensor[1], stride_tensor[2]).unsqueeze(1)
- return anchor_points, stride_tensor
-
-# this function is from the original implementation
-def autopad(k, p=None, d=1): # kernel, padding, dilation
- if d > 1:
- k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k] # actual kernel-size
- if p is None:
- p = k // 2 if isinstance(k, int) else [x // 2 for x in k] # auto-pad
- return p
-
-def clip_boxes(boxes, shape):
- boxes[..., [0, 2]] = np.clip(boxes[..., [0, 2]], 0, shape[1]) # x1, x2
- boxes[..., [1, 3]] = np.clip(boxes[..., [1, 3]], 0, shape[0]) # y1, y2
- return boxes
-
-def scale_boxes(img1_shape, predictions, img0_shape, ratio_pad=None):
- gain = ratio_pad if ratio_pad else min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])
- pad = ((img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2)
- for pred in predictions:
- boxes_np = pred[:4].numpy() if isinstance(pred[:4], Tensor) else pred[:4]
- boxes_np[..., [0, 2]] -= pad[0]
- boxes_np[..., [1, 3]] -= pad[1]
- boxes_np[..., :4] /= gain
- boxes_np = clip_boxes(boxes_np, img0_shape)
- pred[:4] = boxes_np
- return predictions
-
-def get_variant_multiples(variant):
- return {'n':(0.33, 0.25, 2.0), 's':(0.33, 0.50, 2.0), 'm':(0.67, 0.75, 1.5), 'l':(1.0, 1.0, 1.0), 'x':(1, 1.25, 1.0) }.get(variant, None)
-
-def label_predictions(all_predictions):
- class_index_count = defaultdict(int)
- for pred in all_predictions:
- class_id = int(pred[-1])
- if pred[-2] != 0: class_index_count[class_id] += 1
-
- return dict(class_index_count)
-
-#this is taken from https://github.com/tinygrad/tinygrad/pull/784/files by dc-dc-dc (Now 2 models use upsampling)
-class Upsample:
- def __init__(self, scale_factor:int, mode: str = "nearest") -> None:
- assert mode == "nearest" # only mode supported for now
- self.mode = mode
- self.scale_factor = scale_factor
-
- def __call__(self, x: Tensor) -> Tensor:
- assert len(x.shape) > 2 and len(x.shape) <= 5
- (b, c), _lens = x.shape[:2], len(x.shape[2:])
- tmp = x.reshape([b, c, -1] + [1] * _lens) * Tensor.ones(*[1, 1, 1] + [self.scale_factor] * _lens)
- return tmp.reshape(list(x.shape) + [self.scale_factor] * _lens).permute([0, 1] + list(chain.from_iterable([[y+2, y+2+_lens] for y in range(_lens)]))).reshape([b, c] + [x * self.scale_factor for x in x.shape[2:]])
-
-class Conv_Block:
- def __init__(self, c1, c2, kernel_size=1, stride=1, groups=1, dilation=1, padding=None):
- self.conv = Conv2d(c1,c2, kernel_size, stride, padding=autopad(kernel_size, padding, dilation), bias=False, groups=groups, dilation=dilation)
- self.bn = BatchNorm2d(c2, eps=0.001)
-
- def __call__(self, x):
- return self.bn(self.conv(x)).silu()
-
-class Bottleneck:
- def __init__(self, c1, c2 , shortcut: bool, g=1, kernels: list = (3,3), channel_factor=0.5):
- c_ = int(c2 * channel_factor)
- self.cv1 = Conv_Block(c1, c_, kernel_size=kernels[0], stride=1, padding=None)
- self.cv2 = Conv_Block(c_, c2, kernel_size=kernels[1], stride=1, padding=None, groups=g)
- self.residual = c1 == c2 and shortcut
-
- def __call__(self, x):
- return x + self.cv2(self.cv1(x)) if self.residual else self.cv2(self.cv1(x))
-
-class C2f:
- def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
- self.c = int(c2 * e)
- self.cv1 = Conv_Block(c1, 2 * self.c, 1,)
- self.cv2 = Conv_Block((2 + n) * self.c, c2, 1)
- self.bottleneck = [Bottleneck(self.c, self.c, shortcut, g, kernels=[(3, 3), (3, 3)], channel_factor=1.0) for _ in range(n)]
-
- def __call__(self, x):
- y= list(self.cv1(x).chunk(2, 1))
- y.extend(m(y[-1]) for m in self.bottleneck)
- z = y[0]
- for i in y[1:]: z = z.cat(i, dim=1)
- return self.cv2(z)
-
-class SPPF:
- def __init__(self, c1, c2, k=5):
- c_ = c1 // 2 # hidden channels
- self.cv1 = Conv_Block(c1, c_, 1, 1, padding=None)
- self.cv2 = Conv_Block(c_ * 4, c2, 1, 1, padding=None)
-
- # TODO: this pads with 0s, whereas torch function pads with -infinity. This results in a < 2% difference in prediction which does not make a difference visually.
- self.maxpool = lambda x : x.pad((k // 2, k // 2, k // 2, k // 2)).max_pool2d(kernel_size=k, stride=1)
-
- def __call__(self, x):
- x = self.cv1(x)
- x2 = self.maxpool(x)
- x3 = self.maxpool(x2)
- x4 = self.maxpool(x3)
- return self.cv2(x.cat(x2, x3, x4, dim=1))
-
-class DFL:
- def __init__(self, c1=16):
- self.conv = Conv2d(c1, 1, 1, bias=False)
- x = Tensor.arange(c1)
- self.conv.weight.replace(x.reshape(1, c1, 1, 1))
- self.c1 = c1
-
- def __call__(self, x):
- b, c, a = x.shape # batch, channels, anchors
- return self.conv(x.reshape(b, 4, self.c1, a).transpose(2, 1).softmax(1)).reshape(b, 4, a)
-
-#backbone
-class Darknet:
- def __init__(self, w, r, d):
- self.b1 = [Conv_Block(c1=3, c2= int(64*w), kernel_size=3, stride=2, padding=1), Conv_Block(int(64*w), int(128*w), kernel_size=3, stride=2, padding=1)]
- self.b2 = [C2f(c1=int(128*w), c2=int(128*w), n=round(3*d), shortcut=True), Conv_Block(int(128*w), int(256*w), 3, 2, 1), C2f(int(256*w), int(256*w), round(6*d), True)]
- self.b3 = [Conv_Block(int(256*w), int(512*w), kernel_size=3, stride=2, padding=1), C2f(int(512*w), int(512*w), round(6*d), True)]
- self.b4 = [Conv_Block(int(512*w), int(512*w*r), kernel_size=3, stride=2, padding=1), C2f(int(512*w*r), int(512*w*r), round(3*d), True)]
- self.b5 = [SPPF(int(512*w*r), int(512*w*r), 5)]
-
- def return_modules(self):
- return [*self.b1, *self.b2, *self.b3, *self.b4, *self.b5]
-
- def __call__(self, x):
- x1 = x.sequential(self.b1)
- x2 = x1.sequential(self.b2)
- x3 = x2.sequential(self.b3)
- x4 = x3.sequential(self.b4)
- x5 = x4.sequential(self.b5)
- return (x2, x3, x5)
-
-#yolo fpn (neck)
-class Yolov8NECK:
- def __init__(self, w, r, d): #width_multiple, ratio_multiple, depth_multiple
- self.up = Upsample(2, mode='nearest')
- self.n1 = C2f(c1=int(512*w*(1+r)), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n2 = C2f(c1=int(768*w), c2=int(256*w), n=round(3*d), shortcut=False)
- self.n3 = Conv_Block(c1=int(256*w), c2=int(256*w), kernel_size=3, stride=2, padding=1)
- self.n4 = C2f(c1=int(768*w), c2=int(512*w), n=round(3*d), shortcut=False)
- self.n5 = Conv_Block(c1=int(512* w), c2=int(512 * w), kernel_size=3, stride=2, padding=1)
- self.n6 = C2f(c1=int(512*w*(1+r)), c2=int(512*w*r), n=round(3*d), shortcut=False)
-
- def return_modules(self):
- return [self.n1, self.n2, self.n3, self.n4, self.n5, self.n6]
-
- def __call__(self, p3, p4, p5):
- x = self.n1(self.up(p5).cat(p4, dim=1))
- head_1 = self.n2(self.up(x).cat(p3, dim=1))
- head_2 = self.n4(self.n3(head_1).cat(x, dim=1))
- head_3 = self.n6(self.n5(head_2).cat(p5, dim=1))
- return [head_1, head_2, head_3]
-
-#task specific head.
-class DetectionHead:
- def __init__(self, nc=80, filters=()):
- self.ch = 16
- self.nc = nc # number of classes
- self.nl = len(filters)
- self.no = nc + self.ch * 4 #
- self.stride = [8, 16, 32]
- c1 = max(filters[0], self.nc)
- c2 = max((filters[0] // 4, self.ch * 4))
- self.dfl = DFL(self.ch)
- self.cv3 = [[Conv_Block(x, c1, 3), Conv_Block(c1, c1, 3), Conv2d(c1, self.nc, 1)] for x in filters]
- self.cv2 = [[Conv_Block(x, c2, 3), Conv_Block(c2, c2, 3), Conv2d(c2, 4 * self.ch, 1)] for x in filters]
-
- def __call__(self, x):
- for i in range(self.nl):
- x[i] = (x[i].sequential(self.cv2[i]).cat(x[i].sequential(self.cv3[i]), dim=1))
- self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
- y = [(i.reshape(x[0].shape[0], self.no, -1)) for i in x]
- x_cat = y[0].cat(y[1], y[2], dim=2)
- box, cls = x_cat[:, :self.ch * 4], x_cat[:, self.ch * 4:]
- dbox = dist2bbox(self.dfl(box), self.anchors.unsqueeze(0), xywh=True, dim=1) * self.strides
- z = dbox.cat(cls.sigmoid(), dim=1)
- return z
-
-class YOLOv8:
- def __init__(self, w, r, d, num_classes): #width_multiple, ratio_multiple, depth_multiple
- self.net = Darknet(w, r, d)
- self.fpn = Yolov8NECK(w, r, d)
- self.head = DetectionHead(num_classes, filters=(int(256*w), int(512*w), int(512*w*r)))
-
- def __call__(self, x):
- x = self.net(x)
- x = self.fpn(*x)
- x = self.head(x)
- # TODO: postprocess needs to be in the model to be compiled to webgpu
- return postprocess(x)
-
- def return_all_trainable_modules(self):
- backbone_modules = [*range(10)]
- yolov8neck_modules = [12, 15, 16, 18, 19, 21]
- yolov8_head_weights = [(22, self.head)]
- return [*zip(backbone_modules, self.net.return_modules()), *zip(yolov8neck_modules, self.fpn.return_modules()), *yolov8_head_weights]
-
-def convert_f16_safetensor_to_f32(input_file: Path, output_file: Path):
- with open(input_file, 'rb') as f:
- metadata_length = int.from_bytes(f.read(8), 'little')
- metadata = json.loads(f.read(metadata_length).decode())
- float32_values = np.fromfile(f, dtype=np.float16).astype(np.float32)
-
- for v in metadata.values():
- if v["dtype"] == "F16": v.update({"dtype": "F32", "data_offsets": [offset * 2 for offset in v["data_offsets"]]})
-
- with open(output_file, 'wb') as f:
- new_metadata_bytes = json.dumps(metadata).encode()
- f.write(len(new_metadata_bytes).to_bytes(8, 'little'))
- f.write(new_metadata_bytes)
- float32_values.tofile(f)
-
-def compute_iou_matrix(boxes):
- x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
- areas = (x2 - x1) * (y2 - y1)
- x1 = Tensor.maximum(x1[:, None], x1[None, :])
- y1 = Tensor.maximum(y1[:, None], y1[None, :])
- x2 = Tensor.minimum(x2[:, None], x2[None, :])
- y2 = Tensor.minimum(y2[:, None], y2[None, :])
- w = Tensor.maximum(Tensor(0), x2 - x1)
- h = Tensor.maximum(Tensor(0), y2 - y1)
- intersection = w * h
- union = areas[:, None] + areas[None, :] - intersection
- return intersection / union
-
-def postprocess(output, max_det=300, conf_threshold=0.25, iou_threshold=0.45):
- xc, yc, w, h, class_scores = output[0][0], output[0][1], output[0][2], output[0][3], output[0][4:]
- class_ids = Tensor.argmax(class_scores, axis=0)
- probs = Tensor.max(class_scores, axis=0)
- probs = Tensor.where(probs >= conf_threshold, probs, 0)
- x1 = xc - w / 2
- y1 = yc - h / 2
- x2 = xc + w / 2
- y2 = yc + h / 2
- boxes = Tensor.stack(x1, y1, x2, y2, probs, class_ids, dim=1)
- order = Tensor.topk(probs, max_det)[1]
- boxes = boxes[order]
- iou = compute_iou_matrix(boxes[:, :4])
- iou = Tensor.triu(iou, diagonal=1)
- same_class_mask = boxes[:, -1][:, None] == boxes[:, -1][None, :]
- high_iou_mask = (iou > iou_threshold) & same_class_mask
- no_overlap_mask = high_iou_mask.sum(axis=0) == 0
- boxes = boxes * no_overlap_mask.unsqueeze(-1)
- return boxes
-
-def get_weights_location(yolo_variant: str) -> Path:
- weights_location = Path(__file__).parents[1] / "weights" / f'yolov8{yolo_variant}.safetensors'
- fetch(f'https://gitlab.com/r3sist/yolov8_weights/-/raw/master/yolov8{yolo_variant}.safetensors', weights_location)
- #f16
- return weights_location.with_name(f"{weights_location.stem}.safetensors")
- f32_weights = weights_location.with_name(f"{weights_location.stem}_f32.safetensors")
- if not f32_weights.exists(): convert_f16_safetensor_to_f32(weights_location, f32_weights)
- return f32_weights
-
-@TinyJit
-def do_inf(image):
- image = image.reshape(1, 640, 640, 3)
- image = image[..., ::-1].permute(0, 3, 1, 2)
- image = image / 255.0
- predictions = yolo_infer(image)
- return predictions.flatten()
-
-# Model initialization (same as before)
-import uuid
-from typing import Optional, Dict
-import struct
-
-class ASGIApp:
- def __init__(self, yolo_res=640):
- self.yolo_res = yolo_res
- self.session_images: Dict[str, bytearray] = {}
-
- async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
- path = scope.get("path")
- method = scope.get("method")
-
- if method != "POST":
- await self.send_not_found(send)
- return
-
- # Read full request body
- body = b""
- more_body = True
- while more_body:
- message = await receive()
- body += message.get("body", b"")
- more_body = message.get("more_body", False)
-
- headers = dict(scope.get("headers", [])) # List of (key, value) tuples
-
- if path == "/yolo":
- session_id = headers.get(b"x-session-id")
- await self.handle_yolo(body, send, session_id)
-
- elif path == "/diff":
- session_id = headers.get(b"x-session-id")
- await self.handle_diff(body, send, session_id)
-
- else:
- await self.send_not_found(send)
-
- async def handle_yolo(self, body: bytes, send: Send, session_id: Optional[bytes]):
- if session_id is None:
- # Create new session
- session_id = str(uuid.uuid4()).encode()
- self.session_images[session_id] = bytearray(body)
- else:
- self.session_images[session_id] = bytearray(body)
-
- im = Tensor(body, dtype=dtypes.uint8)
- pred = do_inf(im).numpy()
- response_data = struct.pack('<1800f', *pred)
-
- headers = [
- (b"content-type", b"application/octet-stream"),
- (b"content-length", str(len(response_data)).encode()),
- (b"x-session-id", session_id)
- ]
- await self.send_with_headers(send, response_data, headers)
-
- async def handle_diff(self, body: bytes, send: Send, session_id: Optional[bytes]):
- if session_id is None or session_id not in self.session_images:
- await self.send_response(send, b"", status=400, content_type=b"text/plain", message=b"Invalid or missing session ID")
- return
-
- img = bytearray(self.session_images[session_id]) # Copy previous image
-
- i = 0
- while i + 5 <= len(body):
- index = struct.unpack_from("<i", body, i)[0]
- value = body[i + 4]
- if 0 <= index < len(img):
- img[index] = value
- i += 5
-
- im = Tensor(bytes(img), dtype=dtypes.uint8)
- pred = do_inf(im).numpy()
- response_data = struct.pack('<1800f', *pred)
-
- self.session_images[session_id] = img
- await self.send_response(send, response_data)
-
- async def send_response(self, send: Send, body: bytes, status: int = 200,
- content_type: bytes = b"application/octet-stream",
- message: Optional[bytes] = None):
- headers = [
- (b"content-type", content_type),
- (b"content-length", str(len(body)).encode())
- ]
- await send({
- "type": "http.response.start",
- "status": status,
- "headers": headers,
- })
- await send({"type": "http.response.body", "body": message or body})
-
- async def send_with_headers(self, send: Send, body: bytes, headers: list):
- await send({
- "type": "http.response.start",
- "status": 200,
- "headers": headers,
- })
- await send({"type": "http.response.body", "body": body})
-
- async def send_not_found(self, send: Send):
- await send({
- "type": "http.response.start",
- "status": 404,
- "headers": [(b"content-type", b"text/plain")],
- })
- await send({"type": "http.response.body", "body": b"Not Found"})
-
-if __name__ == "__main__":
- yolo_variant = sys.argv[1] if len(sys.argv) >= 2 else (print("No variant given, so choosing 'n' as the default. Yolov8 has different variants, you can choose from ['n', 's', 'm', 'l', 'x']") or 'n')
- depth, width, ratio = get_variant_multiples(yolo_variant)
- yolo_infer = YOLOv8(w=width, r=ratio, d=depth, num_classes=80)
- state_dict = safe_load(get_weights_location(yolo_variant))
- load_state_dict(yolo_infer, state_dict)
- app = ASGIApp()
- config = Config(app=app, host="0.0.0.0", port=6667, workers=1)
- server = Server(config)
- asyncio.run(server.serve())
-
-''' todo, slow with no external deps for now
-from http.server import HTTPServer, BaseHTTPRequestHandler
-import struct
-
-@TinyJit
-def do_inf(image):
- image = image.reshape(1, 640, 640, 3)
- image = image[..., ::-1].permute(0, 3, 1, 2)
- image = image / 255.0
- predictions = yolo_infer(image)
- return predictions.flatten()
-
-yolo_variant = 'n'
-depth, width, ratio = get_variant_multiples(yolo_variant)
-yolo_infer = YOLOv8(w=width, r=ratio, d=depth, num_classes=80)
-state_dict = safe_load(get_weights_location(yolo_variant))
-load_state_dict(yolo_infer, state_dict)
-
-class YOLORequestHandler(BaseHTTPRequestHandler):
- def do_POST(self):
- if self.path != "/yolo":
- self.send_response(404)
- self.end_headers()
- self.wfile.write(b"Not Found")
- return
-
- content_length = int(self.headers.get('Content-Length', 0))
- img = self.rfile.read(content_length)
-
- im = Tensor(img, dtype=dtypes.uint8)
- pred = do_inf(im).numpy()
- response_data = struct.pack('<1800f', *pred)
-
- self.send_response(200)
- self.send_header('Content-Type', 'application/octet-stream')
- self.send_header('Content-Length', str(len(response_data)))
- self.end_headers()
- self.wfile.write(response_data)
-
-if __name__ == '__main__':
- server_address = ('0.0.0.0', 6667)
- httpd = HTTPServer(server_address, YOLORequestHandler)
- print("Serving YOLO on http://0.0.0.0:6667")
- httpd.serve_forever()
-'''
diff --git a/experimental/yolox/.DS_Store b/experimental/yolox/.DS_Store
deleted file mode 100644
index 7e85cb6..0000000
Binary files a/experimental/yolox/.DS_Store and /dev/null differ
diff --git a/experimental/yolox/tracker/basetrack.py b/experimental/yolox/tracker/basetrack.py
deleted file mode 100644
index 4fe2233..0000000
--- a/experimental/yolox/tracker/basetrack.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import numpy as np
-from collections import OrderedDict
-
-
-class TrackState(object):
- New = 0
- Tracked = 1
- Lost = 2
- Removed = 3
-
-
-class BaseTrack(object):
- _count = 0
-
- track_id = 0
- is_activated = False
- state = TrackState.New
-
- history = OrderedDict()
- features = []
- curr_feature = None
- score = 0
- start_frame = 0
- frame_id = 0
- time_since_update = 0
-
- # multi-camera
- location = (np.inf, np.inf)
-
- @property
- def end_frame(self):
- return self.frame_id
-
- @staticmethod
- def next_id():
- BaseTrack._count += 1
- return BaseTrack._count
-
- def activate(self, *args):
- raise NotImplementedError
-
- def predict(self):
- raise NotImplementedError
-
- def update(self, *args, **kwargs):
- raise NotImplementedError
-
- def mark_lost(self):
- self.state = TrackState.Lost
-
- def mark_removed(self):
- self.state = TrackState.Removed
diff --git a/experimental/yolox/tracker/byte_tracker.py b/experimental/yolox/tracker/byte_tracker.py
deleted file mode 100644
index dd8c9a9..0000000
--- a/experimental/yolox/tracker/byte_tracker.py
+++ /dev/null
@@ -1,325 +0,0 @@
-import numpy as np
-
-from .kalman_filter import KalmanFilter
-from yolox.tracker import matching
-from .basetrack import BaseTrack, TrackState
-
-class STrack(BaseTrack):
- shared_kalman = KalmanFilter()
- def __init__(self, tlwh, score, class_id):
-
- # wait activate
- self._tlwh = np.asarray(tlwh, dtype=np.float64)
- self.kalman_filter = None
- self.mean, self.covariance = None, None
- self.is_activated = False
-
- self.score = score
- self.class_id = class_id
- self.tracklet_len = 0
-
- def predict(self):
- mean_state = self.mean.copy()
- if self.state != TrackState.Tracked:
- mean_state[7] = 0
- self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
-
- @staticmethod
- def multi_predict(stracks):
- if len(stracks) > 0:
- multi_mean = np.asarray([st.mean.copy() for st in stracks])
- multi_covariance = np.asarray([st.covariance for st in stracks])
- for i, st in enumerate(stracks):
- if st.state != TrackState.Tracked:
- multi_mean[i][7] = 0
- multi_mean, multi_covariance = STrack.shared_kalman.multi_predict(multi_mean, multi_covariance)
- for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
- stracks[i].mean = mean
- stracks[i].covariance = cov
-
- def activate(self, kalman_filter, frame_id):
- """Start a new tracklet"""
- self.kalman_filter = kalman_filter
- self.track_id = self.next_id()
- self.mean, self.covariance = self.kalman_filter.initiate(self.tlwh_to_xyah(self._tlwh))
-
- self.tracklet_len = 0
- self.state = TrackState.Tracked
- if frame_id == 1:
- self.is_activated = True
- # self.is_activated = True
- self.frame_id = frame_id
- self.start_frame = frame_id
-
- def re_activate(self, new_track, frame_id, new_id=False):
- self.mean, self.covariance = self.kalman_filter.update(
- self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh)
- )
- self.tracklet_len = 0
- self.state = TrackState.Tracked
- self.is_activated = True
- self.frame_id = frame_id
- if new_id:
- self.track_id = self.next_id()
- self.score = new_track.score
-
- def update(self, new_track, frame_id):
- """
- Update a matched track
- :type new_track: STrack
- :type frame_id: int
- :type update_feature: bool
- :return:
- """
- self.frame_id = frame_id
- self.tracklet_len += 1
-
- new_tlwh = new_track.tlwh
- self.mean, self.covariance = self.kalman_filter.update(
- self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh))
- self.state = TrackState.Tracked
- self.is_activated = True
-
- self.score = new_track.score
- self.class_id = new_track.class_id
-
- @property
- # @jit(nopython=True)
- def tlwh(self):
- """Get current position in bounding box format `(top left x, top left y,
- width, height)`.
- """
- if self.mean is None:
- return self._tlwh.copy()
- ret = self.mean[:4].copy()
- ret[2] *= ret[3]
- ret[:2] -= ret[2:] / 2
- return ret
-
- @property
- # @jit(nopython=True)
- def tlbr(self):
- """Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
- `(top left, bottom right)`.
- """
- ret = self.tlwh.copy()
- ret[2:] += ret[:2]
- return ret
-
- @staticmethod
- # @jit(nopython=True)
- def tlwh_to_xyah(tlwh):
- """Convert bounding box to format `(center x, center y, aspect ratio,
- height)`, where the aspect ratio is `width / height`.
- """
- ret = np.asarray(tlwh).copy()
- ret[:2] += ret[2:] / 2
- ret[2] /= ret[3]
- return ret
-
- def to_xyah(self):
- return self.tlwh_to_xyah(self.tlwh)
-
- @staticmethod
- # @jit(nopython=True)
- def tlbr_to_tlwh(tlbr):
- ret = np.asarray(tlbr).copy()
- ret[2:] -= ret[:2]
- return ret
-
- @staticmethod
- # @jit(nopython=True)
- def tlwh_to_tlbr(tlwh):
- ret = np.asarray(tlwh).copy()
- ret[2:] += ret[:2]
- return ret
-
- def __repr__(self):
- return 'OT_{}_({}-{})'.format(self.track_id, self.start_frame, self.end_frame)
-
-
-class BYTETracker(object):
- def __init__(self, args, frame_rate=30):
- self.tracked_stracks = [] # type: list[STrack]
- self.lost_stracks = [] # type: list[STrack]
- self.removed_stracks = [] # type: list[STrack]
-
- self.frame_id = 0
- self.args = args
- #self.det_thresh = args.track_thresh
- self.det_thresh = args.track_thresh + 0.1
- self.buffer_size = int(frame_rate / 30.0 * args.track_buffer)
- self.max_time_lost = self.buffer_size
- self.kalman_filter = KalmanFilter()
-
- def update(self, output_results, img_info, img_size):
- self.frame_id += 1
- activated_starcks = []
- refind_stracks = []
- lost_stracks = []
- removed_stracks = []
-
- classes = output_results[:, 5]
- scores = output_results[:, 4]
- bboxes = output_results[:, :4]
-
- img_h, img_w = img_info[0], img_info[1]
- scale = min(img_size[0] / float(img_h), img_size[1] / float(img_w))
- bboxes /= scale
-
- remain_inds = scores > self.args.track_thresh
- inds_low = scores > 0.1
- inds_high = scores < self.args.track_thresh
-
- inds_second = np.logical_and(inds_low, inds_high)
- dets_second = bboxes[inds_second]
- dets = bboxes[remain_inds]
- scores_keep = scores[remain_inds]
- scores_second = scores[inds_second]
- classes_keep = classes[remain_inds]
- classes_second = classes[inds_second]
-
- if len(dets) > 0:
- '''Detections'''
- detections = [STrack(STrack.tlbr_to_tlwh(tlbr), s, c) for
- (tlbr, s, c) in zip(dets, scores_keep, classes_keep)]
- else:
- detections = []
-
- ''' Add newly detected tracklets to tracked_stracks'''
- unconfirmed = []
- tracked_stracks = [] # type: list[STrack]
- for track in self.tracked_stracks:
- if not track.is_activated:
- unconfirmed.append(track)
- else:
- tracked_stracks.append(track)
-
- ''' Step 2: First association, with high score detection boxes'''
- strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
- # Predict the current location with KF
- STrack.multi_predict(strack_pool)
- dists = matching.iou_distance(strack_pool, detections)
- if not self.args.mot20:
- dists = matching.fuse_score(dists, detections)
- matches, u_track, u_detection = matching.linear_assignment(dists, thresh=self.args.match_thresh)
-
- for itracked, idet in matches:
- track = strack_pool[itracked]
- det = detections[idet]
- if track.state == TrackState.Tracked:
- track.update(detections[idet], self.frame_id)
- activated_starcks.append(track)
- else:
- track.re_activate(det, self.frame_id, new_id=False)
- refind_stracks.append(track)
-
- ''' Step 3: Second association, with low score detection boxes'''
- # association the untrack to the low score detections
- if len(dets_second) > 0:
- '''Detections'''
- detections_second = [STrack(STrack.tlbr_to_tlwh(tlbr), s, c) for
- (tlbr, s, c) in zip(dets_second, scores_second, classes_second)]
- else:
- detections_second = []
- r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
- dists = matching.iou_distance(r_tracked_stracks, detections_second)
- matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)
- for itracked, idet in matches:
- track = r_tracked_stracks[itracked]
- det = detections_second[idet]
- if track.state == TrackState.Tracked:
- track.update(det, self.frame_id)
- activated_starcks.append(track)
- else:
- track.re_activate(det, self.frame_id, new_id=False)
- refind_stracks.append(track)
-
- for it in u_track:
- track = r_tracked_stracks[it]
- if not track.state == TrackState.Lost:
- track.mark_lost()
- lost_stracks.append(track)
-
- '''Deal with unconfirmed tracks, usually tracks with only one beginning frame'''
- detections = [detections[i] for i in u_detection]
- dists = matching.iou_distance(unconfirmed, detections)
- if not self.args.mot20:
- dists = matching.fuse_score(dists, detections)
- matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.7)
- for itracked, idet in matches:
- unconfirmed[itracked].update(detections[idet], self.frame_id)
- activated_starcks.append(unconfirmed[itracked])
- for it in u_unconfirmed:
- track = unconfirmed[it]
- track.mark_removed()
- removed_stracks.append(track)
-
- """ Step 4: Init new stracks"""
- for inew in u_detection:
- track = detections[inew]
- if track.score < self.det_thresh:
- continue
- track.activate(self.kalman_filter, self.frame_id)
- activated_starcks.append(track)
- """ Step 5: Update state"""
- for track in self.lost_stracks:
- if self.frame_id - track.end_frame > self.max_time_lost:
- track.mark_removed()
- removed_stracks.append(track)
-
- # print('Ramained match {} s'.format(t4-t3))
-
- self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
- self.tracked_stracks = joint_stracks(self.tracked_stracks, activated_starcks)
- self.tracked_stracks = joint_stracks(self.tracked_stracks, refind_stracks)
- self.lost_stracks = sub_stracks(self.lost_stracks, self.tracked_stracks)
- self.lost_stracks.extend(lost_stracks)
- self.lost_stracks = sub_stracks(self.lost_stracks, self.removed_stracks)
- self.removed_stracks.extend(removed_stracks)
- self.tracked_stracks, self.lost_stracks = remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
- # get scores of lost tracks
- output_stracks = [track for track in self.tracked_stracks if track.is_activated]
-
- return output_stracks
-
-
-def joint_stracks(tlista, tlistb):
- exists = {}
- res = []
- for t in tlista:
- exists[t.track_id] = 1
- res.append(t)
- for t in tlistb:
- tid = t.track_id
- if not exists.get(tid, 0):
- exists[tid] = 1
- res.append(t)
- return res
-
-
-def sub_stracks(tlista, tlistb):
- stracks = {}
- for t in tlista:
- stracks[t.track_id] = t
- for t in tlistb:
- tid = t.track_id
- if stracks.get(tid, 0):
- del stracks[tid]
- return list(stracks.values())
-
-
-def remove_duplicate_stracks(stracksa, stracksb):
- pdist = matching.iou_distance(stracksa, stracksb)
- pairs = np.where(pdist < 0.15)
- dupa, dupb = list(), list()
- for p, q in zip(*pairs):
- timep = stracksa[p].frame_id - stracksa[p].start_frame
- timeq = stracksb[q].frame_id - stracksb[q].start_frame
- if timep > timeq:
- dupb.append(q)
- else:
- dupa.append(p)
- resa = [t for i, t in enumerate(stracksa) if not i in dupa]
- resb = [t for i, t in enumerate(stracksb) if not i in dupb]
- return resa, resb
diff --git a/experimental/yolox/tracker/kalman_filter.py b/experimental/yolox/tracker/kalman_filter.py
deleted file mode 100644
index deda8a2..0000000
--- a/experimental/yolox/tracker/kalman_filter.py
+++ /dev/null
@@ -1,270 +0,0 @@
-# vim: expandtab:ts=4:sw=4
-import numpy as np
-import scipy.linalg
-
-
-"""
-Table for the 0.95 quantile of the chi-square distribution with N degrees of
-freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv
-function and used as Mahalanobis gating threshold.
-"""
-chi2inv95 = {
- 1: 3.8415,
- 2: 5.9915,
- 3: 7.8147,
- 4: 9.4877,
- 5: 11.070,
- 6: 12.592,
- 7: 14.067,
- 8: 15.507,
- 9: 16.919}
-
-
-class KalmanFilter(object):
- """
- A simple Kalman filter for tracking bounding boxes in image space.
-
- The 8-dimensional state space
-
- x, y, a, h, vx, vy, va, vh
-
- contains the bounding box center position (x, y), aspect ratio a, height h,
- and their respective velocities.
-
- Object motion follows a constant velocity model. The bounding box location
- (x, y, a, h) is taken as direct observation of the state space (linear
- observation model).
-
- """
-
- def __init__(self):
- ndim, dt = 4, 1.
-
- # Create Kalman filter model matrices.
- self._motion_mat = np.eye(2 * ndim, 2 * ndim)
- for i in range(ndim):
- self._motion_mat[i, ndim + i] = dt
- self._update_mat = np.eye(ndim, 2 * ndim)
-
- # Motion and observation uncertainty are chosen relative to the current
- # state estimate. These weights control the amount of uncertainty in
- # the model. This is a bit hacky.
- self._std_weight_position = 1. / 20
- self._std_weight_velocity = 1. / 160
-
- def initiate(self, measurement):
- """Create track from unassociated measurement.
-
- Parameters
- ----------
- measurement : ndarray
- Bounding box coordinates (x, y, a, h) with center position (x, y),
- aspect ratio a, and height h.
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the mean vector (8 dimensional) and covariance matrix (8x8
- dimensional) of the new track. Unobserved velocities are initialized
- to 0 mean.
-
- """
- mean_pos = measurement
- mean_vel = np.zeros_like(mean_pos)
- mean = np.r_[mean_pos, mean_vel]
-
- std = [
- 2 * self._std_weight_position * measurement[3],
- 2 * self._std_weight_position * measurement[3],
- 1e-2,
- 2 * self._std_weight_position * measurement[3],
- 10 * self._std_weight_velocity * measurement[3],
- 10 * self._std_weight_velocity * measurement[3],
- 1e-5,
- 10 * self._std_weight_velocity * measurement[3]]
- covariance = np.diag(np.square(std))
- return mean, covariance
-
- def predict(self, mean, covariance):
- """Run Kalman filter prediction step.
-
- Parameters
- ----------
- mean : ndarray
- The 8 dimensional mean vector of the object state at the previous
- time step.
- covariance : ndarray
- The 8x8 dimensional covariance matrix of the object state at the
- previous time step.
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the mean vector and covariance matrix of the predicted
- state. Unobserved velocities are initialized to 0 mean.
-
- """
- std_pos = [
- self._std_weight_position * mean[3],
- self._std_weight_position * mean[3],
- 1e-2,
- self._std_weight_position * mean[3]]
- std_vel = [
- self._std_weight_velocity * mean[3],
- self._std_weight_velocity * mean[3],
- 1e-5,
- self._std_weight_velocity * mean[3]]
- motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
-
- #mean = np.dot(self._motion_mat, mean)
- mean = np.dot(mean, self._motion_mat.T)
- covariance = np.linalg.multi_dot((
- self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
-
- return mean, covariance
-
- def project(self, mean, covariance):
- """Project state distribution to measurement space.
-
- Parameters
- ----------
- mean : ndarray
- The state's mean vector (8 dimensional array).
- covariance : ndarray
- The state's covariance matrix (8x8 dimensional).
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the projected mean and covariance matrix of the given state
- estimate.
-
- """
- std = [
- self._std_weight_position * mean[3],
- self._std_weight_position * mean[3],
- 1e-1,
- self._std_weight_position * mean[3]]
- innovation_cov = np.diag(np.square(std))
-
- mean = np.dot(self._update_mat, mean)
- covariance = np.linalg.multi_dot((
- self._update_mat, covariance, self._update_mat.T))
- return mean, covariance + innovation_cov
-
- def multi_predict(self, mean, covariance):
- """Run Kalman filter prediction step (Vectorized version).
- Parameters
- ----------
- mean : ndarray
- The Nx8 dimensional mean matrix of the object states at the previous
- time step.
- covariance : ndarray
- The Nx8x8 dimensional covariance matrics of the object states at the
- previous time step.
- Returns
- -------
- (ndarray, ndarray)
- Returns the mean vector and covariance matrix of the predicted
- state. Unobserved velocities are initialized to 0 mean.
- """
- std_pos = [
- self._std_weight_position * mean[:, 3],
- self._std_weight_position * mean[:, 3],
- 1e-2 * np.ones_like(mean[:, 3]),
- self._std_weight_position * mean[:, 3]]
- std_vel = [
- self._std_weight_velocity * mean[:, 3],
- self._std_weight_velocity * mean[:, 3],
- 1e-5 * np.ones_like(mean[:, 3]),
- self._std_weight_velocity * mean[:, 3]]
- sqr = np.square(np.r_[std_pos, std_vel]).T
-
- motion_cov = []
- for i in range(len(mean)):
- motion_cov.append(np.diag(sqr[i]))
- motion_cov = np.asarray(motion_cov)
-
- mean = np.dot(mean, self._motion_mat.T)
- left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
- covariance = np.dot(left, self._motion_mat.T) + motion_cov
-
- return mean, covariance
-
- def update(self, mean, covariance, measurement):
- """Run Kalman filter correction step.
-
- Parameters
- ----------
- mean : ndarray
- The predicted state's mean vector (8 dimensional).
- covariance : ndarray
- The state's covariance matrix (8x8 dimensional).
- measurement : ndarray
- The 4 dimensional measurement vector (x, y, a, h), where (x, y)
- is the center position, a the aspect ratio, and h the height of the
- bounding box.
-
- Returns
- -------
- (ndarray, ndarray)
- Returns the measurement-corrected state distribution.
-
- """
- projected_mean, projected_cov = self.project(mean, covariance)
-
- chol_factor, lower = scipy.linalg.cho_factor(
- projected_cov, lower=True, check_finite=False)
- kalman_gain = scipy.linalg.cho_solve(
- (chol_factor, lower), np.dot(covariance, self._update_mat.T).T,
- check_finite=False).T
- innovation = measurement - projected_mean
-
- new_mean = mean + np.dot(innovation, kalman_gain.T)
- new_covariance = covariance - np.linalg.multi_dot((
- kalman_gain, projected_cov, kalman_gain.T))
- return new_mean, new_covariance
-
- def gating_distance(self, mean, covariance, measurements,
- only_position=False, metric='maha'):
- """Compute gating distance between state distribution and measurements.
- A suitable distance threshold can be obtained from `chi2inv95`. If
- `only_position` is False, the chi-square distribution has 4 degrees of
- freedom, otherwise 2.
- Parameters
- ----------
- mean : ndarray
- Mean vector over the state distribution (8 dimensional).
- covariance : ndarray
- Covariance of the state distribution (8x8 dimensional).
- measurements : ndarray
- An Nx4 dimensional matrix of N measurements, each in
- format (x, y, a, h) where (x, y) is the bounding box center
- position, a the aspect ratio, and h the height.
- only_position : Optional[bool]
- If True, distance computation is done with respect to the bounding
- box center position only.
- Returns
- -------
- ndarray
- Returns an array of length N, where the i-th element contains the
- squared Mahalanobis distance between (mean, covariance) and
- `measurements[i]`.
- """
- mean, covariance = self.project(mean, covariance)
- if only_position:
- mean, covariance = mean[:2], covariance[:2, :2]
- measurements = measurements[:, :2]
-
- d = measurements - mean
- if metric == 'gaussian':
- return np.sum(d * d, axis=1)
- elif metric == 'maha':
- cholesky_factor = np.linalg.cholesky(covariance)
- z = scipy.linalg.solve_triangular(
- cholesky_factor, d.T, lower=True, check_finite=False,
- overwrite_b=True)
- squared_maha = np.sum(z * z, axis=0)
- return squared_maha
- else:
- raise ValueError('invalid distance metric')
\ No newline at end of file
diff --git a/experimental/yolox/tracker/matching.py b/experimental/yolox/tracker/matching.py
deleted file mode 100644
index 2572c4d..0000000
--- a/experimental/yolox/tracker/matching.py
+++ /dev/null
@@ -1,181 +0,0 @@
-import cv2
-import numpy as np
-import scipy
-import lap
-from scipy.spatial.distance import cdist
-
-from cython_bbox import bbox_overlaps as bbox_ious
-from yolox.tracker import kalman_filter
-import time
-
-def merge_matches(m1, m2, shape):
- O,P,Q = shape
- m1 = np.asarray(m1)
- m2 = np.asarray(m2)
-
- M1 = scipy.sparse.coo_matrix((np.ones(len(m1)), (m1[:, 0], m1[:, 1])), shape=(O, P))
- M2 = scipy.sparse.coo_matrix((np.ones(len(m2)), (m2[:, 0], m2[:, 1])), shape=(P, Q))
-
- mask = M1*M2
- match = mask.nonzero()
- match = list(zip(match[0], match[1]))
- unmatched_O = tuple(set(range(O)) - set([i for i, j in match]))
- unmatched_Q = tuple(set(range(Q)) - set([j for i, j in match]))
-
- return match, unmatched_O, unmatched_Q
-
-
-def _indices_to_matches(cost_matrix, indices, thresh):
- matched_cost = cost_matrix[tuple(zip(*indices))]
- matched_mask = (matched_cost <= thresh)
-
- matches = indices[matched_mask]
- unmatched_a = tuple(set(range(cost_matrix.shape[0])) - set(matches[:, 0]))
- unmatched_b = tuple(set(range(cost_matrix.shape[1])) - set(matches[:, 1]))
-
- return matches, unmatched_a, unmatched_b
-
-
-def linear_assignment(cost_matrix, thresh):
- if cost_matrix.size == 0:
- return np.empty((0, 2), dtype=int), tuple(range(cost_matrix.shape[0])), tuple(range(cost_matrix.shape[1]))
- matches, unmatched_a, unmatched_b = [], [], []
- cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)
- for ix, mx in enumerate(x):
- if mx >= 0:
- matches.append([ix, mx])
- unmatched_a = np.where(x < 0)[0]
- unmatched_b = np.where(y < 0)[0]
- matches = np.asarray(matches)
- return matches, unmatched_a, unmatched_b
-
-
-def ious(atlbrs, btlbrs):
- """
- Compute cost based on IoU
- :type atlbrs: list[tlbr] | np.ndarray
- :type atlbrs: list[tlbr] | np.ndarray
-
- :rtype ious np.ndarray
- """
- ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float64)
- if ious.size == 0:
- return ious
-
- ious = bbox_ious(
- np.ascontiguousarray(atlbrs, dtype=np.float64),
- np.ascontiguousarray(btlbrs, dtype=np.float64)
- )
-
- return ious
-
-
-def iou_distance(atracks, btracks):
- """
- Compute cost based on IoU
- :type atracks: list[STrack]
- :type btracks: list[STrack]
-
- :rtype cost_matrix np.ndarray
- """
-
- if (len(atracks)>0 and isinstance(atracks[0], np.ndarray)) or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)):
- atlbrs = atracks
- btlbrs = btracks
- else:
- atlbrs = [track.tlbr for track in atracks]
- btlbrs = [track.tlbr for track in btracks]
- _ious = ious(atlbrs, btlbrs)
- cost_matrix = 1 - _ious
-
- return cost_matrix
-
-def v_iou_distance(atracks, btracks):
- """
- Compute cost based on IoU
- :type atracks: list[STrack]
- :type btracks: list[STrack]
-
- :rtype cost_matrix np.ndarray
- """
-
- if (len(atracks)>0 and isinstance(atracks[0], np.ndarray)) or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)):
- atlbrs = atracks
- btlbrs = btracks
- else:
- atlbrs = [track.tlwh_to_tlbr(track.pred_bbox) for track in atracks]
- btlbrs = [track.tlwh_to_tlbr(track.pred_bbox) for track in btracks]
- _ious = ious(atlbrs, btlbrs)
- cost_matrix = 1 - _ious
-
- return cost_matrix
-
-def embedding_distance(tracks, detections, metric='cosine'):
- """
- :param tracks: list[STrack]
- :param detections: list[BaseTrack]
- :param metric:
- :return: cost_matrix np.ndarray
- """
-
- cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float64)
- if cost_matrix.size == 0:
- return cost_matrix
- det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float64)
- #for i, track in enumerate(tracks):
- #cost_matrix[i, :] = np.maximum(0.0, cdist(track.smooth_feat.reshape(1,-1), det_features, metric))
- track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float64)
- cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric)) # Nomalized features
- return cost_matrix
-
-
-def gate_cost_matrix(kf, cost_matrix, tracks, detections, only_position=False):
- if cost_matrix.size == 0:
- return cost_matrix
- gating_dim = 2 if only_position else 4
- gating_threshold = kalman_filter.chi2inv95[gating_dim]
- measurements = np.asarray([det.to_xyah() for det in detections])
- for row, track in enumerate(tracks):
- gating_distance = kf.gating_distance(
- track.mean, track.covariance, measurements, only_position)
- cost_matrix[row, gating_distance > gating_threshold] = np.inf
- return cost_matrix
-
-
-def fuse_motion(kf, cost_matrix, tracks, detections, only_position=False, lambda_=0.98):
- if cost_matrix.size == 0:
- return cost_matrix
- gating_dim = 2 if only_position else 4
- gating_threshold = kalman_filter.chi2inv95[gating_dim]
- measurements = np.asarray([det.to_xyah() for det in detections])
- for row, track in enumerate(tracks):
- gating_distance = kf.gating_distance(
- track.mean, track.covariance, measurements, only_position, metric='maha')
- cost_matrix[row, gating_distance > gating_threshold] = np.inf
- cost_matrix[row] = lambda_ * cost_matrix[row] + (1 - lambda_) * gating_distance
- return cost_matrix
-
-
-def fuse_iou(cost_matrix, tracks, detections):
- if cost_matrix.size == 0:
- return cost_matrix
- reid_sim = 1 - cost_matrix
- iou_dist = iou_distance(tracks, detections)
- iou_sim = 1 - iou_dist
- fuse_sim = reid_sim * (1 + iou_sim) / 2
- det_scores = np.array([det.score for det in detections])
- det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
- #fuse_sim = fuse_sim * (1 + det_scores) / 2
- fuse_cost = 1 - fuse_sim
- return fuse_cost
-
-
-def fuse_score(cost_matrix, detections):
- if cost_matrix.size == 0:
- return cost_matrix
- iou_sim = 1 - cost_matrix
- det_scores = np.array([det.score for det in detections])
- det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
- fuse_sim = iou_sim * det_scores
- fuse_cost = 1 - fuse_sim
- return fuse_cost
\ No newline at end of file