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.pycdeleted file mode 100644index 024c842..0000000Binary files a/experimental/__pycache__/aes.cpython-313.pyc and /dev/null differdiff --git a/experimental/aes.py b/experimental/aes.pydeleted file mode 100644index 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 filediff --git a/experimental/bytetrack.py b/experimental/bytetrack.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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()">×</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()">×</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 filediff --git a/experimental/rtsp_yolov8.py b/experimental/rtsp_yolov8.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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_Storedeleted file mode 100644index 7e85cb6..0000000Binary files a/experimental/yolox/.DS_Store and /dev/null differdiff --git a/experimental/yolox/tracker/basetrack.py b/experimental/yolox/tracker/basetrack.pydeleted file mode 100644index 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.Removeddiff --git a/experimental/yolox/tracker/byte_tracker.py b/experimental/yolox/tracker/byte_tracker.pydeleted file mode 100644index 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, resbdiff --git a/experimental/yolox/tracker/kalman_filter.py b/experimental/yolox/tracker/kalman_filter.pydeleted file mode 100644index 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 filediff --git a/experimental/yolox/tracker/matching.py b/experimental/yolox/tracker/matching.pydeleted file mode 100644index 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