fix: resolve parameter bugs in frontend settings panel

- Add nmsRadius (9px default) to settings state; expose as slider (3-20px)
- Fix float precision drift on magnification/nmsRadius sliders using toFixed
- Ensure integer params (capacity, frameSkip) use Math.round on slider change
- Properly coerce all FormData values to strings for FastAPI compatibility
- Fix WebSocket settings: Boolean() wraps toggles, Math.round() wraps ints
- Capacity slider step reduced from 10 to 5 for finer control
- Add frontend/.npm-cache/ to .gitignore

.gitignore

@@ -0,0 +1,64 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+*.so
+.Python
+env/
+.venv/
+venv/
+ENV/
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# SQLite databases
+*.db
+*.sqlite3
+
+# Log files
+*.log
+*.err.log
+logs/
+
+# Temp uploads
+temp_uploads/
+
+# Node / Frontend
+frontend/node_modules/
+frontend/dist/
+frontend/.env
+frontend/.npm-cache/
+node_modules/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Model weights (large binary files - too large for GitHub without LFS)
+weights/
+
+# Datasets (usually large)
+# crowd_datasets/

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# System deps for OpenCV headless + general runtime
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for layer caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the project
+COPY . .
+
+# Create runtime directories
+RUN mkdir -p temp_uploads weights
+
+# HuggingFace Spaces uses port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,1401 @@
+Tencent is pleased to support the open source community by making P2PNet available. 
+
+Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved. The below software in this distribution may have been modified by THL A29 Limited ("Tencent Modifications"). All Tencent Modifications are Copyright (C) THL A29 Limited.
+
+P2PNet is licensed under the following License, except for the third-party components listed below. 
+
+License for P2PNet:
+--------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without modification, are permitted provided 
+that the following conditions are met:
+
+1. Use in source and binary forms shall only be for the purpose of academic research.
+
+2. Redistributions of source code must retain the above copyright notice, this list of conditions and the 
+    following disclaimer.
+
+3. Redistributions in binary form must reproduce the above copyright notice,  this list of conditions and 
+    the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+4. Neither the name of the copyright holder nor the names of its contributors may be used to endorse 
+   or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Other dependencies and licenses:
+
+
+Open Source Software Licensed under the BSD 3-Clause License:
+--------------------------------------------------------------------
+1. Pytorch
+Copyright (c) 2016-     Facebook, Inc            (Adam Paszke)
+Copyright (c) 2014-     Facebook, Inc            (Soumith Chintala)
+Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert)
+Copyright (c) 2012-2014 Deepmind Technologies    (Koray Kavukcuoglu)
+Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu)
+Copyright (c) 2011-2013 NYU                      (Clement Farabet)
+Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston)
+Copyright (c) 2006      Idiap Research Institute (Samy Bengio)
+Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz)
+
+2. torchvision
+Copyright (c) Soumith Chintala 2016, 
+All rights reserved.
+
+3. opencv-python
+Copyright (C) 2000-2020, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Copyright (C) 2019-2020, Xperience AI, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+
+Terms of the BSD 3-Clause License:
+--------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+Open Source Software Licensed under the PIL Software License:
+--------------------------------------------------------------------
+1. Pillow
+Copyright © 2010-2020 by Alex Clark and contributors
+
+
+Terms of the PIL Software License:
+--------------------------------------------------------------------
+By obtaining, using, and/or copying this software and/or its associated documentation, you agree that you have read, understood, and will comply with the following terms and conditions:
+
+Permission to use, copy, modify, and distribute this software and its associated documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appears in all copies, and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Secret Labs AB or the author not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.
+
+SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+Open Source Software Licensed under the BSD 3-Clause License and Other Licenses of the Third-Party Components therein:
+--------------------------------------------------------------------
+1. numpy
+Copyright (c) 2005-2020, NumPy Developers.
+All rights reserved.
+
+
+A copy of the BSD 3-Clause License is included in this file.
+
+The NumPy repository and source distributions bundle several libraries that are
+compatibly licensed.  We list these here.
+
+Name: Numpydoc
+Files: doc/sphinxext/numpydoc/*
+License: BSD-2-Clause
+
+Name: scipy-sphinx-theme
+Files: doc/scipy-sphinx-theme/*
+License: BSD-3-Clause AND PSF-2.0 AND Apache-2.0
+
+Name: lapack-lite
+Files: numpy/linalg/lapack_lite/*
+License: BSD-3-Clause
+
+Name: tempita
+Files: tools/npy_tempita/*
+License: MIT
+
+Name: dragon4
+Files: numpy/core/src/multiarray/dragon4.c
+License: MIT
+
+
+
+Open Source Software Licensed under the BSD 3-Clause License and Other Licenses of the Third-Party Components therein:
+--------------------------------------------------------------------
+1. h5py
+Copyright (c) 2008 Andrew Collette and contributors
+All rights reserved.
+
+
+A copy of the BSD 3-Clause License is included in this file.
+
+For thirdparty hdf5:
+HDF5 (Hierarchical Data Format 5) Software Library and Utilities
+Copyright 2006-2007 by The HDF Group (THG).
+
+NCSA HDF5 (Hierarchical Data Format 5) Software Library and Utilities
+Copyright 1998-2006 by the Board of Trustees of the University of Illinois.
+
+All rights reserved.
+
+Contributors: National Center for Supercomputing Applications (NCSA)
+at the University of Illinois, Fortner Software, Unidata Program
+Center (netCDF), The Independent JPEG Group (JPEG), Jean-loup Gailly
+and Mark Adler (gzip), and Digital Equipment Corporation (DEC).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted for any purpose (including commercial
+purposes) provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright
+notice, this list of conditions, and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions, and the following
+disclaimer in the documentation and/or materials provided with the
+distribution.
+   3. In addition, redistributions of modified forms of the source or
+binary code must carry prominent notices stating that the original
+code was changed and the date of the change.
+   4. All publications or advertising materials mentioning features or
+use of this software are asked, but not required, to acknowledge that
+it was developed by The HDF Group and by the National Center for
+Supercomputing Applications at the University of Illinois at
+Urbana-Champaign and credit the contributors.
+   5. Neither the name of The HDF Group, the name of the University,
+nor the name of any Contributor may be used to endorse or promote
+products derived from this software without specific prior written
+permission from THG, the University, or the Contributor, respectively.
+
+DISCLAIMER: THIS SOFTWARE IS PROVIDED BY THE HDF GROUP (THG) AND THE
+CONTRIBUTORS "AS IS" WITH NO WARRANTY OF ANY KIND, EITHER EXPRESSED OR
+IMPLIED. In no event shall THG or the Contributors be liable for any
+damages suffered by the users arising out of the use of this software,
+even if advised of the possibility of such damage.
+
+Portions of HDF5 were developed with support from the University of
+California, Lawrence Livermore National Laboratory (UC LLNL). The
+following statement applies to those portions of the product and must
+be retained in any redistribution of source code, binaries,
+documentation, and/or accompanying materials:
+
+This work was partially produced at the University of California,
+Lawrence Livermore National Laboratory (UC LLNL) under contract
+no. W-7405-ENG-48 (Contract 48) between the U.S. Department of Energy
+(DOE) and The Regents of the University of California (University) for
+the operation of UC LLNL.
+
+DISCLAIMER: This work was prepared as an account of work sponsored by
+an agency of the United States Government. Neither the United States
+Government nor the University of California nor any of their
+employees, makes any warranty, express or implied, or assumes any
+liability or responsibility for the accuracy, completeness, or
+usefulness of any information, apparatus, product, or process
+disclosed, or represents that its use would not infringe privately-
+owned rights. Reference herein to any specific commercial products,
+process, or service by trade name, trademark, manufacturer, or
+otherwise, does not necessarily constitute or imply its endorsement,
+recommendation, or favoring by the United States Government or the
+University of California. The views and opinions of authors expressed
+herein do not necessarily state or reflect those of the United States
+Government or the University of California, and shall not be used for
+advertising or product endorsement purposes.
+
+For third-party pytables:
+Copyright Notice and Statement for PyTables Software Library and Utilities:
+
+Copyright (c) 2002, 2003, 2004  Francesc Altet
+Copyright (c) 2005, 2006, 2007  Carabos Coop. V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+a. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+b. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the
+   distribution.
+
+c. Neither the name of the Carabos Coop. V. nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+For third-party python:
+Python license
+==============
+
+#. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
+   the Individual or Organization ("Licensee") accessing and otherwise using Python
+   Python 2.7.5 software in source or binary form and its associated documentation.
+
+#. Subject to the terms and conditions of this License Agreement, PSF hereby
+   grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+   analyze, test, perform and/or display publicly, prepare derivative works,
+   distribute, and otherwise use Python Python 2.7.5 alone or in any derivative
+   version, provided, however, that PSF's License Agreement and PSF's notice of
+   copyright, i.e., "Copyright 2001-2013 Python Software Foundation; All Rights
+   Reserved" are retained in Python Python 2.7.5 alone or in any derivative version
+   prepared by Licensee.
+
+#. In the event Licensee prepares a derivative work that is based on or
+   incorporates Python Python 2.7.5 or any part thereof, and wants to make the
+   derivative work available to others as provided herein, then Licensee hereby
+   agrees to include in any such work a brief summary of the changes made to Python
+   Python 2.7.5.
+
+#. PSF is making Python Python 2.7.5 available to Licensee on an "AS IS" basis.
+   PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.  BY WAY OF
+   EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
+   WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
+   USE OF PYTHON Python 2.7.5 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+#. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON Python 2.7.5
+   FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
+   MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON Python 2.7.5, OR ANY DERIVATIVE
+   THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+#. This License Agreement will automatically terminate upon a material breach of
+   its terms and conditions.
+
+#. Nothing in this License Agreement shall be deemed to create any relationship
+   of agency, partnership, or joint venture between PSF and Licensee.  This License
+   Agreement does not grant permission to use PSF trademarks or trade name in a
+   trademark sense to endorse or promote products or services of Licensee, or any
+   third party.
+
+#. By copying, installing or otherwise using Python Python 2.7.5, Licensee agrees
+   to be bound by the terms and conditions of this License Agreement.
+
+For third-party stdint:
+Copyright (c) 2006-2008 Alexander Chemeris
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  3. The name of the author may be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+Open Source Software Licensed under the BSD 3-Clause License and Other Licenses of the Third-Party Components therein:
+--------------------------------------------------------------------
+1. scipy
+Copyright (c) 2001-2002 Enthought, Inc.  2003-2019, SciPy Developers.
+All rights reserved.
+
+
+A copy of the BSD 3-Clause License is included in this file.
+
+The SciPy repository and source distributions bundle a number of libraries that
+are compatibly licensed.  We list these here.
+
+Name: Numpydoc
+Files: doc/sphinxext/numpydoc/*
+License: 2-clause BSD
+  For details, see doc/sphinxext/LICENSE.txt
+
+Name: scipy-sphinx-theme
+Files: doc/scipy-sphinx-theme/*
+License: 3-clause BSD, PSF and Apache 2.0
+  For details, see doc/sphinxext/LICENSE.txt
+
+Name: Decorator
+Files: scipy/_lib/decorator.py
+License: 2-clause BSD
+  For details, see the header inside scipy/_lib/decorator.py
+
+Name: ID
+Files: scipy/linalg/src/id_dist/*
+License: 3-clause BSD
+  For details, see scipy/linalg/src/id_dist/doc/doc.tex
+
+Name: L-BFGS-B
+Files: scipy/optimize/lbfgsb/*
+License: BSD license
+  For details, see scipy/optimize/lbfgsb/README
+
+Name: SuperLU
+Files: scipy/sparse/linalg/dsolve/SuperLU/*
+License: 3-clause BSD
+  For details, see scipy/sparse/linalg/dsolve/SuperLU/License.txt
+
+Name: ARPACK
+Files: scipy/sparse/linalg/eigen/arpack/ARPACK/*
+License: 3-clause BSD
+  For details, see scipy/sparse/linalg/eigen/arpack/ARPACK/COPYING
+
+Name: Qhull
+Files: scipy/spatial/qhull/*
+License: Qhull license (BSD-like)
+  For details, see scipy/spatial/qhull/COPYING.txt
+
+Name: Cephes
+Files: scipy/special/cephes/*
+License: 3-clause BSD
+  Distributed under 3-clause BSD license with permission from the author,
+  see https://lists.debian.org/debian-legal/2004/12/msg00295.html
+
+  Cephes Math Library Release 2.8:  June, 2000
+  Copyright 1984, 1995, 2000 by Stephen L. Moshier
+
+  This software is derived from the Cephes Math Library and is
+  incorporated herein by permission of the author.
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of the <organization> nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Name: Faddeeva
+Files: scipy/special/Faddeeva.*
+License: MIT
+  Copyright (c) 2012 Massachusetts Institute of Technology
+
+  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.
+
+Name: qd
+Files: scipy/special/cephes/dd_*.[ch]
+License: modified BSD license ("BSD-LBNL-License.doc")
+  This work was supported by the Director, Office of Science, Division
+  of Mathematical, Information, and Computational Sciences of the
+  U.S. Department of Energy under contract numbers DE-AC03-76SF00098 and
+  DE-AC02-05CH11231.
+
+  Copyright (c) 2003-2009, The Regents of the University of California,
+  through Lawrence Berkeley National Laboratory (subject to receipt of
+  any required approvals from U.S. Dept. of Energy) All rights reserved.
+
+  1. Redistribution and use in source and binary forms, with or
+  without modification, are permitted provided that the following
+  conditions are met:
+
+  (1) Redistributions of source code must retain the copyright
+  notice, this list of conditions and the following disclaimer.
+
+  (2) Redistributions in binary form must reproduce the copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+  (3) Neither the name of the University of California, Lawrence
+  Berkeley National Laboratory, U.S. Dept. of Energy nor the names
+  of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written
+  permission.
+
+  2. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  3. You are under no obligation whatsoever to provide any bug fixes,
+  patches, or upgrades to the features, functionality or performance of
+  the source code ("Enhancements") to anyone; however, if you choose to
+  make your Enhancements available either publicly, or directly to
+  Lawrence Berkeley National Laboratory, without imposing a separate
+  written license agreement for such Enhancements, then you hereby grant
+  the following license: a non-exclusive, royalty-free perpetual license
+  to install, use, modify, prepare derivative works, incorporate into
+  other computer software, distribute, and sublicense such enhancements
+  or derivative works thereof, in binary and source code form.
+
+Name: pypocketfft
+Files: scipy/fft/_pocketfft/[pocketfft.h, pypocketfft.cxx]
+License: 3-Clause BSD
+  For details, see scipy/fft/_pocketfft/LICENSE.md
+
+Name: uarray
+Files: scipy/_lib/uarray/*
+License: 3-Clause BSD
+  For details, see scipy/_lib/uarray/LICENSE
+
+Name: ampgo
+Files: benchmarks/benchmarks/go_benchmark_functions/*.py
+License: MIT
+  Functions for testing global optimizers, forked from the AMPGO project,
+  https://code.google.com/archive/p/ampgo
+
+Name: pybind11
+Files: no source files are included, however pybind11 binary artifacts are
+  included with every binary build of SciPy.
+License:
+  Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+
+  3. Neither the name of the copyright holder nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+Open Source Software Licensed under the Specific License and Other Licenses of the Third-Party Components therein:
+--------------------------------------------------------------------
+1. matplotlib
+Copyright (c)
+2012- Matplotlib Development Team; All Rights Reserved
+
+
+Terms of the Specific License:
+--------------------------------------------------------------------
+1. This LICENSE AGREEMENT is between the Matplotlib Development Team
+("MDT"), and the Individual or Organization ("Licensee") accessing and
+otherwise using matplotlib software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, MDT
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that MDT's
+License Agreement and MDT's notice of copyright, i.e., "Copyright (c)
+2012- Matplotlib Development Team; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib .
+
+4. MDT is making matplotlib available to Licensee on an "AS
+IS" basis.  MDT MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, MDT MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. MDT SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between MDT and
+Licensee.  This License Agreement does not grant permission to use MDT
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib ,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.
+
+For third-party cmr10.pfb:
+The cmr10.pfb file is a Type-1 version of one of Knuth's Computer Modern fonts.
+It is included here as test data only, but the following license applies.
+
+Copyright (c) 1997, 2009, American Mathematical Society (http://www.ams.org).
+All Rights Reserved.
+
+"cmb10" is a Reserved Font Name for this Font Software.
+"cmbsy10" is a Reserved Font Name for this Font Software.
+"cmbsy5" is a Reserved Font Name for this Font Software.
+"cmbsy6" is a Reserved Font Name for this Font Software.
+"cmbsy7" is a Reserved Font Name for this Font Software.
+"cmbsy8" is a Reserved Font Name for this Font Software.
+"cmbsy9" is a Reserved Font Name for this Font Software.
+"cmbx10" is a Reserved Font Name for this Font Software.
+"cmbx12" is a Reserved Font Name for this Font Software.
+"cmbx5" is a Reserved Font Name for this Font Software.
+"cmbx6" is a Reserved Font Name for this Font Software.
+"cmbx7" is a Reserved Font Name for this Font Software.
+"cmbx8" is a Reserved Font Name for this Font Software.
+"cmbx9" is a Reserved Font Name for this Font Software.
+"cmbxsl10" is a Reserved Font Name for this Font Software.
+"cmbxti10" is a Reserved Font Name for this Font Software.
+"cmcsc10" is a Reserved Font Name for this Font Software.
+"cmcsc8" is a Reserved Font Name for this Font Software.
+"cmcsc9" is a Reserved Font Name for this Font Software.
+"cmdunh10" is a Reserved Font Name for this Font Software.
+"cmex10" is a Reserved Font Name for this Font Software.
+"cmex7" is a Reserved Font Name for this Font Software.
+"cmex8" is a Reserved Font Name for this Font Software.
+"cmex9" is a Reserved Font Name for this Font Software.
+"cmff10" is a Reserved Font Name for this Font Software.
+"cmfi10" is a Reserved Font Name for this Font Software.
+"cmfib8" is a Reserved Font Name for this Font Software.
+"cminch" is a Reserved Font Name for this Font Software.
+"cmitt10" is a Reserved Font Name for this Font Software.
+"cmmi10" is a Reserved Font Name for this Font Software.
+"cmmi12" is a Reserved Font Name for this Font Software.
+"cmmi5" is a Reserved Font Name for this Font Software.
+"cmmi6" is a Reserved Font Name for this Font Software.
+"cmmi7" is a Reserved Font Name for this Font Software.
+"cmmi8" is a Reserved Font Name for this Font Software.
+"cmmi9" is a Reserved Font Name for this Font Software.
+"cmmib10" is a Reserved Font Name for this Font Software.
+"cmmib5" is a Reserved Font Name for this Font Software.
+"cmmib6" is a Reserved Font Name for this Font Software.
+"cmmib7" is a Reserved Font Name for this Font Software.
+"cmmib8" is a Reserved Font Name for this Font Software.
+"cmmib9" is a Reserved Font Name for this Font Software.
+"cmr10" is a Reserved Font Name for this Font Software.
+"cmr12" is a Reserved Font Name for this Font Software.
+"cmr17" is a Reserved Font Name for this Font Software.
+"cmr5" is a Reserved Font Name for this Font Software.
+"cmr6" is a Reserved Font Name for this Font Software.
+"cmr7" is a Reserved Font Name for this Font Software.
+"cmr8" is a Reserved Font Name for this Font Software.
+"cmr9" is a Reserved Font Name for this Font Software.
+"cmsl10" is a Reserved Font Name for this Font Software.
+"cmsl12" is a Reserved Font Name for this Font Software.
+"cmsl8" is a Reserved Font Name for this Font Software.
+"cmsl9" is a Reserved Font Name for this Font Software.
+"cmsltt10" is a Reserved Font Name for this Font Software.
+"cmss10" is a Reserved Font Name for this Font Software.
+"cmss12" is a Reserved Font Name for this Font Software.
+"cmss17" is a Reserved Font Name for this Font Software.
+"cmss8" is a Reserved Font Name for this Font Software.
+"cmss9" is a Reserved Font Name for this Font Software.
+"cmssbx10" is a Reserved Font Name for this Font Software.
+"cmssdc10" is a Reserved Font Name for this Font Software.
+"cmssi10" is a Reserved Font Name for this Font Software.
+"cmssi12" is a Reserved Font Name for this Font Software.
+"cmssi17" is a Reserved Font Name for this Font Software.
+"cmssi8" is a Reserved Font Name for this Font Software.
+"cmssi9" is a Reserved Font Name for this Font Software.
+"cmssq8" is a Reserved Font Name for this Font Software.
+"cmssqi8" is a Reserved Font Name for this Font Software.
+"cmsy10" is a Reserved Font Name for this Font Software.
+"cmsy5" is a Reserved Font Name for this Font Software.
+"cmsy6" is a Reserved Font Name for this Font Software.
+"cmsy7" is a Reserved Font Name for this Font Software.
+"cmsy8" is a Reserved Font Name for this Font Software.
+"cmsy9" is a Reserved Font Name for this Font Software.
+"cmtcsc10" is a Reserved Font Name for this Font Software.
+"cmtex10" is a Reserved Font Name for this Font Software.
+"cmtex8" is a Reserved Font Name for this Font Software.
+"cmtex9" is a Reserved Font Name for this Font Software.
+"cmti10" is a Reserved Font Name for this Font Software.
+"cmti12" is a Reserved Font Name for this Font Software.
+"cmti7" is a Reserved Font Name for this Font Software.
+"cmti8" is a Reserved Font Name for this Font Software.
+"cmti9" is a Reserved Font Name for this Font Software.
+"cmtt10" is a Reserved Font Name for this Font Software.
+"cmtt12" is a Reserved Font Name for this Font Software.
+"cmtt8" is a Reserved Font Name for this Font Software.
+"cmtt9" is a Reserved Font Name for this Font Software.
+"cmu10" is a Reserved Font Name for this Font Software.
+"cmvtt10" is a Reserved Font Name for this Font Software.
+"euex10" is a Reserved Font Name for this Font Software.
+"euex7" is a Reserved Font Name for this Font Software.
+"euex8" is a Reserved Font Name for this Font Software.
+"euex9" is a Reserved Font Name for this Font Software.
+"eufb10" is a Reserved Font Name for this Font Software.
+"eufb5" is a Reserved Font Name for this Font Software.
+"eufb7" is a Reserved Font Name for this Font Software.
+"eufm10" is a Reserved Font Name for this Font Software.
+"eufm5" is a Reserved Font Name for this Font Software.
+"eufm7" is a Reserved Font Name for this Font Software.
+"eurb10" is a Reserved Font Name for this Font Software.
+"eurb5" is a Reserved Font Name for this Font Software.
+"eurb7" is a Reserved Font Name for this Font Software.
+"eurm10" is a Reserved Font Name for this Font Software.
+"eurm5" is a Reserved Font Name for this Font Software.
+"eurm7" is a Reserved Font Name for this Font Software.
+"eusb10" is a Reserved Font Name for this Font Software.
+"eusb5" is a Reserved Font Name for this Font Software.
+"eusb7" is a Reserved Font Name for this Font Software.
+"eusm10" is a Reserved Font Name for this Font Software.
+"eusm5" is a Reserved Font Name for this Font Software.
+"eusm7" is a Reserved Font Name for this Font Software.
+"lasy10" is a Reserved Font Name for this Font Software.
+"lasy5" is a Reserved Font Name for this Font Software.
+"lasy6" is a Reserved Font Name for this Font Software.
+"lasy7" is a Reserved Font Name for this Font Software.
+"lasy8" is a Reserved Font Name for this Font Software.
+"lasy9" is a Reserved Font Name for this Font Software.
+"lasyb10" is a Reserved Font Name for this Font Software.
+"lcircle1" is a Reserved Font Name for this Font Software.
+"lcirclew" is a Reserved Font Name for this Font Software.
+"lcmss8" is a Reserved Font Name for this Font Software.
+"lcmssb8" is a Reserved Font Name for this Font Software.
+"lcmssi8" is a Reserved Font Name for this Font Software.
+"line10" is a Reserved Font Name for this Font Software.
+"linew10" is a Reserved Font Name for this Font Software.
+"msam10" is a Reserved Font Name for this Font Software.
+"msam5" is a Reserved Font Name for this Font Software.
+"msam6" is a Reserved Font Name for this Font Software.
+"msam7" is a Reserved Font Name for this Font Software.
+"msam8" is a Reserved Font Name for this Font Software.
+"msam9" is a Reserved Font Name for this Font Software.
+"msbm10" is a Reserved Font Name for this Font Software.
+"msbm5" is a Reserved Font Name for this Font Software.
+"msbm6" is a Reserved Font Name for this Font Software.
+"msbm7" is a Reserved Font Name for this Font Software.
+"msbm8" is a Reserved Font Name for this Font Software.
+"msbm9" is a Reserved Font Name for this Font Software.
+"wncyb10" is a Reserved Font Name for this Font Software.
+"wncyi10" is a Reserved Font Name for this Font Software.
+"wncyr10" is a Reserved Font Name for this Font Software.
+"wncysc10" is a Reserved Font Name for this Font Software.
+"wncyss10" is a Reserved Font Name for this Font Software.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+For third-party BaKoMa:
+BaKoMa Fonts Licence
+			--------------------
+
+  This licence covers two font packs (known as BaKoMa Fonts Colelction,
+  which is available at `CTAN:fonts/cm/ps-type1/bakoma/'):
+
+    1) BaKoMa-CM (1.1/12-Nov-94)
+       Computer Modern Fonts in PostScript Type 1 and TrueType font formats.
+
+    2) BaKoMa-AMS (1.2/19-Jan-95)
+       AMS TeX fonts in PostScript Type 1 and TrueType font formats.
+   
+  Copyright (C) 1994, 1995, Basil K. Malyshev. All Rights Reserved.
+
+  Permission to copy and distribute these fonts for any purpose is 
+  hereby granted without fee, provided that the above copyright notice, 
+  author statement and this permission notice appear in all copies of 
+  these fonts and related documentation.
+
+  Permission to modify and distribute modified fonts for any purpose is 
+  hereby granted without fee, provided that the copyright notice, 
+  author statement, this permission notice and location of original 
+  fonts (http://www.ctan.org/tex-archive/fonts/cm/ps-type1/bakoma)
+  appear in all copies of modified fonts and related documentation.
+
+  Permission to use these fonts (embedding into PostScript, PDF, SVG
+  and printing by using any software) is hereby granted without fee. 
+  It is not required to provide any notices about using these fonts.
+
+ Basil K. Malyshev
+ INSTITUTE FOR HIGH ENERGY PHYSICS
+ IHEP, OMVT
+ Moscow Region
+ 142281 PROTVINO
+ RUSSIA
+
+ E-Mail:	bakoma@mail.ru
+      or	malyshev@mail.ihep.ru
+
+For thirdparty carlogo:
+----> we renamed carlito -> carlogo to comply with the terms <----
+
+Copyright (c) 2010-2013 by tyPoland Lukasz Dziedzic with Reserved Font Name "Carlito".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
+
+For third-party ColorBrewer Color Schemes:
+Apache-Style Software License for ColorBrewer Color Schemes
+
+Version 1.1
+
+Copyright (c) 2002 Cynthia Brewer, Mark Harrower, and The Pennsylvania 
+State University. All rights reserved. Redistribution and use in source 
+and binary forms, with or without modification, are permitted provided 
+that the following conditions are met:
+
+1. Redistributions as source code must retain the above copyright notice, 
+this list of conditions and the following disclaimer.
+
+2. The end-user documentation included with the redistribution, if any, 
+must include the following acknowledgment: "This product includes color 
+specifications and designs developed by Cynthia Brewer 
+(http://colorbrewer.org/)." Alternately, this acknowledgment may appear in 
+the software itself, if and wherever such third-party acknowledgments 
+normally appear.
+
+3. The name "ColorBrewer" must not be used to endorse or promote products 
+derived from this software without prior written permission. For written 
+permission, please contact Cynthia Brewer at cbrewer@psu.edu.
+
+4. Products derived from this software may not be called "ColorBrewer", 
+nor may "ColorBrewer" appear in their name, without prior written 
+permission of Cynthia Brewer.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, 
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
+CYNTHIA BREWER, MARK HARROWER, OR THE PENNSYLVANIA STATE UNIVERSITY BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+POSSIBILITY OF SUCH DAMAGE.
+
+For third-party JSXTOOLS_RESIZE_OBSERVER:
+# CC0 1.0 Universal
+
+## Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an “owner”) of an original work of
+authorship and/or a database (each, a “Work”).
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific works
+(“Commons”) that the public can reliably and without fear of later claims of
+infringement build upon, modify, incorporate in other works, reuse and
+redistribute as freely as possible in any form whatsoever and for any purposes,
+including without limitation commercial purposes. These owners may contribute
+to the Commons to promote the ideal of a free culture and the further
+production of creative, cultural and scientific works, or to gain reputation or
+greater distribution for their Work in part through the use and efforts of
+others.
+
+For these and/or other purposes and motivations, and without any expectation of
+additional consideration or compensation, the person associating CC0 with a
+Work (the “Affirmer”), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and
+publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+   protected by copyright and related or neighboring rights (“Copyright and
+   Related Rights”). Copyright and Related Rights include, but are not limited
+   to, the following:
+   1. the right to reproduce, adapt, distribute, perform, display, communicate,
+      and translate a Work;
+   2. moral rights retained by the original author(s) and/or performer(s);
+   3. publicity and privacy rights pertaining to a person’s image or likeness
+      depicted in a Work;
+   4. rights protecting against unfair competition in regards to a Work,
+      subject to the limitations in paragraph 4(i), below;
+   5. rights protecting the extraction, dissemination, use and reuse of data in
+      a Work;
+   6. database rights (such as those arising under Directive 96/9/EC of the
+      European Parliament and of the Council of 11 March 1996 on the legal
+      protection of databases, and under any national implementation thereof,
+      including any amended or successor version of such directive); and
+   7. other similar, equivalent or corresponding rights throughout the world
+      based on applicable law or treaty, and any national implementations
+      thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+   applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+   unconditionally waives, abandons, and surrenders all of Affirmer’s Copyright
+   and Related Rights and associated claims and causes of action, whether now
+   known or unknown (including existing as well as future claims and causes of
+   action), in the Work (i) in all territories worldwide, (ii) for the maximum
+   duration provided by applicable law or treaty (including future time
+   extensions), (iii) in any current or future medium and for any number of
+   copies, and (iv) for any purpose whatsoever, including without limitation
+   commercial, advertising or promotional purposes (the “Waiver”). Affirmer
+   makes the Waiver for the benefit of each member of the public at large and
+   to the detriment of Affirmer’s heirs and successors, fully intending that
+   such Waiver shall not be subject to revocation, rescission, cancellation,
+   termination, or any other legal or equitable action to disrupt the quiet
+   enjoyment of the Work by the public as contemplated by Affirmer’s express
+   Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+   judged legally invalid or ineffective under applicable law, then the Waiver
+   shall be preserved to the maximum extent permitted taking into account
+   Affirmer’s express Statement of Purpose. In addition, to the extent the
+   Waiver is so judged Affirmer hereby grants to each affected person a
+   royalty-free, non transferable, non sublicensable, non exclusive,
+   irrevocable and unconditional license to exercise Affirmer’s Copyright and
+   Related Rights in the Work (i) in all territories worldwide, (ii) for the
+   maximum duration provided by applicable law or treaty (including future time
+   extensions), (iii) in any current or future medium and for any number of
+   copies, and (iv) for any purpose whatsoever, including without limitation
+   commercial, advertising or promotional purposes (the “License”). The License
+   shall be deemed effective as of the date CC0 was applied by Affirmer to the
+   Work. Should any part of the License for any reason be judged legally
+   invalid or ineffective under applicable law, such partial invalidity or
+   ineffectiveness shall not invalidate the remainder of the License, and in
+   such case Affirmer hereby affirms that he or she will not (i) exercise any
+   of his or her remaining Copyright and Related Rights in the Work or (ii)
+   assert any associated claims and causes of action with respect to the Work,
+   in either case contrary to Affirmer’s express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+   1. No trademark or patent rights held by Affirmer are waived, abandoned,
+      surrendered, licensed or otherwise affected by this document.
+   2. Affirmer offers the Work as-is and makes no representations or warranties
+      of any kind concerning the Work, express, implied, statutory or
+      otherwise, including without limitation warranties of title,
+      merchantability, fitness for a particular purpose, non infringement, or
+      the absence of latent or other defects, accuracy, or the present or
+      absence of errors, whether or not discoverable, all to the greatest
+      extent permissible under applicable law.
+   3. Affirmer disclaims responsibility for clearing rights of other persons
+      that may apply to the Work or any use thereof, including without
+      limitation any person’s Copyright and Related Rights in the Work.
+      Further, Affirmer disclaims responsibility for obtaining any necessary
+      consents, permissions or other rights required for any use of the Work.
+   4. Affirmer understands and acknowledges that Creative Commons is not a
+      party to this document and has no duty or obligation with respect to this
+      CC0 or use of the Work.
+
+For more information, please see
+http://creativecommons.org/publicdomain/zero/1.0/.
+
+For third-party QT4_EDITOR:
+Module creating PyQt4 form dialogs/layouts to edit various type of parameters
+
+
+formlayout License Agreement (MIT License)
+------------------------------------------
+
+Copyright (c) 2009 Pierre Raybaut
+
+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.
+"""
+
+For third-party SOLARIZED:
+https://github.com/altercation/solarized/blob/master/LICENSE
+Copyright (c) 2011 Ethan Schoonover
+
+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.
+
+For third-party STIX:
+TERMS AND CONDITIONS
+
+   1. Permission is hereby granted, free of charge, to any person 
+obtaining a copy of the STIX Fonts-TM set accompanying this license 
+(collectively, the "Fonts") and the associated documentation files 
+(collectively with the Fonts, the "Font Software"), to reproduce and 
+distribute the Font Software, including the rights to use, copy, merge 
+and publish copies of the Font Software, and to permit persons to whom 
+the Font Software is furnished to do so same, subject to the following 
+terms and conditions (the "License").
+
+   2. The following copyright and trademark notice and these Terms and 
+Conditions shall be included in all copies of one or more of the Font 
+typefaces and any derivative work created as permitted under this 
+License:
+
+	Copyright (c) 2001-2005 by the STI Pub Companies, consisting of 
+the American Institute of Physics, the American Chemical Society, the 
+American Mathematical Society, the American Physical Society, Elsevier, 
+Inc., and The Institute of Electrical and Electronic Engineers, Inc. 
+Portions copyright (c) 1998-2003 by MicroPress, Inc. Portions copyright 
+(c) 1990 by Elsevier, Inc. All rights reserved. STIX Fonts-TM is a 
+trademark of The Institute of Electrical and Electronics Engineers, Inc.
+
+   3. You may (a) convert the Fonts from one format to another (e.g., 
+from TrueType to PostScript), in which case the normal and reasonable 
+distortion that occurs during such conversion shall be permitted and (b) 
+embed or include a subset of the Fonts in a document for the purposes of 
+allowing users to read text in the document that utilizes the Fonts. In 
+each case, you may use the STIX Fonts-TM mark to designate the resulting 
+Fonts or subset of the Fonts.
+
+   4. You may also (a) add glyphs or characters to the Fonts, or modify 
+the shape of existing glyphs, so long as the base set of glyphs is not 
+removed and (b) delete glyphs or characters from the Fonts, provided 
+that the resulting font set is distributed with the following 
+disclaimer: "This [name] font does not include all the Unicode points 
+covered in the STIX Fonts-TM set but may include others." In each case, 
+the name used to denote the resulting font set shall not include the 
+term "STIX" or any similar term.
+
+   5. You may charge a fee in connection with the distribution of the 
+Font Software, provided that no copy of one or more of the individual 
+Font typefaces that form the STIX Fonts-TM set may be sold by itself.
+
+   6. THE FONT SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY 
+KIND, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT 
+OF COPYRIGHT, PATENT, TRADEMARK OR OTHER RIGHT. IN NO EVENT SHALL 
+MICROPRESS OR ANY OF THE STI PUB COMPANIES BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, INCLUDING, BUT NOT LIMITED TO, ANY GENERAL, 
+SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM OR OUT OF THE USE OR 
+INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT 
+SOFTWARE.
+
+   7. Except as contained in the notice set forth in Section 2, the 
+names MicroPress Inc. and STI Pub Companies, as well as the names of the 
+companies/organizations that compose the STI Pub Companies, shall not be 
+used in advertising or otherwise to promote the sale, use or other 
+dealings in the Font Software without the prior written consent of the 
+respective company or organization.
+
+   8. This License shall become null and void in the event of any 
+material breach of the Terms and Conditions herein by licensee.
+
+   9. A substantial portion of the STIX Fonts set was developed by 
+MicroPress Inc. for the STI Pub Companies. To obtain additional 
+mathematical fonts, please contact MicroPress, Inc., 68-30 Harrow 
+Street, Forest Hills, NY 11375, USA - Phone: (718) 575-1816.
+
+For third-party YORICK:
+BSD-style license for gist/yorick colormaps.
+
+Copyright:
+
+  Copyright (c) 1996.  The Regents of the University of California.
+			 All rights reserved.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose without fee is hereby granted, provided that this entire
+notice is included in all copies of any software which is or includes
+a copy or modification of this software and in all copies of the
+supporting documentation for such software.
+
+This work was produced at the University of California, Lawrence
+Livermore National Laboratory under contract no. W-7405-ENG-48 between
+the U.S. Department of Energy and The Regents of the University of
+California for the operation of UC LLNL.
+
+
+			      DISCLAIMER
+
+This software was prepared as an account of work sponsored by an
+agency of the United States Government.  Neither the United States
+Government nor the University of California nor any of their
+employees, makes any warranty, express or implied, or assumes any
+liability or responsibility for the accuracy, completeness, or
+usefulness of any information, apparatus, product, or process
+disclosed, or represents that its use would not infringe
+privately-owned rights.  Reference herein to any specific commercial
+products, process, or service by trade name, trademark, manufacturer,
+or otherwise, does not necessarily constitute or imply its
+endorsement, recommendation, or favoring by the United States
+Government or the University of California.  The views and opinions of
+authors expressed herein do not necessarily state or reflect those of
+the United States Government or the University of California, and
+shall not be used for advertising or product endorsement purposes.
+
+
+				AUTHOR
+
+David H. Munro wrote Yorick and Gist.  Berkeley Yacc (byacc) generated
+the Yorick parser.  The routines in Math are from LAPACK and FFTPACK;
+MathC contains C translations by David H. Munro.  The algorithms for
+Yorick's random number generator and several special functions in
+Yorick/include were taken from Numerical Recipes by Press, et. al.,
+although the Yorick implementations are unrelated to those in
+Numerical Recipes.  A small amount of code in Gist was adapted from
+the X11R4 release, copyright M.I.T. -- the complete copyright notice
+may be found in the (unused) file Gist/host.c.
+
+
+
+Open Source Software Licensed under the PSF License Version 2:
+--------------------------------------------------------------------
+1. Python
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 Python Software Foundation. All rights reserved.
+
+Copyright (c) 2000 BeOpen.com. All rights reserved.
+
+Copyright (c) 1995-2001 Corporation for National Research Initiatives. All rights reserved.
+
+Copyright (c) 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
+
+
+Terms of the PSF License Version 2:
+--------------------------------------------------------------------
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 Python Software Foundation; All
+Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+
+Open Source Software Licensed under the MIT License:
+The below software in this distribution may have been modified by THL A29 Limited ("Tencent Modifications"). All Tencent Modifications are Copyright (C) 2021 THL A29 Limited.
+--------------------------------------------------------------------
+1. C^3 Framework
+Copyright (c) 2018 Junyu Gao
+
+
+Terms of the MIT License:
+--------------------------------------------------------------------
+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.
+
+
+
+Open Source Software Licensed under the MIT License:
+--------------------------------------------------------------------
+1. tensorboardX
+Copyright (c) 2017 Tzu-Wei Huang
+
+
+A copy of the MIT License is included in this file.
+
+
+
+Open Source Software Licensed under the Apache License Version 2.0:
+The below software in this distribution may have been modified by Tencent.
+--------------------------------------------------------------------
+1. DETR
+Copyright 2020 - present, Facebook, Inc
+Please note this software has been modified by Tencent in this distribution.
+
+
+Terms of the Apache License Version 2.0:
+--------------------------------------------------------------------
+Apache License 
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/ 
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and 
+
+You must cause any modified files to carry prominent notices stating that You changed the files; and 
+
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and 
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. 
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

MANUAL_TESTING.md

@@ -0,0 +1,19 @@
+# Manual Testing Checklist
+
+- [ ] Image upload accepts JPG, JPEG, and PNG.
+- [ ] Image processing completes and displays predicted points.
+- [ ] Video upload accepts MP4, AVI, and MOV.
+- [ ] Video processing supports shorter and longer videos without fixed duration limits.
+- [ ] Confidence slider changes the number of detected points.
+- [ ] Duplicate merge radius reduces duplicate detections on overlapping patches.
+- [ ] Magnification improves visibility of small drone targets.
+- [ ] Frame skip changes processing speed for video.
+- [ ] Fast processing preset prioritizes speed.
+- [ ] Balanced processing preset gives normal recommended behavior.
+- [ ] Accurate processing preset processes more thoroughly and runs slower.
+- [ ] Tracking keeps stable IDs across nearby moving points.
+- [ ] Alert triggers show normal/advisory/warning/critical states at capacity thresholds.
+- [ ] CSV export downloads and contains frame count fields.
+- [ ] JSON export downloads and contains timeline data.
+- [ ] Annotated video download works after processing.
+- [ ] Invalid video upload shows a clean error message.

README.md

@@ -0,0 +1,214 @@
+---
+title: Civic Pulse — Crowd Counting
+emoji: 👥
+colorFrom: teal
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+
+# Civic Pulse — Tactical Crowd Intelligence
+
+A full-stack AI drone monitoring dashboard built on **P2PNet** (ICCV 2021).
+FastAPI backend + React/Vite frontend with real-time WebSocket video streaming.
+
+## 🚀 Live Deployment (Free Tier)
+
+| Component | Platform | URL |
+|-----------|----------|-----|
+| **Frontend** | Vercel | `https://crowd-counting.vercel.app` |
+| **Backend API** | FastAPI (Docker/HuggingFace Spaces) | `Set your deployed backend URL in frontend/.env.production` |
+| **Model Weights** | HuggingFace Hub | `Set HF_WEIGHTS_REPO to your deployed weights repo` |
+
+> ⚠️ The HF Space may sleep after 15 min of inactivity. Open the app 30 seconds before your demo.
+
+## ⚡ Quick Local Setup
+
+```bash
+# Backend
+pip install -r requirements.txt
+uvicorn api:app --reload
+
+# Frontend (in another terminal)
+cd frontend
+npm install
+npm run dev
+```
+
+---
+
+# P2PNet (ICCV2021 Oral Presentation)
+
+This repository contains codes for the official implementation in PyTorch of **P2PNet** as described in [Rethinking Counting and Localization in Crowds: A Purely Point-Based Framework](https://arxiv.org/abs/2107.12746).
+ 
+A brief introduction of P2PNet can be found at [机器之心 (almosthuman)](https://mp.weixin.qq.com/s?__biz=MzA3MzI4MjgzMw==&mid=2650827826&idx=3&sn=edd3d66444130fb34a59d08fab618a9e&chksm=84e5a84cb392215a005a3b3424f20a9d24dc525dcd933960035bf4b6aa740191b5ecb2b7b161&mpshare=1&scene=1&srcid=1004YEOC7HC9daYRYeUio7Xn&sharer_sharetime=1633675738338&sharer_shareid=7d375dccd3b2f9eec5f8b27ee7c04883&version=3.1.16.5505&platform=win#rd).
+
+The codes is tested with PyTorch 1.5.0. It may not run with other versions.
+
+## Visualized demos for P2PNet
+<img src="vis/congested1.png" width="1000"/>   
+<img src="vis/congested2.png" width="1000"/> 
+<img src="vis/congested3.png" width="1000"/> 
+
+## The network
+The overall architecture of the P2PNet. Built upon the VGG16, it firstly introduce an upsampling path to obtain fine-grained feature map. 
+Then it exploits two branches to simultaneously predict a set of point proposals and their confidence scores.
+
+<img src="vis/net.png" width="1000"/>   
+
+## Comparison with state-of-the-art methods
+The P2PNet achieved state-of-the-art performance on several challenging datasets with various densities.
+
+| Methods   | Venue     | SHTechPartA <br> MAE/MSE  |SHTechPartB <br> MAE/MSE | UCF_CC_50 <br> MAE/MSE | UCF_QNRF <br> MAE/MSE   |
+|:----:|:----:|:----:|:----:|:----:|:----:|
+CAN  | CVPR'19 | 62.3/100.0 | 7.8/12.2 | 212.2/**243.7** | 107.0/183.0 |
+Bayesian+ | ICCV'19 | 62.8/101.8 | 7.7/12.7 | 229.3/308.2 | 88.7/154.8 |
+S-DCNet  | ICCV'19 | 58.3/95.0 | 6.7/10.7 | 204.2/301.3 | 104.4/176.1 |
+SANet+SPANet  | ICCV'19 | 59.4/92.5 | 6.5/**9.9** | 232.6/311.7 | -/- |
+DUBNet  | AAAI'20 | 64.6/106.8 | 7.7/12.5 | 243.8/329.3 | 105.6/180.5 |
+SDANet | AAAI'20 | 63.6/101.8 | 7.8/10.2 | 227.6/316.4 | -/- |
+ADSCNet | CVPR'20 | <u>55.4</u>/97.7 | <u>6.4</u>/11.3 | 198.4/267.3 | **71.3**/**132.5**|
+ASNet   | CVPR'20 | 57.78/<u>90.13</u> | -/- | <u>174.84</u>/<u>251.63</u> | 91.59/159.71 |
+AMRNet  | ECCV'20 | 61.59/98.36 | 7.02/11.00 | 184.0/265.8 | 86.6/152.2 |
+AMSNet  | ECCV'20 | 56.7/93.4 | 6.7/10.2 | 208.4/297.3 | 101.8/163.2|
+DM-Count  | NeurIPS'20 | 59.7/95.7 | 7.4/11.8 | 211.0/291.5 | 85.6/<u>148.3</u>|
+**Ours** |- | **52.74**/**85.06** | **6.25**/**9.9** | **172.72**/256.18 | <u>85.32</u>/154.5 |
+
+Comparison on the [NWPU-Crowd](https://www.crowdbenchmark.com/resultdetail.html?rid=81) dataset.
+
+| Methods   | MAE[O]  |MSE[O] | MAE[L] | MAE[S]   |
+|:----:|:----:|:----:|:----:|:----:|
+MCNN  | 232.5|714.6 | 220.9|1171.9 |
+SANet  | 190.6 | 491.4 | 153.8 | 716.3|
+CSRNet | 121.3 | 387.8 | 112.0 | <u>522.7</u> |
+PCC-Net  | 112.3 | 457.0 | 111.0 | 777.6 |
+CANNet  | 110.0 | 495.3 | 102.3 | 718.3|
+Bayesian+  | 105.4 | 454.2 | 115.8 | 750.5 |
+S-DCNet   | 90.2 | 370.5 | **82.9** | 567.8 |
+DM-Count  | <u>88.4</u> | 388.6 | 88.0 | **498.0** |
+**Ours** | **77.44**|**362** | <u>83.28</u>| 553.92 |
+
+The overall performance for both counting and localization.
+
+|nAP$_{\delta}$|SHTechPartA| SHTechPartB | UCF_CC_50 | UCF_QNRF | NWPU_Crowd |
+|:----:|:----:|:----:|:----:|:----:|:----:|    
+$\delta=0.05$ | 10.9\% | 23.8\%  | 5.0\% | 5.9\% | 12.9\% | 
+$\delta=0.25$ | 70.3\% | 84.2\%  | 54.5\% | 55.4\% | 71.3\% |  
+$\delta=0.50$ | 90.1\% | 94.1\%  | 88.1\% | 83.2\% | 89.1\% | 
+$\delta=\{{0.05:0.05:0.50}\}$ | 64.4\% | 76.3\%  | 54.3\% | 53.1\% | 65.0\% |  
+
+Comparison for the localization performance in terms of F1-Measure on NWPU.
+
+| Method| F1-Measure |Precision| Recall |
+|:----:|:----:|:----:|:----:|
+FasterRCNN  |  0.068 |  0.958 | 0.035 |
+TinyFaces |  0.567  |  0.529 | 0.611 |
+RAZ |   0.599 |  0.666 |  0.543|
+Crowd-SDNet |  0.637  | 0.651  | 0.624  |
+PDRNet |  0.653 | 0.675  | 0.633  |
+TopoCount | 0.692  | 0.683  | **0.701** |
+D2CNet | <u>0.700</u> | **0.741**  | 0.662 |
+**Ours** |**0.712** | <u>0.729</u>  | <u>0.695</u> |
+
+## Installation
+* Clone this repo into a directory named P2PNET_ROOT
+* Organize your datasets as required
+* Install Python dependencies. We use python 3.6.5 and pytorch 1.5.0
+```
+pip install -r requirements.txt
+```
+
+## Organize the counting dataset
+We use a list file to collect all the images and their ground truth annotations in a counting dataset. When your dataset is organized as recommended in the following, the format of this list file is defined as:
+```
+train/scene01/img01.jpg train/scene01/img01.txt
+train/scene01/img02.jpg train/scene01/img02.txt
+...
+train/scene02/img01.jpg train/scene02/img01.txt
+```
+
+### Dataset structures:
+```
+DATA_ROOT/
+        |->train/
+        |    |->scene01/
+        |    |->scene02/
+        |    |->...
+        |->test/
+        |    |->scene01/
+        |    |->scene02/
+        |    |->...
+        |->train.list
+        |->test.list
+```
+DATA_ROOT is your path containing the counting datasets.
+
+### Annotations format
+For the annotations of each image, we use a single txt file which contains one annotation per line. Note that indexing for pixel values starts at 0. The expected format of each line is:
+```
+x1 y1
+x2 y2
+...
+```
+
+## Training
+
+The network can be trained using the `train.py` script. For training on SHTechPartA, use
+
+```
+CUDA_VISIBLE_DEVICES=0 python train.py --data_root $DATA_ROOT \
+    --dataset_file SHHA \
+    --epochs 3500 \
+    --lr_drop 3500 \
+    --output_dir ./logs \
+    --checkpoints_dir ./weights \
+    --tensorboard_dir ./logs \
+    --lr 0.0001 \
+    --lr_backbone 0.00001 \
+    --batch_size 8 \
+    --eval_freq 1 \
+    --gpu_id 0
+```
+By default, a periodic evaluation will be conducted on the validation set.
+
+## Testing
+
+A trained model (with an MAE of **51.96**) on SHTechPartA is available at "./weights", run the following commands to launch a visualization demo:
+
+```
+CUDA_VISIBLE_DEVICES=0 python run_test.py --weight_path ./weights/SHTechA.pth --output_dir ./logs/
+```
+
+## Civic Pulse Application
+
+The supported application stack in this repository is:
+
+- FastAPI backend in `api.py`
+- React/Vite frontend in `frontend/`
+
+The application loads `weights/SHTechA.pth` by default.
+
+For this application, use the pretrained P2PNet weights directly for inference. Manual point-labeling and one-image fine-tuning are not part of the recommended workflow because they are too small and unstable to improve model quality.
+
+## Acknowledgements
+
+- Part of codes are borrowed from the [C^3 Framework](https://github.com/gjy3035/C-3-Framework).
+- We refer to [DETR](https://github.com/facebookresearch/detr) to implement our matching strategy.
+
+
+## Citing P2PNet
+
+If you find P2PNet is useful in your project, please consider citing us:
+
+```BibTeX
+@inproceedings{song2021rethinking,
+  title={Rethinking Counting and Localization in Crowds: A Purely Point-Based Framework},
+  author={Song, Qingyu and Wang, Changan and Jiang, Zhengkai and Wang, Yabiao and Tai, Ying and Wang, Chengjie and Li, Jilin and Huang, Feiyue and Wu, Yang},
+  journal={Proceedings of the IEEE/CVF International Conference on Computer Vision},
+  year={2021}
+}
+```
+
+## Related works from Tencent Youtu Lab
+- [AAAI2021] To Choose or to Fuse? Scale Selection for Crowd Counting. ([paper link](https://ojs.aaai.org/index.php/AAAI/article/view/16360) & [codes](https://github.com/TencentYoutuResearch/CrowdCounting-SASNet))
+- [ICCV2021] Uniformity in Heterogeneity: Diving Deep into Count Interval Partition for Crowd Counting. ([paper link](https://arxiv.org/abs/2107.12619) & [codes](https://github.com/TencentYoutuResearch/CrowdCounting-UEPNet))

alert_system.py

@@ -0,0 +1,16 @@
+import streamlit as st
+
+def render_alert(current_unique_count, threshold):
+    # Safety Check: If threshold is 0 somehow to avoid div zero error
+    if threshold <= 0:
+        threshold = 1
+        
+    ratio = current_unique_count / threshold
+    if ratio >= 1.0:
+        st.error(f"🔴 CRITICAL ALERT: Venue Capacity Exceeded! ({current_unique_count:,} / {threshold:,})")
+    elif ratio >= 0.85:
+        st.warning(f"🟠 WARNING: Venue Capacity Nearing Limit! ({current_unique_count:,} / {threshold:,})")
+    elif ratio >= 0.70:
+        st.info(f"🟡 ADVISORY: Venue Filling Up. ({current_unique_count:,} / {threshold:,})")
+    else:
+        st.success(f"🟢 Venue Status Normal. ({current_unique_count:,} / {threshold:,})")

api.py

@@ -0,0 +1,529 @@
+import os
+os.environ.setdefault('OMP_NUM_THREADS', '5')  # Suppress sklearn KMeans MKL memory leak warning on Windows
+from download_weights import ensure_weights
+import io
+import time
+import shutil
+import base64
+import json
+import asyncio
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+import torch
+import torchvision.transforms as standard_transforms
+import numpy as np
+from PIL import Image
+import cv2
+from sklearn.cluster import KMeans
+from sqlmodel import Session
+
+from models import build_model
+from tracker import Tracker
+from database import init_db, engine, FlightReport
+
+app = FastAPI()
+
+# Allow both local dev and the deployed Vercel frontend.
+# The ALLOWED_ORIGINS env var can be set on HF Spaces to your exact Vercel URL.
+_raw_origins = os.environ.get(
+    "ALLOWED_ORIGINS",
+    "http://localhost:5173,http://127.0.0.1:5173,http://localhost:4173,http://127.0.0.1:4173,http://localhost:3000,http://127.0.0.1:3000"
+)
+ALLOWED_ORIGINS = [o.strip() for o in _raw_origins.split(",") if o.strip()]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_origin_regex=r"https://.*\.vercel\.app",   # matches any Vercel deployment
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+TEMP_DIR = os.path.join(BASE_DIR, "temp_uploads")
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+class Args:
+    def __init__(self):
+        self.backbone = 'vgg16_bn'
+        self.row = 2
+        self.line = 2
+
+model = None
+device = None
+transform = None
+
+@app.get("/")
+async def health_check():
+    """Health check — HuggingFace Spaces pings this to confirm the app is alive."""
+    return {"status": "ok", "model_loaded": model is not None}
+
+
+@app.on_event("startup")
+async def startup_event():
+    # Download weights from HuggingFace Hub if not present locally
+    ensure_weights()
+    init_db()
+    
+    global model, device, transform
+    device_type = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    if device_type.type == 'cuda':
+        torch.backends.cudnn.benchmark = True
+        
+    args = Args()
+    model_obj = build_model(args)
+    model_obj.to(device_type)
+    if device_type.type == 'cuda':
+        model_obj.to(memory_format=torch.channels_last)
+    
+    weight_path = os.path.join(BASE_DIR, 'weights', 'SHTechA.pth')
+    if os.path.exists(weight_path):
+        checkpoint = torch.load(weight_path, map_location=device_type)
+        model_obj.load_state_dict(checkpoint['model'])
+    
+    model_obj.eval()
+    
+    transform_obj = standard_transforms.Compose([
+        standard_transforms.ToTensor(), 
+        standard_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    
+    model = model_obj
+    device = device_type
+    transform = transform_obj
+
+def score_aware_merge(predictions, radius, orig_width, orig_height):
+    if not predictions: return []
+    predictions = sorted(predictions, key=lambda item: item[2], reverse=True)
+    final_points = []
+    radius_sq = radius * radius
+    for x, y, _ in predictions:
+        if not (0 <= x < orig_width and 0 <= y < orig_height): continue
+        duplicate = False
+        for fx, fy in final_points:
+            if (x - fx) ** 2 + (y - fy) ** 2 <= radius_sq:
+                duplicate = True
+                break
+        if not duplicate:
+            final_points.append([float(x), float(y)])
+    return final_points
+
+def round_to_stride(value, stride=128):
+    return max(stride, int(np.ceil(value / stride) * stride))
+
+def process_frame(img_raw, model, device, transform, threshold, max_dim=3840, magnification=1.5, patch_size=512, nms_radius=8.0, batch_size=8, patch_overlap=0.25, inference_strategy="Auto", full_frame_max_dim=1800, fencing_poly=None):
+    orig_width, orig_height = img_raw.size
+    work_width = int(orig_width * magnification)
+    work_height = int(orig_height * magnification)
+    
+    if max_dim is not None and (work_width > max_dim or work_height > max_dim):
+        scale = max_dim / float(max(work_width, work_height))
+        work_width = int(work_width * scale)
+        work_height = int(work_height * scale)
+        magnification = work_width / float(orig_width)
+        
+    resample_filter = getattr(Image, 'Resampling', Image).LANCZOS if hasattr(Image, 'Resampling') else getattr(Image, 'ANTIALIAS', 1)
+    img_magnified = img_raw.resize((work_width, work_height), resample_filter)
+
+    use_single_pass = inference_strategy == "Single Pass" or (inference_strategy == "Auto" and max(work_width, work_height) <= full_frame_max_dim)
+
+    final_points = []
+    if use_single_pass:
+        model_width = round_to_stride(work_width)
+        model_height = round_to_stride(work_height)
+        scale_x = model_width / float(orig_width)
+        scale_y = model_height / float(orig_height)
+        model_img = img_raw.resize((model_width, model_height), resample_filter)
+        samples = transform(model_img).unsqueeze(0).to(device, non_blocking=True)
+        if device.type == 'cuda': samples = samples.contiguous(memory_format=torch.channels_last)
+
+        with torch.inference_mode():
+            if device.type == 'cuda':
+                with torch.cuda.amp.autocast(): outputs = model(samples)
+            else: outputs = model(samples)
+
+        scores = torch.nn.functional.softmax(outputs['pred_logits'].float(), -1)[:, :, 1][0]
+        points = outputs['pred_points'][0].float()
+        mask = scores > threshold
+        selected_points = points[mask].detach().cpu().numpy()
+        selected_scores = scores[mask].detach().cpu().numpy()
+        predictions = []
+        for point, score in zip(selected_points, selected_scores):
+            predictions.append([point[0] / scale_x, point[1] / scale_y, float(score)])
+        final_points = score_aware_merge(predictions, nms_radius, orig_width, orig_height)
+    else:
+        pad_border = 256
+        new_width = ((work_width + (pad_border * 2) + patch_size - 1) // patch_size) * patch_size
+        new_height = ((work_height + (pad_border * 2) + patch_size - 1) // patch_size) * patch_size
+        
+        img_padded = Image.new('RGB', (new_width, new_height), (0, 0, 0))
+        img_padded.paste(img_magnified, (pad_border, pad_border))
+        
+        all_predictions = []
+        patch_overlap = min(max(float(patch_overlap), 0.0), 0.75)
+        stride = max(64, int(patch_size * (1.0 - patch_overlap)))
+        patch_jobs = []
+        
+        for y in range(0, new_height - stride + 1, stride):
+            for x in range(0, new_width - stride + 1, stride):
+                if y + patch_size > new_height or x + patch_size > new_width: continue
+                patch = img_padded.crop((x, y, x + patch_size, y + patch_size))
+                patch_jobs.append((x, y, patch))
+
+        total_patches = len(patch_jobs)
+        batch_size = max(1, int(batch_size))
+
+        for start_idx in range(0, total_patches, batch_size):
+            batch_jobs = patch_jobs[start_idx:start_idx + batch_size]
+            patch_tensors = [transform(patch) for _, _, patch in batch_jobs]
+            samples = torch.stack(patch_tensors, dim=0).to(device, non_blocking=True)
+            if device.type == 'cuda': samples = samples.contiguous(memory_format=torch.channels_last)
+
+            with torch.inference_mode():
+                if device.type == 'cuda':
+                    with torch.cuda.amp.autocast(): outputs = model(samples)
+                else: outputs = model(samples)
+
+            outputs_scores = torch.nn.functional.softmax(outputs['pred_logits'].float(), -1)[:, :, 1]
+            outputs_points = outputs['pred_points'].float()
+
+            for batch_idx, (x, y, _) in enumerate(batch_jobs):
+                mask = outputs_scores[batch_idx] > threshold
+                points = outputs_points[batch_idx][mask].detach().cpu().numpy()
+                scores = outputs_scores[batch_idx][mask].detach().cpu().numpy()
+
+                if len(points) > 0:
+                    points[:, 0] += (x - pad_border)
+                    points[:, 1] += (y - pad_border)
+                    points = points / float(magnification)
+                    for point, score in zip(points, scores):
+                        all_predictions.append([point[0], point[1], float(score)])
+
+        final_points = score_aware_merge(all_predictions, nms_radius, orig_width, orig_height)
+
+    # Smart Zone Fencing filter
+    if fencing_poly and len(fencing_poly) > 2:
+        poly_arr = np.array([[p['x']*orig_width, p['y']*orig_height] for p in fencing_poly], dtype=np.int32)
+        filtered_pts = []
+        for pt in final_points:
+            # check if point is inside
+            if cv2.pointPolygonTest(poly_arr, (pt[0], pt[1]), False) >= 0:
+                filtered_pts.append(pt)
+        final_points = filtered_pts
+
+    return img_raw, len(final_points), final_points
+
+def process_frame_with_oom_recovery(*args, batch_size=8, **kwargs):
+    current_batch_size = max(1, int(batch_size))
+    while current_batch_size >= 1:
+        try:
+            return process_frame(*args, batch_size=current_batch_size, **kwargs), current_batch_size
+        except RuntimeError as exc:
+            if "out of memory" not in str(exc).lower(): raise
+            if torch.cuda.is_available(): torch.cuda.empty_cache()
+            if current_batch_size == 1: raise
+            current_batch_size = max(1, current_batch_size // 2)
+
+def generate_colors(n):
+    colors = []
+    base_hues = [30, 90, 150, 210, 270, 330]
+    for i in range(n):
+        h = base_hues[i % len(base_hues)]
+        hsv = np.uint8([[[h, 255, 255]]])
+        bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)[0][0]
+        colors.append((int(bgr[0]), int(bgr[1]), int(bgr[2])))
+    return colors
+
+def draw_points(img, points, use_heatmap=False, use_clustering=False, use_motion_vectors=False, prev_points=None):
+    img_bgr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+    
+    if use_heatmap:
+        h, w = img_bgr.shape[:2]
+        heatmap = np.zeros((h, w), dtype=np.float32)
+        for p in points:
+            px, py = int(p[0]), int(p[1])
+            if 0 <= px < w and 0 <= py < h:
+                r = 15
+                x_min, x_max = max(0, px-r), min(w, px+r+1)
+                y_min, y_max = max(0, py-r), min(h, py+r+1)
+                y, x = np.ogrid[y_min:y_max, x_min:x_max]
+                mask = np.exp(-((x - px)**2 + (y - py)**2) / (2 * 5**2))
+                heatmap[y_min:y_max, x_min:x_max] += mask
+        heatmap = np.clip(heatmap * 100, 0, 255).astype(np.uint8)
+        color_map = cv2.applyColorMap(heatmap, cv2.COLORMAP_INFERNO)
+        mask = (heatmap > 10).astype(np.float32)[:, :, np.newaxis]
+        img_bgr = (img_bgr * (1 - mask * 0.7) + color_map * (mask * 0.7)).astype(np.uint8)
+        
+    elif use_clustering and len(points) >= 3:
+        num_clusters = min(len(points) // 10 + 1, 5)
+        # Guard: KMeans requires n_clusters <= n_samples
+        num_clusters = max(1, min(num_clusters, len(points)))
+        if num_clusters > 1:
+            pts_array = np.array([[p[0], p[1]] for p in points])
+            try:
+                kmeans = KMeans(n_clusters=num_clusters, n_init='auto', random_state=42).fit(pts_array)
+                labels = kmeans.labels_
+                colors = generate_colors(num_clusters)
+                for i, p in enumerate(points):
+                    cv2.circle(img_bgr, (int(p[0]), int(p[1])), 3, colors[labels[i]], -1)
+                for c in range(num_clusters):
+                    cluster_pts = pts_array[labels == c].astype(np.int32)
+                    if len(cluster_pts) >= 3:
+                        hull = cv2.convexHull(cluster_pts)
+                        cv2.polylines(img_bgr, [hull], True, colors[c], 2)
+            except Exception:
+                # Fallback to plain dots if clustering fails for any reason
+                for p in points: cv2.circle(img_bgr, (int(p[0]), int(p[1])), 2, (184, 230, 0), -1)
+        else:
+            for p in points: cv2.circle(img_bgr, (int(p[0]), int(p[1])), 2, (184, 230, 0), -1)
+    else:
+        for p in points:
+            cv2.circle(img_bgr, (int(p[0]), int(p[1])), 2, (184, 230, 0), -1)
+
+    # GAP 5: Motion Vectors — draw arrows from prev positions to current
+    if use_motion_vectors and prev_points and len(prev_points) > 0 and len(points) > 0:
+        cur_arr  = np.array([[p[0], p[1]] for p in points],      dtype=np.float32)
+        prev_arr = np.array([[p[0], p[1]] for p in prev_points], dtype=np.float32)
+        # Match nearest neighbours between prev and current
+        for pp in prev_arr:
+            dists = np.sum((cur_arr - pp) ** 2, axis=1)
+            nearest_idx = int(np.argmin(dists))
+            if dists[nearest_idx] < 2500:  # max 50px movement
+                cp = cur_arr[nearest_idx]
+                dx, dy = float(cp[0] - pp[0]), float(cp[1] - pp[1])
+                if abs(dx) > 1 or abs(dy) > 1:  # only draw if actually moved
+                    speed = (dx**2 + dy**2) ** 0.5
+                    # Color from green (slow) to amber (fast)
+                    t = min(speed / 30.0, 1.0)
+                    color = (
+                        int(11 * (1 - t) + 11 * t),
+                        int(230 * (1 - t) + 158 * t),
+                        int(184 * (1 - t) + 245 * t)
+                    )
+                    cv2.arrowedLine(
+                        img_bgr,
+                        (int(pp[0]), int(pp[1])),
+                        (int(cp[0]), int(cp[1])),
+                        color, 1, tipLength=0.3
+                    )
+            
+    return img_bgr
+
+@app.post("/api/upload-video")
+async def upload_video(file: UploadFile = File(...)):
+    # Sanitize filename to remove spaces/special chars that break WebSocket URLs
+    safe_name = "".join(c if c.isalnum() or c in '._-' else '_' for c in (file.filename or 'video'))
+    file_id = f"vid_{int(time.time())}_{safe_name}"
+    file_path = os.path.join(TEMP_DIR, file_id)
+    # Stream-write in chunks to avoid loading entire video into RAM
+    try:
+        with open(file_path, "wb") as out_f:
+            while True:
+                chunk = await file.read(1024 * 1024)  # 1 MB chunks
+                if not chunk:
+                    break
+                out_f.write(chunk)
+    except Exception as exc:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        raise HTTPException(status_code=500, detail=f"Video upload failed: {exc}")
+    return {"file_id": file_id, "size": os.path.getsize(file_path)}
+
+@app.websocket("/api/stream-video/{file_id}")
+async def stream_video(websocket: WebSocket, file_id: str):
+    await websocket.accept()
+    file_path = os.path.join(TEMP_DIR, file_id)
+
+    if not os.path.exists(file_path):
+        await websocket.send_json({"status": "error", "message": "Video file not found on server. Please upload again."})
+        await websocket.close()
+        return
+
+    # Guard: model must be loaded
+    if model is None:
+        await websocket.send_json({"status": "error", "message": "AI model not loaded yet. Please wait and retry."})
+        await websocket.close()
+        return
+
+    cap = None
+    try:
+        data = await websocket.receive_json()
+        settings_payload = data.get("settings", {})
+
+        confidence_threshold = float(settings_payload.get("confidenceThresh", 0.35))
+        magnification        = float(settings_payload.get("magnification", 1.5))
+        nms_radius           = float(settings_payload.get("nmsRadius", 9.0))
+        use_heatmap          = bool(settings_payload.get("useHeatmap", False))
+        use_clustering       = bool(settings_payload.get("useClustering", False))
+        use_motion_vecs      = bool(settings_payload.get("useMotionVecs", False))
+        fencing_poly         = settings_payload.get("fencingPolygon", [])
+        frame_skip           = max(1, int(settings_payload.get("frameSkip", 3)))
+        patch_overlap        = 0.25
+        capacity_limit       = int(settings_payload.get("capacityLimit", 150))
+
+        cap = cv2.VideoCapture(file_path)
+        if not cap.isOpened():
+            await websocket.send_json({"status": "error", "message": f"Cannot open video file. Format may not be supported by OpenCV."})
+            return
+
+        total_video_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 1
+        tracker = Tracker(max_distance=50.0, max_age=5)
+
+        frames_processed  = 0
+        total_unique      = 0
+        peak_crowd        = 0
+        total_anomalies   = 0
+        capacity_breached = False
+        prev_raw_points   = []
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            if frames_processed % frame_skip == 0:
+                try:
+                    img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    pil_img = Image.fromarray(img_rgb)
+
+                    (_, count, raw_points), _ = process_frame_with_oom_recovery(
+                        pil_img, model, device, transform, confidence_threshold,
+                        max_dim=1920, magnification=magnification, nms_radius=nms_radius,
+                        batch_size=4, patch_overlap=patch_overlap, inference_strategy="Auto",
+                        fencing_poly=fencing_poly
+                    )
+
+                    if count > peak_crowd:      peak_crowd = count
+                    if count > capacity_limit:  capacity_breached = True
+
+                    img_bgr = draw_points(pil_img, raw_points, use_heatmap, use_clustering,
+                                          use_motion_vecs, prev_raw_points)
+                    prev_raw_points = raw_points[:]
+
+                    active_tracks, cumulative_unique, anomaly = tracker.update(img_bgr, raw_points)
+                    total_unique = cumulative_unique
+                    if anomaly:
+                        total_anomalies += 1
+
+                    for t in active_tracks:
+                        color = (11, 158, 245) if (anomaly and hasattr(t, 'velocity') and t.velocity > 35) else (0, 255, 255)
+                        cv2.circle(img_bgr, (int(t.pt[0]), int(t.pt[1])), 4, color, -1)
+
+                    _, buffer   = cv2.imencode('.jpg', img_bgr, [cv2.IMWRITE_JPEG_QUALITY, 80])
+                    encoded_img = base64.b64encode(buffer).decode('utf-8')
+
+                    progress = round(frames_processed / total_video_frames * 100)
+                    await websocket.send_json({
+                        "status":       "playing",
+                        "frame":        frames_processed,
+                        "count":        count,
+                        "total_unique": total_unique,
+                        "anomalyEvent": anomaly,
+                        "progress":     progress,
+                        "imageB64":     encoded_img
+                    })
+
+                except Exception as frame_err:
+                    print(f"[Frame {frames_processed} error]: {frame_err}")
+                    # Skip this frame and continue rather than crashing the whole stream
+
+            frames_processed += 1
+            await asyncio.sleep(0.001)
+
+        # Release BEFORE any file operations so Windows unlocks it
+        cap.release()
+        cap = None
+
+        # Log to DB
+        try:
+            with Session(engine) as db_session:
+                record = FlightReport(
+                    filename=file_id,
+                    max_capacity_breached=capacity_breached,
+                    peak_crowd_count=peak_crowd,
+                    duration_frames=frames_processed,
+                    chaos_anomalies=total_anomalies
+                )
+                db_session.add(record)
+                db_session.commit()
+        except Exception as db_err:
+            print(f"[DB error]: {db_err}")
+
+        await websocket.send_json({"status": "done", "total_unique": total_unique})
+
+    except WebSocketDisconnect:
+        print("[WebSocket] client disconnected")
+    except Exception as e:
+        print(f"[Stream error]: {e}")
+        try:
+            await websocket.send_json({"status": "error", "message": str(e)})
+        except Exception:
+            pass
+    finally:
+        # Make sure cap is released before file deletion
+        if cap is not None:
+            cap.release()
+        # Retry deletion — Windows may keep handle briefly after cap.release()
+        for _attempt in range(5):
+            try:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                break
+            except PermissionError:
+                import time as _t
+                _t.sleep(0.3)
+
+
+@app.post("/api/process-image")
+async def process_image_api(
+    file: UploadFile = File(...),
+    confidence_threshold: float = Form(0.35),
+    magnification: float = Form(1.5),
+    nms_radius: float = Form(9.0),
+    use_heatmap: str = Form("false"),
+    use_clustering: str = Form("false"),
+    use_motion_vectors: str = Form("false"),
+    fencing_polygon: str = Form("[]"),
+    inference_batch_size: int = Form(8),
+    patch_overlap: float = Form(0.25),
+    max_resolution: int = Form(3840),
+    inference_strategy: str = Form("Auto")
+):
+    try:
+        fencing_poly = json.loads(fencing_polygon) if fencing_polygon else []
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents)).convert('RGB')
+        
+        start_time = time.perf_counter()
+        
+        (processed_img, count, points), used_batch_size = process_frame_with_oom_recovery(
+            image, model, device, transform, confidence_threshold,
+            max_dim=max_resolution, magnification=magnification,
+            nms_radius=nms_radius, batch_size=inference_batch_size,
+            patch_overlap=patch_overlap, inference_strategy=inference_strategy,
+            fencing_poly=fencing_poly
+        )
+        
+        elapsed = time.perf_counter() - start_time
+        img_bgr = draw_points(
+            image, points,
+            use_heatmap.lower() == 'true',
+            use_clustering.lower() == 'true',
+            use_motion_vectors.lower() == 'true',
+            None  # no prev_points for single image
+        )
+            
+        _, buffer = cv2.imencode('.jpg', img_bgr)
+        encoded_img = base64.b64encode(buffer).decode('utf-8')
+        
+        return {
+            "count": count, "elapsed": elapsed,
+            "usedBatchSize": used_batch_size, "imageB64": encoded_img
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=False)

app.py

@@ -0,0 +1,606 @@
+import streamlit as st
+import cv2
+import torch
+import torchvision.transforms as standard_transforms
+import numpy as np
+from PIL import Image
+import os
+import tempfile
+import time
+import warnings
+warnings.filterwarnings('ignore')
+
+from tracker import Tracker
+from report_generator import ReportGenerator
+from alert_system import render_alert
+
+from app_enhancements import confidence_interval, load_config, save_config
+from models import build_model
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_PATH = os.path.join(BASE_DIR, "civic_pulse_config.json")
+MODE_SETTINGS = {
+    "Fast": {
+        "patch_overlap": 0.0,
+        "frame_skip": 5,
+        "magnification": 1.25,
+        "confidence_threshold": 0.5,
+        "nms_radius": 10.0,
+        "tracker_max_distance": 65.0,
+        "inference_batch_size": 16,
+    },
+    "Balanced": {
+        "patch_overlap": 0.25,
+        "frame_skip": 2,
+        "magnification": 1.5,
+        "confidence_threshold": 0.35,
+        "nms_radius": 9.0,
+        "tracker_max_distance": 55.0,
+        "inference_batch_size": 8,
+    },
+    "Accurate": {
+        "patch_overlap": 0.5,
+        "frame_skip": 1,
+        "magnification": 2.0,
+        "confidence_threshold": 0.25,
+        "nms_radius": 7.0,
+        "tracker_max_distance": 45.0,
+        "inference_batch_size": 4,
+    },
+}
+DEFAULT_CONFIG = {
+    "processing_mode": "Balanced",
+    "max_resolution": 3840,
+    "magnification": 1.5,
+    "confidence_threshold": 0.35,
+    "nms_radius": 9.0,
+    "tracker_max_distance": 55.0,
+    "inference_batch_size": 8,
+    "inference_strategy": "Auto",
+    "venue_capacity": 15000,
+}
+saved_config = load_config(CONFIG_PATH, DEFAULT_CONFIG)
+
+# Custom wrapper to provide args to the model builder
+class Args:
+    def __init__(self):
+        self.backbone = 'vgg16_bn'
+        self.row = 2
+        self.line = 2
+
+# Page Configuration
+st.set_page_config(page_title="Civic Pulse Dashboard", page_icon="🚁", layout="wide")
+
+st.title("🚁 Civic Pulse: Drone Crowd Monitor")
+st.markdown("Upload drone imagery or video for AI-based crowd counting using P2PNet.")
+
+# Sidebar Configuration
+st.sidebar.header("Processing Settings")
+processing_mode = st.sidebar.selectbox(
+    "Processing Mode",
+    ("Balanced", "Fast", "Accurate"),
+    index=("Balanced", "Fast", "Accurate").index(saved_config.get("processing_mode", "Balanced")),
+    help="Fast uses fewer overlapping patches. Accurate uses more overlap for better boundary coverage. Balanced is recommended."
+)
+preset_values = MODE_SETTINGS[processing_mode]
+use_preset_values = st.sidebar.checkbox(
+    "Use Recommended Detection Preset",
+    value=True,
+    help="Recommended for drone/top-down images. Turn off only if you want to manually tune every setting."
+)
+max_resolution = st.sidebar.slider("Max GPU Resolution Bounds", min_value=720, max_value=8000, value=int(saved_config.get("max_resolution", 3840)), step=120, help="Prevents RAM crashes. Patches are generated within this bound.")
+inference_strategy = st.sidebar.selectbox(
+    "Inference Strategy",
+    ("Auto", "Single Pass", "Tiled"),
+    index=("Auto", "Single Pass", "Tiled").index(saved_config.get("inference_strategy", "Auto")),
+    help="Single Pass is much faster for normal images. Tiled is only for very large images. Auto chooses for you."
+)
+if use_preset_values:
+    magnification = preset_values["magnification"]
+    confidence_threshold = preset_values["confidence_threshold"]
+    nms_radius = preset_values["nms_radius"]
+    tracker_max_distance = preset_values["tracker_max_distance"]
+    inference_batch_size = preset_values["inference_batch_size"]
+    st.sidebar.info(
+        f"Preset active: magnification {magnification}x, confidence {confidence_threshold}, "
+        f"merge radius {nms_radius}px, batch {inference_batch_size}."
+    )
+else:
+    magnification = st.sidebar.slider("Micro-Target Magnification", min_value=1.0, max_value=3.0, value=float(saved_config.get("magnification", preset_values["magnification"])), step=0.1, help="Scales up tiny drone targets so the AI can physically see them.")
+    confidence_threshold = st.sidebar.slider("Confidence Threshold", min_value=0.05, max_value=1.0, value=float(saved_config.get("confidence_threshold", preset_values["confidence_threshold"])), step=0.05, help="Decrease to catch missed people, increase to reduce false positives.")
+    nms_radius = st.sidebar.slider("Duplicate Merge Radius (px)", min_value=2.0, max_value=30.0, value=float(saved_config.get("nms_radius", preset_values["nms_radius"])), step=1.0, help="Merges overlapping patch detections. Increase if duplicate dots appear.")
+    tracker_max_distance = st.sidebar.slider("Tracker Match Radius (px)", min_value=10.0, max_value=150.0, value=float(saved_config.get("tracker_max_distance", preset_values["tracker_max_distance"])), step=5.0, help="Maximum motion allowed when matching people between processed video frames.")
+    inference_batch_size = st.sidebar.slider("P2PNet Patch Batch Size", min_value=1, max_value=32, value=int(saved_config.get("inference_batch_size", preset_values["inference_batch_size"])), step=1, help="Processes tiled patches in batches for faster P2PNet inference. Lower it if memory is limited.")
+input_type = st.sidebar.radio("Select Input Type", ("Image", "Video"))
+uploaded_file = st.sidebar.file_uploader(f"Upload {input_type}", type=["png", "jpg", "jpeg"] if input_type == "Image" else ["mp4", "avi", "mov"])
+
+st.sidebar.markdown("---")
+st.sidebar.header("Alert Settings")
+venue_capacity = st.sidebar.slider("Venue Max Capacity", min_value=100, max_value=50000, value=int(saved_config.get("venue_capacity", 15000)), step=100)
+if st.sidebar.button("Save Current Settings"):
+    save_config(CONFIG_PATH, {
+        "processing_mode": processing_mode,
+        "max_resolution": max_resolution,
+        "magnification": magnification,
+        "confidence_threshold": confidence_threshold,
+        "nms_radius": nms_radius,
+        "tracker_max_distance": tracker_max_distance,
+        "inference_batch_size": inference_batch_size,
+        "inference_strategy": inference_strategy,
+        "venue_capacity": venue_capacity,
+    })
+    st.sidebar.success("Settings saved.")
+
+
+@st.cache_resource
+def load_model():
+    """Load the P2PNet model into GPU if available."""
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    if device.type == 'cuda':
+        torch.backends.cudnn.benchmark = True
+        
+    args = Args()
+    model = build_model(args)
+    model.to(device)
+    if device.type == 'cuda':
+        model.to(memory_format=torch.channels_last)
+    
+    # Load weights
+    weight_path = os.path.join(BASE_DIR, 'weights', 'SHTechA.pth')
+    if os.path.exists(weight_path):
+        checkpoint = torch.load(weight_path, map_location=device)
+        model.load_state_dict(checkpoint['model'])
+    else:
+        st.sidebar.error(f"Weights not found at {weight_path}. Model will perform poorly.")
+    
+    model.eval()
+    
+    transform = standard_transforms.Compose([
+        standard_transforms.ToTensor(), 
+        standard_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    
+    return model, device, transform
+
+model, device, transform = load_model()
+
+def format_elapsed(seconds):
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes, remaining = divmod(seconds, 60)
+    return f"{int(minutes)}m {remaining:.1f}s"
+
+
+def score_aware_merge(predictions, radius, orig_width, orig_height):
+    if not predictions:
+        return []
+    predictions = sorted(predictions, key=lambda item: item[2], reverse=True)
+    final_points = []
+    radius_sq = radius * radius
+    for x, y, _ in predictions:
+        if not (0 <= x < orig_width and 0 <= y < orig_height):
+            continue
+        duplicate = False
+        for fx, fy in final_points:
+            if (x - fx) ** 2 + (y - fy) ** 2 <= radius_sq:
+                duplicate = True
+                break
+        if not duplicate:
+            final_points.append([float(x), float(y)])
+    return final_points
+
+
+def round_to_stride(value, stride=128):
+    return max(stride, int(np.ceil(value / stride) * stride))
+
+
+def process_frame(
+    img_raw,
+    model,
+    device,
+    transform,
+    threshold,
+    max_dim=3840,
+    magnification=1.5,
+    patch_size=512,
+    nms_radius=8.0,
+    batch_size=8,
+    patch_overlap=0.25,
+    inference_strategy="Auto",
+    full_frame_max_dim=1800,
+    progress_callback=None,
+):
+    """Process a PIL Image using Multi-Scale Tiling Inference."""
+    orig_width, orig_height = img_raw.size
+    
+    # 1. Magnify
+    work_width = int(orig_width * magnification)
+    work_height = int(orig_height * magnification)
+    
+    if max_dim is not None and (work_width > max_dim or work_height > max_dim):
+        scale = max_dim / float(max(work_width, work_height))
+        work_width = int(work_width * scale)
+        work_height = int(work_height * scale)
+        magnification = work_width / float(orig_width)
+        
+    resample_filter = getattr(Image, 'Resampling', Image).LANCZOS if hasattr(Image, 'Resampling') else getattr(Image, 'ANTIALIAS', 1)
+    img_magnified = img_raw.resize((work_width, work_height), resample_filter)
+
+    use_single_pass = inference_strategy == "Single Pass" or (
+        inference_strategy == "Auto" and max(work_width, work_height) <= full_frame_max_dim
+    )
+
+    if use_single_pass:
+        model_width = round_to_stride(work_width)
+        model_height = round_to_stride(work_height)
+        scale_x = model_width / float(orig_width)
+        scale_y = model_height / float(orig_height)
+        model_img = img_raw.resize((model_width, model_height), resample_filter)
+        samples = transform(model_img).unsqueeze(0).to(device, non_blocking=True)
+        if device.type == 'cuda':
+            samples = samples.contiguous(memory_format=torch.channels_last)
+
+        with torch.inference_mode():
+            if device.type == 'cuda':
+                with torch.cuda.amp.autocast():
+                    outputs = model(samples)
+            else:
+                outputs = model(samples)
+
+        scores = torch.nn.functional.softmax(outputs['pred_logits'].float(), -1)[:, :, 1][0]
+        points = outputs['pred_points'][0].float()
+        mask = scores > threshold
+        selected_points = points[mask].detach().cpu().numpy()
+        selected_scores = scores[mask].detach().cpu().numpy()
+        predictions = []
+        for point, score in zip(selected_points, selected_scores):
+            predictions.append([point[0] / scale_x, point[1] / scale_y, float(score)])
+        if progress_callback is not None:
+            progress_callback(1.0, 1, 1)
+        final_points = score_aware_merge(predictions, nms_radius, orig_width, orig_height)
+        return img_raw, len(final_points), final_points
+    
+    # 2. Symmetrical Boundary Padding to eliminate corner-blindness
+    pad_border = 256
+    new_width = ((work_width + (pad_border * 2) + patch_size - 1) // patch_size) * patch_size
+    new_height = ((work_height + (pad_border * 2) + patch_size - 1) // patch_size) * patch_size
+    
+    img_padded = Image.new('RGB', (new_width, new_height), (0, 0, 0))
+    img_padded.paste(img_magnified, (pad_border, pad_border))
+    
+    all_predictions = []
+    patch_overlap = min(max(float(patch_overlap), 0.0), 0.75)
+    stride = max(64, int(patch_size * (1.0 - patch_overlap)))
+    patch_jobs = []
+    
+    # 3. Patch Gridding Inference
+    for y in range(0, new_height - stride + 1, stride):
+        for x in range(0, new_width - stride + 1, stride):
+            if y + patch_size > new_height or x + patch_size > new_width: continue
+            patch = img_padded.crop((x, y, x + patch_size, y + patch_size))
+            patch_jobs.append((x, y, patch))
+
+    total_patches = len(patch_jobs)
+    batch_size = max(1, int(batch_size))
+
+    for start_idx in range(0, total_patches, batch_size):
+        batch_jobs = patch_jobs[start_idx:start_idx + batch_size]
+        patch_tensors = [transform(patch) for _, _, patch in batch_jobs]
+        samples = torch.stack(patch_tensors, dim=0).to(device, non_blocking=True)
+        if device.type == 'cuda':
+            samples = samples.contiguous(memory_format=torch.channels_last)
+
+        with torch.inference_mode():
+            if device.type == 'cuda':
+                with torch.cuda.amp.autocast():
+                    outputs = model(samples)
+            else:
+                outputs = model(samples)
+
+        outputs_scores = torch.nn.functional.softmax(outputs['pred_logits'].float(), -1)[:, :, 1]
+        outputs_points = outputs['pred_points'].float()
+
+        for batch_idx, (x, y, _) in enumerate(batch_jobs):
+            mask = outputs_scores[batch_idx] > threshold
+            points = outputs_points[batch_idx][mask].detach().cpu().numpy()
+            scores = outputs_scores[batch_idx][mask].detach().cpu().numpy()
+
+            if len(points) > 0:
+                # Subtract the padding offset to map correctly back to original frame
+                points[:, 0] += (x - pad_border)
+                points[:, 1] += (y - pad_border)
+                points = points / float(magnification)
+                for point, score in zip(points, scores):
+                    all_predictions.append([point[0], point[1], float(score)])
+
+        if progress_callback is not None and total_patches > 0:
+            done = min(start_idx + len(batch_jobs), total_patches)
+            progress_callback(done / total_patches, done, total_patches)
+                
+    final_points = score_aware_merge(all_predictions, nms_radius, orig_width, orig_height)
+                
+    return img_raw, len(final_points), final_points
+
+
+def process_frame_with_oom_recovery(*args, batch_size=8, **kwargs):
+    current_batch_size = max(1, int(batch_size))
+    while current_batch_size >= 1:
+        try:
+            result = process_frame(*args, batch_size=current_batch_size, **kwargs)
+            return result, current_batch_size
+        except RuntimeError as exc:
+            if "out of memory" not in str(exc).lower():
+                raise
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            if current_batch_size == 1:
+                raise
+            current_batch_size = max(1, current_batch_size // 2)
+
+
+# Main Interface
+if uploaded_file is not None:
+    if input_type == "Image":
+        col1, col2 = st.columns(2)
+        
+        # Original Image
+        image = Image.open(uploaded_file).convert('RGB')
+        col1.subheader("Original Image")
+        col1.image(image, use_container_width=True)
+        
+        # Processing
+        if st.sidebar.button("Process Image"):
+            image_progress = st.progress(0)
+            image_status = st.empty()
+            image_start = time.perf_counter()
+
+            def update_image_progress(ratio, done, total):
+                elapsed = time.perf_counter() - image_start
+                image_progress.progress(ratio)
+                image_status.text(f"Processing image patches: {done}/{total} ({ratio * 100:.1f}%) | Elapsed: {format_elapsed(elapsed)}")
+
+            (processed_img, count, points), used_batch_size = process_frame_with_oom_recovery(
+                image,
+                model,
+                device,
+                transform,
+                confidence_threshold,
+                max_dim=max_resolution,
+                magnification=magnification,
+                nms_radius=nms_radius,
+                batch_size=inference_batch_size,
+                patch_overlap=MODE_SETTINGS[processing_mode]["patch_overlap"],
+                inference_strategy=inference_strategy,
+                progress_callback=update_image_progress,
+            )
+            image_elapsed = time.perf_counter() - image_start
+            image_progress.progress(1.0)
+            image_status.text(f"Image processing complete: 100.0% | Processed time: {format_elapsed(image_elapsed)}")
+            
+            img_draw = cv2.cvtColor(np.array(processed_img), cv2.COLOR_RGB2BGR)
+            for p in points:
+                cv2.circle(img_draw, (int(p[0]), int(p[1])), 2, (0, 0, 255), -1)
+                
+            img_draw_rgb = cv2.cvtColor(img_draw, cv2.COLOR_BGR2RGB)
+            
+            col2.subheader("Processed Analysis")
+            col2.image(img_draw_rgb, use_container_width=True)
+            st.sidebar.metric(label="Detected Crowd Count", value=count)
+            st.sidebar.metric(label="Processed Time", value=format_elapsed(image_elapsed))
+            st.sidebar.metric(label="Used Batch Size", value=used_batch_size)
+            if count < 10:
+                st.warning(
+                    "Low detection count. For top-down drone/crosswalk images, use Processing Mode = Accurate. "
+                    "If still low, turn off recommended preset and reduce Confidence Threshold toward 0.05."
+                )
+            
+    elif input_type == "Video":
+        st.subheader("Video Processing")
+        st.caption("Upload any supported video duration. Processing progress is calculated from the video's total frame count, not a fixed 30-second limit.")
+        
+        frame_skip = st.sidebar.slider(
+            "Frame Skip (Process Every Nth Frame)",
+            min_value=1,
+            max_value=30,
+            value=MODE_SETTINGS[processing_mode]["frame_skip"],
+            step=1,
+            help="Higher values process video faster by analyzing fewer frames. Processing Mode sets a good starting value."
+        )
+        
+        if st.sidebar.button("Process Video"):
+            # Save temp file because cv2.VideoCapture requires a file path
+            tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+            tfile.write(uploaded_file.getvalue())
+            tfile.close()  # Fixes Windows [WinError 32] lock
+
+            cap = cv2.VideoCapture(tfile.name)
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            if fps == 0:
+                fps = 30
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            if width <= 0 or height <= 0:
+                cap.release()
+                os.remove(tfile.name)
+                st.error("Could not read video dimensions. Please upload a valid video file.")
+                st.stop()
+            video_duration = total_frames / float(fps) if total_frames > 0 else 0
+            st.info(
+                f"Video loaded: {width}x{height}, {fps} FPS, "
+                f"{total_frames if total_frames > 0 else 'unknown'} frames"
+                f"{f', duration {format_elapsed(video_duration)}' if video_duration > 0 else ''}."
+            )
+            
+            # Ensure multiples of 2 for codecs
+            new_width = width if width % 2 == 0 else width - 1
+            new_height = height if height % 2 == 0 else height - 1
+            
+            tfile_out = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+            tfile_out.close()  # Fixes Windows [WinError 32] lock
+            # mp4v is a safe fallback codec for cv2.VideoWriter
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(tfile_out.name, fourcc, fps, (new_width, new_height))
+            
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            elapsed_text = st.empty()
+            video_start = time.perf_counter()
+            
+            peak_count = 0
+            frames_processed = 0
+            frames_analyzed = 0
+            crowd_timeline = []
+            analyzed_counts = []
+            live_count = 0
+            used_batch_size = inference_batch_size
+            last_out_frame = np.zeros((new_height, new_width, 3), dtype=np.uint8)
+            
+            # --- Analytics Inits ---
+            tracker = Tracker(max_distance=tracker_max_distance, max_age=5)
+            report = ReportGenerator()
+            total_unique = 0
+            
+            # Helper for consistent coloring based on unique ID
+            def get_color(track_id):
+                np.random.seed(track_id)
+                return tuple(int(x) for x in np.random.randint(0, 255, 3))
+            
+            while cap.isOpened():
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                # Check for frame skip optimization
+                if frames_processed % frame_skip == 0:
+                    # Convert cv2 frame (BGR) to PIL RGB
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    pil_img = Image.fromarray(frame_rgb)
+                    
+                    # Process single frame safely
+                    (img_out, live_count, raw_points), used_batch_size = process_frame_with_oom_recovery(
+                        pil_img,
+                        model,
+                        device,
+                        transform,
+                        confidence_threshold,
+                        max_dim=max_resolution,
+                        magnification=magnification,
+                        nms_radius=nms_radius,
+                        batch_size=inference_batch_size,
+                        patch_overlap=MODE_SETTINGS[processing_mode]["patch_overlap"],
+                        inference_strategy=inference_strategy,
+                    )
+                    frames_analyzed += 1
+                    analyzed_counts.append(live_count)
+                    
+                    img_out = img_out.resize((new_width, new_height))
+                    img_out_bgr = cv2.cvtColor(np.array(img_out), cv2.COLOR_RGB2BGR)
+                    
+                    # Track
+                    active_tracks, cumulative_unique, anomaly = tracker.update(img_out_bgr, raw_points)
+                    total_unique = cumulative_unique
+                    
+                    # Draw faintly all raw points
+                    for p in raw_points:
+                        cv2.circle(img_out_bgr, (int(p[0]), int(p[1])), 2, (0, 0, 100), -1)
+                        
+                    # Draw strongly unique IDs
+                    for t in active_tracks:
+                        color = get_color(t.id)
+                        cv2.circle(img_out_bgr, (int(t.pt[0]), int(t.pt[1])), 4, color, -1)
+                    if anomaly:
+                        st.warning("High motion anomaly detected in the current processed segment.")
+                        
+                    last_out_frame = img_out_bgr
+                    
+                    if live_count > peak_count:
+                        peak_count = live_count
+                        
+                    current_time_sec = frames_processed / float(fps)
+                    report.add_frame_data(frames_processed, current_time_sec, live_count, total_unique)
+                else:
+                    # For skipped frames, duplicate the last drawn frame for continuous smooth playback
+                    pass
+                
+                crowd_timeline.append(live_count)
+                out.write(last_out_frame)
+                
+                frames_processed += 1
+                if total_frames > 0:
+                    encoded_status = min(frames_processed / total_frames, 1.0)
+                    progress_bar.progress(encoded_status)
+                    elapsed = time.perf_counter() - video_start
+                    status_text.text(f"Processing video: {encoded_status * 100:.1f}% | Frame {frames_processed}/{total_frames} | Unique Targets: {total_unique}")
+                    elapsed_text.text(f"Elapsed processing time: {format_elapsed(elapsed)}")
+                else:
+                    elapsed = time.perf_counter() - video_start
+                    status_text.text(f"Processing frame {frames_processed}... (Unique Targets: {total_unique})")
+                    elapsed_text.text(f"Elapsed processing time: {format_elapsed(elapsed)}")
+            
+            cap.release()
+            out.release()
+            os.remove(tfile.name)
+            
+            video_elapsed = time.perf_counter() - video_start
+            progress_bar.progress(1.0)
+            status_text.text(f"Processing Complete: 100.0% | Finalizing video output...")
+            elapsed_text.text(f"Total processed time: {format_elapsed(video_elapsed)}")
+            
+            # Try to encode the resulting MP4 in H264 for web browser compatibility using ffmpeg (if available)
+            web_friendly_mp4 = tfile_out.name.replace('.mp4', '_web.mp4')
+            result_video_path = tfile_out.name
+            
+            try:
+                # Suppress output to avoid clutter, run synchronously
+                exit_code = os.system(f'ffmpeg -y -i "{tfile_out.name}" -vcodec libx264 -f mp4 "{web_friendly_mp4}" >nul 2>&1')
+                if exit_code == 0 and os.path.exists(web_friendly_mp4):
+                    result_video_path = web_friendly_mp4
+            except Exception:
+                pass
+            
+            st.success("Video Analytics Compilation Completed.")
+            
+            # Subsystem Alerts
+            render_alert(total_unique, venue_capacity)
+            
+            # Telemetry Metrics
+            m1, m2 = st.columns(2)
+            m1.metric(label="Peak Current Frame Count", value=peak_count)
+            m2.metric(label="Total Unique Individuals Tracked", value=total_unique)
+            st.metric(label="Total Processed Time", value=format_elapsed(video_elapsed))
+            ci_low, ci_high = confidence_interval(analyzed_counts)
+            s1, s2, s3 = st.columns(3)
+            s1.metric(label="Effective FPS", value=f"{frames_processed / video_elapsed:.2f}" if video_elapsed > 0 else "0.00")
+            s2.metric(label="Analyzed FPS", value=f"{frames_analyzed / video_elapsed:.2f}" if video_elapsed > 0 else "0.00")
+            s3.metric(label="95% Count CI", value=f"{ci_low:.1f} - {ci_high:.1f}")
+            st.caption(f"CUDA OOM recovery used batch size: {used_batch_size}")
+            if peak_count < 10:
+                st.warning(
+                    "Low detection count. For top-down drone/crosswalk videos, use Processing Mode = Accurate. "
+                    "If still low, turn off recommended preset and reduce Confidence Threshold toward 0.05."
+                )
+            
+            st.subheader("Population History Dynamics")
+            st.line_chart(crowd_timeline)
+            
+            st.subheader("Data Exports")
+            e1, e2 = st.columns(2)
+            if total_unique > 0:
+                e1.download_button(label="Download CSV Report", data=report.get_csv(), file_name="drone_report.csv", mime="text/csv")
+                e2.download_button(label="Download JSON Report", data=report.get_json(), file_name="drone_report.json", mime="application/json")
+            else:
+                st.info("No crowd targets detected to export.")
+            
+            st.subheader("Simulated Telemetry Video Pipeline")
+            try:
+                video_bytes = open(result_video_path, 'rb').read()
+                st.video(video_bytes)
+                st.download_button(label="Download Analytics Video", data=video_bytes, file_name="analytics_overlay_output.mp4", mime="video/mp4")
+            except Exception as e:
+                st.error("Could not load the generated video for playback in Streamlit, but you can download it anyway.")
+                st.download_button(label="Download Analytics Video", data=open(tfile_out.name, 'rb').read(), file_name="analytics_overlay_output.mp4", mime="video/mp4")
+
+
+else:
+    st.info("Please upload an image or video from the sidebar to begin.")

app_enhancements.py

@@ -0,0 +1,115 @@
+import json
+import math
+import os
+import time
+
+import torch
+
+
+PRESETS = {
+    "Fast": {
+        "magnification": 1.0,
+        "confidence_threshold": 0.55,
+        "nms_radius": 10.0,
+        "tracker_max_distance": 65.0,
+        "inference_batch_size": 16,
+        "frame_skip": 5,
+        "patch_overlap": 0.0,
+    },
+    "Balanced": {
+        "magnification": 1.5,
+        "confidence_threshold": 0.5,
+        "nms_radius": 8.0,
+        "tracker_max_distance": 50.0,
+        "inference_batch_size": 8,
+        "frame_skip": 2,
+        "patch_overlap": 0.25,
+    },
+    "Accurate": {
+        "magnification": 2.0,
+        "confidence_threshold": 0.45,
+        "nms_radius": 6.0,
+        "tracker_max_distance": 40.0,
+        "inference_batch_size": 4,
+        "frame_skip": 1,
+        "patch_overlap": 0.5,
+    },
+}
+
+
+def load_config(config_path, defaults):
+    if os.path.exists(config_path):
+        with open(config_path, "r", encoding="utf-8") as f:
+            return {**defaults, **json.load(f)}
+    return defaults
+
+
+def save_config(config_path, config):
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+
+def run_with_oom_recovery(process_fn, *args, batch_size=8, min_batch_size=1, **kwargs):
+    current_batch = max(min_batch_size, int(batch_size))
+    while current_batch >= min_batch_size:
+        try:
+            return process_fn(*args, batch_size=current_batch, **kwargs), current_batch
+        except RuntimeError as exc:
+            if "out of memory" not in str(exc).lower():
+                raise
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            if current_batch == min_batch_size:
+                raise
+            current_batch = max(min_batch_size, current_batch // 2)
+    raise RuntimeError("CUDA OOM recovery failed.")
+
+
+def confidence_interval(values, z=1.96):
+    if not values:
+        return 0.0, 0.0
+    if len(values) == 1:
+        return float(values[0]), float(values[0])
+    mean = sum(values) / len(values)
+    variance = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
+    margin = z * math.sqrt(variance) / math.sqrt(len(values))
+    return mean - margin, mean + margin
+
+
+def result_summary(start_time, frames_read, frames_analyzed, counts):
+    elapsed = max(time.perf_counter() - start_time, 1e-9)
+    ci_low, ci_high = confidence_interval(counts)
+    return {
+        "elapsed_sec": round(elapsed, 3),
+        "frames_read": frames_read,
+        "frames_analyzed": frames_analyzed,
+        "effective_fps": round(frames_read / elapsed, 3),
+        "analysis_fps": round(frames_analyzed / elapsed, 3),
+        "avg_count": round(sum(counts) / len(counts), 3) if counts else 0,
+        "peak_count": max(counts) if counts else 0,
+        "count_95ci_low": round(ci_low, 3),
+        "count_95ci_high": round(ci_high, 3),
+    }
+
+
+APP_PASTE_SECTION = r'''
+CONFIG_PATH = os.path.join(BASE_DIR, "civic_pulse_config.json")
+PRESETS = {
+    "Fast": {"magnification": 1.0, "confidence_threshold": 0.55, "nms_radius": 10.0, "tracker_max_distance": 65.0, "inference_batch_size": 16, "frame_skip": 5, "patch_overlap": 0.0},
+    "Balanced": {"magnification": 1.5, "confidence_threshold": 0.5, "nms_radius": 8.0, "tracker_max_distance": 50.0, "inference_batch_size": 8, "frame_skip": 2, "patch_overlap": 0.25},
+    "Accurate": {"magnification": 2.0, "confidence_threshold": 0.45, "nms_radius": 6.0, "tracker_max_distance": 40.0, "inference_batch_size": 4, "frame_skip": 1, "patch_overlap": 0.5},
+}
+
+def process_with_oom_recovery(*args, batch_size, **kwargs):
+    while batch_size >= 1:
+        try:
+            return process_frame(*args, batch_size=batch_size, **kwargs), batch_size
+        except RuntimeError as exc:
+            if "out of memory" not in str(exc).lower():
+                raise
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            if batch_size == 1:
+                raise
+            batch_size = max(1, batch_size // 2)
+'''

benchmark.py

@@ -0,0 +1,171 @@
+import argparse
+import csv
+import json
+import os
+import time
+from itertools import product
+
+import cv2
+import numpy as np
+import torch
+import torchvision.transforms as standard_transforms
+from PIL import Image
+from scipy.spatial import cKDTree
+
+from models import build_model
+
+
+class Args:
+    backbone = "vgg16_bn"
+    row = 2
+    line = 2
+
+
+def load_model(weight_path):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if device.type == "cuda":
+        torch.backends.cudnn.benchmark = True
+    model = build_model(Args()).to(device).eval()
+    if os.path.exists(weight_path):
+        checkpoint = torch.load(weight_path, map_location=device)
+        model.load_state_dict(checkpoint["model"])
+    transform = standard_transforms.Compose([
+        standard_transforms.ToTensor(),
+        standard_transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                      std=[0.229, 0.224, 0.225]),
+    ])
+    return model, device, transform
+
+
+def merge_points(points, radius=8.0):
+    if not points:
+        return []
+    pts = np.array(points, dtype=np.float32)
+    tree = cKDTree(pts)
+    suppressed = set()
+    for i, j in tree.query_pairs(r=radius):
+        if i not in suppressed and j not in suppressed:
+            suppressed.add(j)
+    return [pts[i].tolist() for i in range(len(pts)) if i not in suppressed]
+
+
+def infer_frame(image, model, device, transform, confidence, magnification, batch_size, patch_overlap):
+    orig_w, orig_h = image.size
+    patch_size = 512
+    pad = 256
+    work_w, work_h = int(orig_w * magnification), int(orig_h * magnification)
+    scale = min(1.0, 3840 / float(max(work_w, work_h)))
+    work_w, work_h = int(work_w * scale), int(work_h * scale)
+    magnification = work_w / float(orig_w)
+    resample_filter = getattr(Image, "Resampling", Image).LANCZOS if hasattr(Image, "Resampling") else getattr(Image, "ANTIALIAS", 1)
+    image = image.resize((work_w, work_h), resample_filter)
+    padded_w = ((work_w + pad * 2 + patch_size - 1) // patch_size) * patch_size
+    padded_h = ((work_h + pad * 2 + patch_size - 1) // patch_size) * patch_size
+    padded = Image.new("RGB", (padded_w, padded_h), (0, 0, 0))
+    padded.paste(image, (pad, pad))
+    stride = max(64, int(patch_size * (1.0 - patch_overlap)))
+    jobs = []
+    for y in range(0, padded_h - stride + 1, stride):
+        for x in range(0, padded_w - stride + 1, stride):
+            if x + patch_size <= padded_w and y + patch_size <= padded_h:
+                jobs.append((x, y, padded.crop((x, y, x + patch_size, y + patch_size))))
+
+    all_points = []
+    for start in range(0, len(jobs), batch_size):
+        batch = jobs[start:start + batch_size]
+        samples = torch.stack([transform(patch) for _, _, patch in batch]).to(device)
+        with torch.inference_mode():
+            if device.type == "cuda":
+                with torch.cuda.amp.autocast():
+                    out = model(samples)
+            else:
+                out = model(samples)
+        scores = torch.nn.functional.softmax(out["pred_logits"].float(), -1)[:, :, 1]
+        points = out["pred_points"].float()
+        for idx, (x, y, _) in enumerate(batch):
+            selected = points[idx][scores[idx] > confidence].detach().cpu().numpy()
+            if len(selected):
+                selected[:, 0] += x - pad
+                selected[:, 1] += y - pad
+                selected /= float(magnification)
+                all_points.extend([
+                    p.tolist() for p in selected
+                    if 0 <= p[0] < orig_w and 0 <= p[1] < orig_h
+                ])
+    return merge_points(all_points)
+
+
+def run_config(video, model, device, transform, cfg, max_frames):
+    cap = cv2.VideoCapture(video)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frames_read = 0
+    frames_analyzed = 0
+    counts = []
+    start = time.perf_counter()
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret or (max_frames and frames_read >= max_frames):
+            break
+        if frames_read % cfg["frame_skip"] == 0:
+            image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            points = infer_frame(image, model, device, transform, cfg["confidence"], cfg["magnification"], cfg["batch_size"], cfg["patch_overlap"])
+            counts.append(len(points))
+            frames_analyzed += 1
+        frames_read += 1
+    cap.release()
+    elapsed = time.perf_counter() - start
+    return {
+        **cfg,
+        "video_frames": total_frames,
+        "frames_read": frames_read,
+        "frames_analyzed": frames_analyzed,
+        "elapsed_sec": round(elapsed, 4),
+        "effective_fps": round(frames_read / elapsed, 4) if elapsed else 0,
+        "analysis_fps": round(frames_analyzed / elapsed, 4) if elapsed else 0,
+        "avg_count": round(float(np.mean(counts)), 4) if counts else 0,
+        "max_count": int(max(counts)) if counts else 0,
+        "std_count": round(float(np.std(counts)), 4) if counts else 0,
+    }
+
+
+def recommendations(rows):
+    return {
+        "fast": max(rows, key=lambda row: row["effective_fps"]),
+        "balanced": min(rows, key=lambda row: (row["std_count"], -row["effective_fps"])),
+        "accurate": max(rows, key=lambda row: (row["patch_overlap"], row["magnification"], -row["frame_skip"])),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--video", required=True)
+    parser.add_argument("--weights", default=os.path.join("weights", "SHTechA.pth"))
+    parser.add_argument("--output_dir", default="benchmark_results")
+    parser.add_argument("--max_frames", type=int, default=120)
+    args = parser.parse_args()
+    os.makedirs(args.output_dir, exist_ok=True)
+    model, device, transform = load_model(args.weights)
+    configs = []
+    for frame_skip, mag, batch, conf in product([1, 2, 5], [1.0, 1.5, 2.0], [4, 8, 16], [0.45, 0.5, 0.55]):
+        configs.append({
+            "frame_skip": frame_skip,
+            "magnification": mag,
+            "batch_size": batch,
+            "confidence": conf,
+            "patch_overlap": 0.5 if frame_skip == 1 else 0.25 if frame_skip == 2 else 0.0,
+        })
+    rows = [run_config(args.video, model, device, transform, cfg, args.max_frames) for cfg in configs]
+    recs = recommendations(rows)
+    csv_path = os.path.join(args.output_dir, "benchmark_results.csv")
+    json_path = os.path.join(args.output_dir, "benchmark_results.json")
+    with open(csv_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+        writer.writeheader()
+        writer.writerows(rows)
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump({"results": rows, "recommendations": recs}, f, indent=2)
+    print(json.dumps({"csv": csv_path, "json": json_path, "recommendations": recs}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

crowd_datasets/SHHA/SHHA.py

@@ -0,0 +1,158 @@
+import os
+import random
+import torch
+import numpy as np
+from torch.utils.data import Dataset
+from PIL import Image
+import cv2
+import glob
+import scipy.io as io
+import re
+
+class SHHA(Dataset):
+    def __init__(
+        self,
+        data_root,
+        transform=None,
+        train=False,
+        patch=False,
+        flip=False,
+        train_list="shanghai_tech_part_a_train.list",
+        eval_list="shanghai_tech_part_a_test.list",
+    ):
+        self.root_path = data_root
+        self.train_lists = train_list
+        self.eval_list = eval_list
+        # there may exist multiple list files
+        self.img_list_file = self.train_lists.split(',')
+        if train:
+            self.img_list_file = self.train_lists.split(',')
+        else:
+            self.img_list_file = self.eval_list.split(',')
+
+        self.img_map = {}
+        self.img_list = []
+        # loads the image/gt pairs
+        for _, train_list in enumerate(self.img_list_file):
+            train_list = train_list.strip()
+            with open(os.path.join(self.root_path, train_list)) as fin:
+                for line in fin:
+                    if len(line) < 2: 
+                        continue
+                    line = line.strip()
+                    if "\t" in line:
+                        img_path, gt_path = line.split("\t", 1)
+                    else:
+                        line = line.split()
+                        if len(line) < 2:
+                            continue
+                        img_path = line[0]
+                        gt_path = line[1]
+                    img_path = img_path.strip()
+                    gt_path = gt_path.strip()
+                    if not os.path.isabs(img_path):
+                        img_path = os.path.join(self.root_path, img_path)
+                    if not os.path.isabs(gt_path):
+                        gt_path = os.path.join(self.root_path, gt_path)
+                    self.img_map[img_path] = gt_path
+        self.img_list = sorted(list(self.img_map.keys()))
+        # number of samples
+        self.nSamples = len(self.img_list)
+        
+        self.transform = transform
+        self.train = train
+        self.patch = patch
+        self.flip = flip
+
+    def __len__(self):
+        return self.nSamples
+
+    def __getitem__(self, index):
+        assert index <= len(self), 'index range error'
+
+        img_path = self.img_list[index]
+        gt_path = self.img_map[img_path]
+        # load image and ground truth
+        img, point = load_data((img_path, gt_path), self.train)
+        # applu augumentation
+        if self.transform is not None:
+            img = self.transform(img)
+
+        if self.train:
+            # data augmentation -> random scale
+            scale_range = [0.7, 1.3]
+            min_size = min(img.shape[1:])
+            scale = random.uniform(*scale_range)
+            # scale the image and points
+            if scale * min_size > 128:
+                img = torch.nn.functional.upsample_bilinear(img.unsqueeze(0), scale_factor=scale).squeeze(0)
+                point *= scale
+        # random crop augumentaiton
+        if self.train and self.patch:
+            img, point = random_crop(img, point)
+            for i, _ in enumerate(point):
+                point[i] = torch.Tensor(point[i])
+        # random flipping
+        if random.random() > 0.5 and self.train and self.flip:
+            # random flip
+            img = torch.Tensor(img[:, :, :, ::-1].copy())
+            for i, _ in enumerate(point):
+                point[i][:, 0] = 128 - point[i][:, 0]
+
+        if not self.train:
+            point = [point]
+
+        img = torch.Tensor(img)
+        # pack up related infos
+        target = [{} for i in range(len(point))]
+        for i, _ in enumerate(point):
+            target[i]['point'] = torch.Tensor(point[i])
+            image_stem = os.path.splitext(os.path.basename(img_path))[0]
+            digits = re.findall(r'\d+', image_stem)
+            image_id = int(digits[-1]) if digits else index
+            image_id = torch.Tensor([image_id]).long()
+            target[i]['image_id'] = image_id
+            target[i]['labels'] = torch.ones([point[i].shape[0]]).long()
+
+        return img, target
+
+
+def load_data(img_gt_path, train):
+    img_path, gt_path = img_gt_path
+    # load the images
+    img = cv2.imread(img_path)
+    img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+    # load ground truth points
+    points = []
+    with open(gt_path) as f_label:
+        for line in f_label:
+            x = float(line.strip().split(' ')[0])
+            y = float(line.strip().split(' ')[1])
+            points.append([x, y])
+
+    return img, np.array(points)
+
+# random crop augumentation
+def random_crop(img, den, num_patch=4):
+    half_h = 128
+    half_w = 128
+    result_img = np.zeros([num_patch, img.shape[0], half_h, half_w])
+    result_den = []
+    # crop num_patch for each image
+    for i in range(num_patch):
+        start_h = random.randint(0, img.size(1) - half_h)
+        start_w = random.randint(0, img.size(2) - half_w)
+        end_h = start_h + half_h
+        end_w = start_w + half_w
+        # copy the cropped rect
+        result_img[i] = img[:, start_h:end_h, start_w:end_w]
+        # copy the cropped points
+        idx = (den[:, 0] >= start_w) & (den[:, 0] <= end_w) & (den[:, 1] >= start_h) & (den[:, 1] <= end_h)
+        # shift the corrdinates
+        record_den = den[idx]
+        record_den[:, 0] -= start_w
+        record_den[:, 1] -= start_h
+
+        result_den.append(record_den)
+
+    return result_img, result_den

crowd_datasets/SHHA/loading_data.py

@@ -0,0 +1,27 @@
+import torchvision.transforms as standard_transforms
+from .SHHA import SHHA
+
+# DeNormalize used to get original images
+class DeNormalize(object):
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, tensor):
+        for t, m, s in zip(tensor, self.mean, self.std):
+            t.mul_(s).add_(m)
+        return tensor
+
+def loading_data(data_root):
+    # the pre-proccssing transform
+    transform = standard_transforms.Compose([
+        standard_transforms.ToTensor(), 
+        standard_transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                    std=[0.229, 0.224, 0.225]),
+    ])
+    # create the training dataset
+    train_set = SHHA(data_root, train=True, transform=transform, patch=True, flip=True)
+    # create the validation dataset
+    val_set = SHHA(data_root, train=False, transform=transform)
+
+    return train_set, val_set

crowd_datasets/__init__.py

@@ -0,0 +1,8 @@
+# build dataset according to given 'dataset_file'
+def build_dataset(args):
+    dataset_file = args.dataset_file.upper()
+    if dataset_file == 'SHHA':
+        from crowd_datasets.SHHA.loading_data import loading_data
+        return loading_data
+
+    raise ValueError(f"Unsupported dataset_file: {args.dataset_file}. Use SHHA.")

database.py

@@ -0,0 +1,14 @@
+from sqlmodel import SQLModel, Field, create_engine, Session
+
+class FlightReport(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    filename: str
+    max_capacity_breached: bool
+    peak_crowd_count: int
+    duration_frames: int
+    chaos_anomalies: int
+
+engine = create_engine("sqlite:///crowd_data.db")
+
+def init_db():
+    SQLModel.metadata.create_all(engine)

download_weights.py

@@ -0,0 +1,53 @@
+"""
+download_weights.py
+Auto-downloads the P2PNet model weights from HuggingFace Hub if they are
+not present locally. Called at FastAPI startup so the container always has
+the weights without committing the 82 MB .pth file to Git.
+"""
+
+import os
+
+
+HF_WEIGHTS_REPO = os.environ.get(
+    "HF_WEIGHTS_REPO",
+    "YOUR_HF_USERNAME/crowd-counting-weights",
+)
+WEIGHTS_FILENAME = "SHTechA.pth"
+WEIGHTS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "weights")
+WEIGHTS_PATH = os.path.join(WEIGHTS_DIR, WEIGHTS_FILENAME)
+
+
+def ensure_weights() -> None:
+    """Download model weights from HuggingFace Hub if not present locally."""
+    if os.path.exists(WEIGHTS_PATH):
+        print(f"[Weights] Found at {WEIGHTS_PATH} - skipping download.")
+        return
+
+    repo_is_placeholder = (
+        not HF_WEIGHTS_REPO
+        or "YOUR_HF_USERNAME" in HF_WEIGHTS_REPO
+        or "your-username" in HF_WEIGHTS_REPO.lower()
+    )
+    if repo_is_placeholder:
+        print("[Weights] No valid HuggingFace weights repo configured - skipping download.")
+        print("[Weights] The model will run without pretrained weights.")
+        return
+
+    print(
+        f"[Weights] Not found locally. Downloading '{WEIGHTS_FILENAME}' "
+        f"from HuggingFace Hub repo '{HF_WEIGHTS_REPO}' ..."
+    )
+    os.makedirs(WEIGHTS_DIR, exist_ok=True)
+
+    try:
+        from huggingface_hub import hf_hub_download
+
+        downloaded = hf_hub_download(
+            repo_id=HF_WEIGHTS_REPO,
+            filename=WEIGHTS_FILENAME,
+            local_dir=WEIGHTS_DIR,
+        )
+        print(f"[Weights] Downloaded successfully -> {downloaded}")
+    except Exception as exc:
+        print(f"[Weights] WARNING: Could not download weights - {exc}")
+        print("[Weights] The model will run without pretrained weights.")

engine.py

@@ -0,0 +1,159 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Train and eval functions used in main.py
+Mostly copy-paste from DETR (https://github.com/facebookresearch/detr).
+"""
+import math
+import os
+import sys
+from typing import Iterable
+
+import torch
+
+import util.misc as utils
+from util.misc import NestedTensor
+import numpy as np
+import time
+import torchvision.transforms as standard_transforms
+import cv2
+
+class DeNormalize(object):
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, tensor):
+        for t, m, s in zip(tensor, self.mean, self.std):
+            t.mul_(s).add_(m)
+        return tensor
+
+def vis(samples, targets, pred, vis_dir, des=None):
+    '''
+    samples -> tensor: [batch, 3, H, W]
+    targets -> list of dict: [{'points':[], 'image_id': str}]
+    pred -> list: [num_preds, 2]
+    '''
+    gts = [t['point'].tolist() for t in targets]
+
+    pil_to_tensor = standard_transforms.ToTensor()
+
+    restore_transform = standard_transforms.Compose([
+        DeNormalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        standard_transforms.ToPILImage()
+    ])
+    # draw one by one
+    for idx in range(samples.shape[0]):
+        sample = restore_transform(samples[idx])
+        sample = pil_to_tensor(sample.convert('RGB')).numpy() * 255
+        sample_gt = sample.transpose([1, 2, 0])[:, :, ::-1].astype(np.uint8).copy()
+        sample_pred = sample.transpose([1, 2, 0])[:, :, ::-1].astype(np.uint8).copy()
+
+        max_len = np.max(sample_gt.shape)
+
+        size = 2
+        # draw gt
+        for t in gts[idx]:
+            sample_gt = cv2.circle(sample_gt, (int(t[0]), int(t[1])), size, (0, 255, 0), -1)
+        # draw predictions
+        for p in pred[idx]:
+            sample_pred = cv2.circle(sample_pred, (int(p[0]), int(p[1])), size, (0, 0, 255), -1)
+
+        name = targets[idx]['image_id']
+        # save the visualized images
+        if des is not None:
+            cv2.imwrite(os.path.join(vis_dir, '{}_{}_gt_{}_pred_{}_gt.jpg'.format(int(name), 
+                                                des, len(gts[idx]), len(pred[idx]))), sample_gt)
+            cv2.imwrite(os.path.join(vis_dir, '{}_{}_gt_{}_pred_{}_pred.jpg'.format(int(name), 
+                                                des, len(gts[idx]), len(pred[idx]))), sample_pred)
+        else:
+            cv2.imwrite(
+                os.path.join(vis_dir, '{}_gt_{}_pred_{}_gt.jpg'.format(int(name), len(gts[idx]), len(pred[idx]))),
+                sample_gt)
+            cv2.imwrite(
+                os.path.join(vis_dir, '{}_gt_{}_pred_{}_pred.jpg'.format(int(name), len(gts[idx]), len(pred[idx]))),
+                sample_pred)
+
+# the training routine
+def train_one_epoch(model: torch.nn.Module, criterion: torch.nn.Module,
+                    data_loader: Iterable, optimizer: torch.optim.Optimizer,
+                    device: torch.device, epoch: int, max_norm: float = 0):
+    model.train()
+    criterion.train()
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))
+    # iterate all training samples
+    for samples, targets in data_loader:
+        samples = samples.to(device)
+        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
+        # forward
+        outputs = model(samples)
+        # calc the losses
+        loss_dict = criterion(outputs, targets)
+        weight_dict = criterion.weight_dict
+        losses = sum(loss_dict[k] * weight_dict[k] for k in loss_dict.keys() if k in weight_dict)
+
+        # reduce all losses
+        loss_dict_reduced = utils.reduce_dict(loss_dict)
+        loss_dict_reduced_unscaled = {f'{k}_unscaled': v
+                                      for k, v in loss_dict_reduced.items()}
+        loss_dict_reduced_scaled = {k: v * weight_dict[k]
+                                    for k, v in loss_dict_reduced.items() if k in weight_dict}
+        losses_reduced_scaled = sum(loss_dict_reduced_scaled.values())
+
+        loss_value = losses_reduced_scaled.item()
+
+        if not math.isfinite(loss_value):
+            print("Loss is {}, stopping training".format(loss_value))
+            print(loss_dict_reduced)
+            sys.exit(1)
+        # backward
+        optimizer.zero_grad()
+        losses.backward()
+        if max_norm > 0:
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)
+        optimizer.step()
+        # update logger
+        metric_logger.update(loss=loss_value, **loss_dict_reduced_scaled, **loss_dict_reduced_unscaled)
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger)
+    return {k: meter.global_avg for k, meter in metric_logger.meters.items()}
+
+# the inference routine
+@torch.no_grad()
+def evaluate_crowd_no_overlap(model, data_loader, device, vis_dir=None):
+    model.eval()
+
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('class_error', utils.SmoothedValue(window_size=1, fmt='{value:.2f}'))
+    # run inference on all images to calc MAE
+    maes = []
+    mses = []
+    for samples, targets in data_loader:
+        samples = samples.to(device)
+
+        outputs = model(samples)
+        outputs_scores = torch.nn.functional.softmax(outputs['pred_logits'], -1)[:, :, 1][0]
+
+        outputs_points = outputs['pred_points'][0]
+
+        gt_cnt = targets[0]['point'].shape[0]
+        # 0.5 is used by default
+        threshold = 0.5
+
+        points = outputs_points[outputs_scores > threshold].detach().cpu().numpy().tolist()
+        predict_cnt = int((outputs_scores > threshold).sum())
+        # if specified, save the visualized images
+        if vis_dir is not None: 
+            vis(samples, targets, [points], vis_dir)
+        # accumulate MAE, MSE
+        mae = abs(predict_cnt - gt_cnt)
+        mse = (predict_cnt - gt_cnt) * (predict_cnt - gt_cnt)
+        maes.append(float(mae))
+        mses.append(float(mse))
+    # calc MAE, MSE
+    mae = np.mean(maes)
+    mse = np.sqrt(np.mean(mses))
+
+    return mae, mse

evaluate.py

@@ -0,0 +1,171 @@
+import argparse
+import csv
+import json
+import os
+
+import cv2
+import numpy as np
+import torch
+import torchvision.transforms as standard_transforms
+from PIL import Image
+from scipy.optimize import linear_sum_assignment
+from scipy.spatial import cKDTree
+
+from models import build_model
+
+
+class Args:
+    backbone = "vgg16_bn"
+    row = 2
+    line = 2
+
+
+def load_model(weight_path):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = build_model(Args()).to(device).eval()
+    if os.path.exists(weight_path):
+        checkpoint = torch.load(weight_path, map_location=device)
+        model.load_state_dict(checkpoint["model"])
+    transform = standard_transforms.Compose([
+        standard_transforms.ToTensor(),
+        standard_transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                      std=[0.229, 0.224, 0.225]),
+    ])
+    return model, device, transform
+
+
+def infer_points(image, model, device, transform, confidence=0.5, magnification=1.5, batch_size=8):
+    orig_w, orig_h = image.size
+    patch_size = 512
+    pad = 256
+    work_w, work_h = int(orig_w * magnification), int(orig_h * magnification)
+    scale = min(1.0, 3840 / float(max(work_w, work_h)))
+    work_w, work_h = int(work_w * scale), int(work_h * scale)
+    magnification = work_w / float(orig_w)
+    resample_filter = getattr(Image, "Resampling", Image).LANCZOS if hasattr(Image, "Resampling") else getattr(Image, "ANTIALIAS", 1)
+    image = image.resize((work_w, work_h), resample_filter)
+    padded_w = ((work_w + pad * 2 + patch_size - 1) // patch_size) * patch_size
+    padded_h = ((work_h + pad * 2 + patch_size - 1) // patch_size) * patch_size
+    padded = Image.new("RGB", (padded_w, padded_h), (0, 0, 0))
+    padded.paste(image, (pad, pad))
+    stride = patch_size // 2
+    jobs = []
+    for y in range(0, padded_h - stride + 1, stride):
+        for x in range(0, padded_w - stride + 1, stride):
+            if x + patch_size <= padded_w and y + patch_size <= padded_h:
+                jobs.append((x, y, padded.crop((x, y, x + patch_size, y + patch_size))))
+    all_points = []
+    for start in range(0, len(jobs), batch_size):
+        batch = jobs[start:start + batch_size]
+        samples = torch.stack([transform(patch) for _, _, patch in batch]).to(device)
+        with torch.inference_mode():
+            if device.type == "cuda":
+                with torch.cuda.amp.autocast():
+                    out = model(samples)
+            else:
+                out = model(samples)
+        scores = torch.nn.functional.softmax(out["pred_logits"].float(), -1)[:, :, 1]
+        pred = out["pred_points"].float()
+        for idx, (x, y, _) in enumerate(batch):
+            pts = pred[idx][scores[idx] > confidence].detach().cpu().numpy()
+            if len(pts):
+                pts[:, 0] += x - pad
+                pts[:, 1] += y - pad
+                pts /= float(magnification)
+                all_points.extend([p.tolist() for p in pts if 0 <= p[0] < orig_w and 0 <= p[1] < orig_h])
+    if not all_points:
+        return []
+    pts = np.array(all_points, dtype=np.float32)
+    tree = cKDTree(pts)
+    suppressed = set()
+    for i, j in tree.query_pairs(r=8.0):
+        if i not in suppressed and j not in suppressed:
+            suppressed.add(j)
+    return [pts[i].tolist() for i in range(len(pts)) if i not in suppressed]
+
+
+def load_gt(path):
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    if isinstance(data, dict) and "annotations" in data:
+        data = data["annotations"]
+    if isinstance(data, dict):
+        return [{"image": image, "points": points} for image, points in data.items()]
+    return data
+
+
+def precision_recall(pred_points, gt_points, radius):
+    pred = np.array(pred_points, dtype=np.float32)
+    gt = np.array(gt_points, dtype=np.float32)
+    if len(pred) == 0 and len(gt) == 0:
+        return 1.0, 1.0, 0, 0, 0
+    if len(pred) == 0:
+        return 0.0, 0.0, 0, 0, len(gt)
+    if len(gt) == 0:
+        return 0.0, 0.0, 0, len(pred), 0
+    dist = np.linalg.norm(pred[:, None, :] - gt[None, :, :], axis=2)
+    rows, cols = linear_sum_assignment(dist)
+    matches = sum(1 for r, c in zip(rows, cols) if dist[r, c] <= radius)
+    fp = len(pred) - matches
+    fn = len(gt) - matches
+    precision = matches / (matches + fp) if matches + fp else 0.0
+    recall = matches / (matches + fn) if matches + fn else 0.0
+    return precision, recall, matches, fp, fn
+
+
+def draw_visual(image_path, gt_points, pred_points, output_path):
+    img = cv2.imread(image_path)
+    for x, y in gt_points:
+        cv2.circle(img, (int(x), int(y)), 4, (0, 255, 0), -1)
+    for x, y in pred_points:
+        cv2.circle(img, (int(x), int(y)), 3, (0, 0, 255), 1)
+    cv2.imwrite(output_path, img)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--images_dir", required=True)
+    parser.add_argument("--gt_json", required=True)
+    parser.add_argument("--weights", default=os.path.join("weights", "SHTechA.pth"))
+    parser.add_argument("--output_dir", default="eval_results")
+    parser.add_argument("--confidence", type=float, default=0.5)
+    args = parser.parse_args()
+    os.makedirs(args.output_dir, exist_ok=True)
+    vis_dir = os.path.join(args.output_dir, "visualizations")
+    os.makedirs(vis_dir, exist_ok=True)
+    model, device, transform = load_model(args.weights)
+    rows = []
+    errors = []
+    squared_errors = []
+    for item in load_gt(args.gt_json):
+        image_name = item["image"]
+        gt_points = item.get("points", [])
+        image_path = image_name if os.path.isabs(image_name) else os.path.join(args.images_dir, image_name)
+        pred_points = infer_points(Image.open(image_path).convert("RGB"), model, device, transform, args.confidence)
+        err = abs(len(pred_points) - len(gt_points))
+        errors.append(err)
+        squared_errors.append(err ** 2)
+        row = {"image": os.path.basename(image_path), "gt_count": len(gt_points), "pred_count": len(pred_points), "abs_error": err, "sq_error": err ** 2}
+        for radius in [5, 10, 15, 20]:
+            p, r, m, fp, fn = precision_recall(pred_points, gt_points, radius)
+            row[f"precision_{radius}px"] = round(p, 4)
+            row[f"recall_{radius}px"] = round(r, 4)
+            row[f"matches_{radius}px"] = m
+            row[f"fp_{radius}px"] = fp
+            row[f"fn_{radius}px"] = fn
+        rows.append(row)
+        draw_visual(image_path, gt_points, pred_points, os.path.join(vis_dir, os.path.splitext(os.path.basename(image_path))[0] + "_eval.png"))
+    summary = {"mae": round(float(np.mean(errors)), 4) if errors else 0, "mse": round(float(np.mean(squared_errors)), 4) if squared_errors else 0, "images": len(rows)}
+    csv_path = os.path.join(args.output_dir, "evaluation.csv")
+    json_path = os.path.join(args.output_dir, "evaluation_summary.json")
+    with open(csv_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()) if rows else ["image"])
+        writer.writeheader()
+        writer.writerows(rows)
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump({"summary": summary, "rows": rows}, f, indent=2)
+    print(json.dumps({"csv": csv_path, "json": json_path, "visualizations": vis_dir, "summary": summary}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

frontend/.env.example

@@ -0,0 +1,5 @@
+# Copy this file to .env.local for local development, or to .env.production for prod builds.
+# The app defaults to http://localhost:8000 if this is not set.
+
+# Backend API URL (your HuggingFace Spaces URL or local server)
+VITE_API_URL=http://localhost:8000

frontend/.env.production

@@ -0,0 +1,3 @@
+# Production API URL — points to your HuggingFace Spaces backend
+# Replace with your actual HF Spaces URL after deployment
+VITE_API_URL=

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

frontend/eslint.config.js

@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "lucide-react": "^1.8.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "recharts": "^3.8.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "vite": "^8.0.4"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,1067 @@
+import React, { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import {
+  LineChart, Line, XAxis, YAxis, Tooltip,
+  ResponsiveContainer, CartesianGrid, ReferenceLine, Area, AreaChart
+} from 'recharts';
+import {
+  Shield, Activity, AlertTriangle, Zap, Target,
+  Eye, Layers, Radio, Cpu, Users,
+  TrendingUp, Download, Crosshair, Map, BarChart2,
+  Wifi, WifiOff, Play, Square, RotateCcw, Database,
+  Maximize2, Upload, GitBranch, Thermometer, Move,
+  ZoomIn, ZoomOut, Wind, Brain, Gauge, Sun, Moon
+} from 'lucide-react';
+import './index.css';
+
+// ─── helpers ──────────────────────────────────────────────────
+const nowStr  = () => new Date().toLocaleTimeString('en-US', { hour12: false });
+const uid     = () => Math.random().toString(36).slice(2, 8);
+const secStr  = (ms) => {
+  const s = Math.floor(ms / 1000);
+  return `${String(Math.floor(s / 60)).padStart(2,'0')}:${String(s % 60).padStart(2,'0')}`;
+};
+
+// ─── API Base URLs (reads from env var, falls back to localhost for dev) ──────
+const rawApiBase = (import.meta.env.VITE_API_URL || '').trim();
+const hasPlaceholderApiBase =
+  !rawApiBase || /YOUR_(HF_USERNAME|USERNAME)|your_hf_username|your_username/i.test(rawApiBase);
+const isLocalHost =
+  typeof window !== 'undefined' &&
+  ['localhost', '127.0.0.1'].includes(window.location.hostname);
+const fallbackApiBase =
+  typeof window === 'undefined'
+    ? 'http://127.0.0.1:8000'
+    : (isLocalHost ? 'http://127.0.0.1:8000' : '');
+const API_BASE = (hasPlaceholderApiBase ? fallbackApiBase : rawApiBase).replace(/\/$/, '');
+const WS_BASE  = API_BASE.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://');
+const API_CONFIG_ERROR = 'Backend API is not configured. Set VITE_API_URL to your FastAPI server URL.';
+
+const THREAT = {
+  SAFE:     { label: 'SAFE',     cls: 'safe'     },
+  MODERATE: { label: 'MODERATE', cls: 'moderate' },
+  DANGER:   { label: 'DANGER',   cls: 'danger'   },
+};
+function getThreat(count, limit) {
+  const r = limit > 0 ? count / limit : 0;
+  if (r >= 1)    return THREAT.DANGER;
+  if (r >= 0.75) return THREAT.MODERATE;
+  return THREAT.SAFE;
+}
+
+// Density classification per 10k pixel reference area
+function getDensityLabel(count, limit) {
+  const r = limit > 0 ? count / limit : 0;
+  if (r >= 1)    return { label: 'CRITICAL', cls: 'danger'   };
+  if (r >= 0.75) return { label: 'HIGH',     cls: 'moderate' };
+  if (r >= 0.40) return { label: 'MEDIUM',   cls: 'blue'     };
+  return           { label: 'LOW',      cls: ''         };
+}
+
+// Simple linear regression on last N data points for predictive alerts
+function predictNextFrameCount(history, n = 12) {
+  const data = history.slice(-n);
+  if (data.length < 3) return null;
+  const xs = data.map((_, i) => i);
+  const ys = data.map(d => d.count);
+  const xMean = xs.reduce((a, b) => a + b, 0) / xs.length;
+  const yMean = ys.reduce((a, b) => a + b, 0) / ys.length;
+  const num   = xs.reduce((s, x, i) => s + (x - xMean) * (ys[i] - yMean), 0);
+  const den   = xs.reduce((s, x) => s + (x - xMean) ** 2, 0);
+  if (den === 0) return null;
+  const slope = num / den;
+  const intercept = yMean - slope * xMean;
+  // predict 10 frames ahead
+  return Math.max(0, Math.round(slope * (xs.length + 10) + intercept));
+}
+
+// ─── Custom Recharts Tooltip ──────────────────────────────────
+function CTooltip({ active, payload, label }) {
+  if (!active || !payload?.length) return null;
+  return (
+    <div className="custom-tooltip">
+      <div className="custom-tooltip-label">{label}</div>
+      <div className="custom-tooltip-value">{payload[0].value}</div>
+    </div>
+  );
+}
+
+// ─── Alert Item ───────────────────────────────────────────────
+function AlertItem({ type, title, msg, time }) {
+  const Icon = type === 'danger' ? AlertTriangle : type === 'warning' ? Zap : Radio;
+  return (
+    <div className={`alert-item ${type}`}>
+      <div className="alert-icon"><Icon /></div>
+      <div className="alert-body">
+        <div className="alert-title">{title}</div>
+        <div className="alert-msg">{msg}</div>
+        <div className="alert-time">{time}</div>
+      </div>
+    </div>
+  );
+}
+
+// ─── Main App ─────────────────────────────────────────────────
+export default function App() {
+
+  // ── Theme ──
+  const [theme, setTheme] = useState(() => localStorage.getItem('cp_theme') || 'dark');
+  useEffect(() => {
+    document.documentElement.setAttribute('data-theme', theme);
+    localStorage.setItem('cp_theme', theme);
+  }, [theme]);
+  const toggleTheme = () => setTheme(t => t === 'dark' ? 'light' : 'dark');
+
+  // ── File / mode ──
+  const [file,          setFile]          = useState(null);
+  const [fileType,      setFileType]      = useState('image');
+  const [preview,       setPreview]       = useState(null);      // image preview URL
+  const [videoPreview,  setVideoPreview]  = useState(null);      // video preview URL
+  const [resultImg,     setResultImg]     = useState(null);
+  const [loading,       setLoading]       = useState(false);
+  const [dragActive,    setDragActive]    = useState(false);
+  const [uploadProgress, setUploadProgress] = useState(0);       // 0-100
+
+  // ── Analytics ──
+  const [stats,    setStats]    = useState({ count: 0, unique: 0, latency: 0, frames: 0 });
+  const [history,  setHistory]  = useState([]);
+  const [peakCount, setPeak]    = useState(0);
+  const [alerts,   setAlerts]   = useState([]);
+  const [sessions, setSessions] = useState(() => {
+    try { return JSON.parse(localStorage.getItem('cp_sessions') || '[]'); }
+    catch { return []; }
+  });
+  const sessionStartTs = useRef(null);
+
+  // ── WebSocket ──
+  const wsRef = useRef(null);
+  const [wsConnected, setWsConnected] = useState(false);
+
+  // ── Settings ──
+  const [settings, setSettings] = useState({
+    heatmap:       false,
+    clustering:    false,
+    showPoints:    true,
+    motionVecs:    false,
+    zoning:        false,
+    mode:          'Balanced',
+    capacity:      150,
+    magnification: 1.5,
+    nmsRadius:     9.0,
+    frameSkip:     3,
+    overlayOpacity: 100,   // GAP 2: opacity slider
+  });
+
+  // ── Zoom / Pan (GAP 4) ──
+  const [zoom, setZoom]       = useState(1);
+  const [pan, setPan]         = useState({ x: 0, y: 0 });
+  const isPanning             = useRef(false);
+  const panStart              = useRef({ x: 0, y: 0 });
+  const panOrigin             = useRef({ x: 0, y: 0 });
+
+  // ── Zone fencing ──
+  const [fencePoints, setFencePoints] = useState([]);
+  const [drawingFence, setDrawingFence] = useState(false);
+  const viewerRef    = useRef(null);
+  const fileInputRef = useRef(null);
+
+  // ── Derived ──
+  const threat       = getThreat(stats.count, settings.capacity);
+  const density      = getDensityLabel(stats.count, settings.capacity);
+  const anomalyActive = alerts.some(a => a.type === 'danger' && Date.now() - a._ts < 5000);
+  const predicted    = useMemo(() => predictNextFrameCount(history), [history]);
+  const predictAlert = predicted !== null && predicted > settings.capacity;
+
+  // ── Clock ──
+  const [clock, setClock] = useState(nowStr());
+  useEffect(() => {
+    const t = setInterval(() => setClock(nowStr()), 1000);
+    return () => clearInterval(t);
+  }, []);
+
+  // ── FPS ──
+  const lastHistLen = useRef(0);
+  const [fps, setFps] = useState(0);
+  useEffect(() => {
+    const t = setInterval(() => {
+      const delta = history.length - lastHistLen.current;
+      setFps(Math.max(0, Math.round(delta / Math.max(1, settings.frameSkip) * settings.frameSkip)));
+      lastHistLen.current = history.length;
+    }, 1000);
+    return () => clearInterval(t);
+  }, [history, settings.frameSkip]);
+
+  // ── Average density from history ──
+  const avgCount = history.length > 0
+    ? Math.round(history.reduce((s, h) => s + h.count, 0) / history.length)
+    : 0;
+
+  // ── Alert helper ──
+  const addAlert = useCallback((type, title, msg) => {
+    const entry = { id: uid(), type, title, msg, time: nowStr(), _ts: Date.now() };
+    setAlerts(prev => [entry, ...prev].slice(0, 60));
+  }, []);
+
+  useEffect(() => {
+    if (hasPlaceholderApiBase) {
+      addAlert(
+        'warning',
+        'API Fallback Active',
+        API_BASE
+          ? `Using fallback backend: ${API_BASE}. Set VITE_API_URL for deployed builds.`
+          : API_CONFIG_ERROR
+      );
+    }
+  }, [addAlert]);
+
+  // ── Predictive alert (GAP optional-7) ──
+  useEffect(() => {
+    if (predictAlert && history.length % 15 === 0 && history.length > 0) {
+      addAlert('warning', '🔮 Predictive Alert', `Model predicts ~${predicted} subjects in ~10 frames — limit ${settings.capacity}`);
+    }
+  }, [predictAlert, predicted, history.length, settings.capacity, addAlert]);
+
+  // ── File handling ──
+  const handleFile = useCallback((f) => {
+    setFile(f);
+    setResultImg(null);
+    setHistory([]);
+    setPeak(0);
+    setFencePoints([]);
+    setZoom(1);
+    setPan({ x: 0, y: 0 });
+    setUploadProgress(0);
+    setStats({ count: 0, unique: 0, latency: 0, frames: 0 });
+    sessionStartTs.current = Date.now();
+    // Revoke any old preview URLs to avoid memory leaks
+    if (preview)      URL.revokeObjectURL(preview);
+    if (videoPreview) URL.revokeObjectURL(videoPreview);
+    if (f.type.startsWith('video')) {
+      setFileType('video');
+      setPreview(null);
+      setVideoPreview(URL.createObjectURL(f));
+    } else {
+      setFileType('image');
+      setPreview(URL.createObjectURL(f));
+      setVideoPreview(null);
+    }
+    addAlert('info', 'Feed Loaded', `${f.name.slice(0, 28)} (${(f.size/1024/1024).toFixed(1)} MB)`);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [addAlert]);
+
+  const onDrop = (e) => {
+    e.preventDefault(); setDragActive(false);
+    if (e.dataTransfer.files[0]) handleFile(e.dataTransfer.files[0]);
+  };
+  const onDrag = (e) => {
+    e.preventDefault();
+    setDragActive(e.type === 'dragenter' || e.type === 'dragover');
+  };
+
+  // ── Zoom via scroll wheel (GAP 4) ──
+  const onWheel = (e) => {
+    e.preventDefault();
+    setZoom(z => Math.min(5, Math.max(1, z - e.deltaY * 0.002)));
+  };
+
+  // ── Pan via mouse drag (GAP 4) ──
+  const onMouseDown = (e) => {
+    if (zoom <= 1) return;
+    isPanning.current = true;
+    panStart.current  = { x: e.clientX, y: e.clientY };
+    panOrigin.current = { ...pan };
+    e.currentTarget.style.cursor = 'grabbing';
+  };
+  const onMouseMove = (e) => {
+    if (!isPanning.current) return;
+    setPan({
+      x: panOrigin.current.x + (e.clientX - panStart.current.x),
+      y: panOrigin.current.y + (e.clientY - panStart.current.y),
+    });
+  };
+  const onMouseUp = (e) => {
+    isPanning.current = false;
+    if (e.currentTarget) e.currentTarget.style.cursor = zoom > 1 ? 'grab' : 'crosshair';
+  };
+
+  // ── Zone fencing click ──
+  const onViewerClick = (e) => {
+    if (!drawingFence || !viewerRef.current || isPanning.current) return;
+    const r  = viewerRef.current.getBoundingClientRect();
+    const xr = (e.clientX - r.left) / r.width;
+    const yr = (e.clientY - r.top)  / r.height;
+    setFencePoints(fp => [...fp, { x: xr, y: yr }]);
+  };
+
+  // ── Wheel listener (must be non-passive) ──
+  useEffect(() => {
+    const el = viewerRef.current;
+    if (!el) return;
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  });
+
+  // ── Image scan ──
+  const executeImageScan = async () => {
+    if (!file) return;
+    setLoading(true);
+    addAlert('info', 'Scan Initiated', 'Neural engine processing frame...');
+
+    const form = new FormData();
+    form.append('file', file);
+    form.append('confidence_threshold',
+      settings.mode === 'Performance' ? '0.45' : settings.mode === 'Accuracy' ? '0.25' : '0.35');
+    form.append('magnification',        parseFloat(settings.magnification).toFixed(2));
+    form.append('nms_radius',           parseFloat(settings.nmsRadius).toFixed(2));
+    form.append('use_heatmap',          String(settings.heatmap));
+    form.append('use_clustering',       String(settings.clustering));
+    form.append('use_motion_vectors',   String(settings.motionVecs));
+    form.append('fencing_polygon',      JSON.stringify(fencePoints));
+    form.append('inference_batch_size', '8');
+    form.append('patch_overlap',
+      settings.mode === 'Performance' ? '0.0' : settings.mode === 'Accuracy' ? '0.5' : '0.25');
+    form.append('inference_strategy',   'Auto');
+    form.append('max_resolution',       '3840');
+
+    try {
+      if (!API_BASE) throw new Error(API_CONFIG_ERROR);
+      const res = await fetch(`${API_BASE}/api/process-image`, { method: 'POST', body: form });
+      const responseText = await res.text();
+      let data;
+      try {
+        data = responseText ? JSON.parse(responseText) : {};
+      } catch {
+        data = { detail: responseText || `HTTP ${res.status}` };
+      }
+      if (!res.ok) throw new Error(data.detail || `Image scan failed (HTTP ${res.status})`);
+      if (data.detail) throw new Error(data.detail);
+
+      setResultImg(`data:image/jpeg;base64,${data.imageB64}`);
+      const c = data.count;
+      const ts = nowStr();
+      setStats(s => ({ ...s, count: c, unique: c, latency: data.elapsed }));
+      setPeak(p => Math.max(p, c));
+      setHistory([{ label: ts, count: c }]);
+
+      const t = getThreat(c, settings.capacity);
+      if      (t === THREAT.DANGER)   addAlert('danger',  '⚠ Capacity Breach',  `${c} subjects — limit ${settings.capacity}`);
+      else if (t === THREAT.MODERATE) addAlert('warning', 'Elevated Density',    `Zone at ${Math.round(c / settings.capacity * 100)}%`);
+      else                            addAlert('info',    'Scan Complete',         `${c} subjects in ${data.elapsed.toFixed(2)}s`);
+
+    } catch (err) {
+      addAlert('danger', 'Scan Failed', err?.message || 'Unknown image scan error');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  // ── Video stream ──
+  const streamVideo = async () => {
+    if (!file) return;
+    setLoading(true);
+    setHistory([]);
+    setPeak(0);
+    setUploadProgress(0);
+    addAlert('info', 'Uploading Video', `${file.name.slice(0,28)} — ${(file.size/1024/1024).toFixed(1)} MB`);
+
+    try {
+      if (!API_BASE) throw new Error(API_CONFIG_ERROR);
+      // Use XMLHttpRequest so we can track upload progress
+      const file_id = await new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        const form = new FormData();
+        form.append('file', file);
+
+        xhr.open('POST', `${API_BASE}/api/upload-video`, true);
+
+        xhr.upload.onprogress = (e) => {
+          if (e.lengthComputable) {
+            setUploadProgress(Math.round((e.loaded / e.total) * 100));
+          }
+        };
+
+        xhr.onload = () => {
+          if (xhr.status === 200) {
+            try {
+              const data = JSON.parse(xhr.responseText);
+              resolve(data.file_id);
+            } catch {
+              reject(new Error('Invalid server response'));
+            }
+          } else {
+            try {
+              const err = JSON.parse(xhr.responseText);
+              reject(new Error(err.detail || `Upload failed (HTTP ${xhr.status})`));
+            } catch {
+              reject(new Error(`Upload failed (HTTP ${xhr.status})`));
+            }
+          }
+        };
+        xhr.onerror = () => reject(new Error('Network error during upload'));
+        xhr.send(form);
+      });
+
+      setUploadProgress(100);
+      addAlert('info', 'Upload Complete', 'Connecting to inference engine...');
+
+      const ws = new WebSocket(`${WS_BASE}/api/stream-video/${file_id}`);
+      wsRef.current = ws;
+      let lastCapacityAlertFrame = -999;
+
+      ws.onopen = () => {
+        setWsConnected(true);
+        addAlert('info', 'WebSocket Live', 'Real-time telemetry stream established');
+        ws.send(JSON.stringify({
+          settings: {
+            confidenceThresh:
+              settings.mode === 'Performance' ? 0.45 : settings.mode === 'Accuracy' ? 0.25 : 0.35,
+            magnification:   parseFloat(parseFloat(settings.magnification).toFixed(2)),
+            nmsRadius:       parseFloat(parseFloat(settings.nmsRadius).toFixed(2)),
+            useHeatmap:      Boolean(settings.heatmap),
+            useClustering:   Boolean(settings.clustering),
+            useMotionVecs:   Boolean(settings.motionVecs),
+            frameSkip:       Math.round(settings.frameSkip),
+            fencingPolygon:  fencePoints,
+            capacityLimit:   Math.round(settings.capacity),
+          }
+        }));
+      };
+
+      ws.onmessage = (e) => {
+        const payload = JSON.parse(e.data);
+        if (payload.status === 'playing') {
+          setResultImg(`data:image/jpeg;base64,${payload.imageB64}`);
+          const c   = payload.count;
+          const ts  = nowStr();
+          setStats(s => ({ ...s, count: c, unique: payload.total_unique, frames: payload.frame }));
+          setPeak(p => Math.max(p, c));
+          setHistory(h => [...h, { label: ts, count: c }]);
+
+          if (payload.anomalyEvent)
+            addAlert('danger', '⚠ CHAOS DETECTED', `Rapid movement at frame ${payload.frame}`);
+
+          const t = getThreat(c, settings.capacity);
+          if (t === THREAT.DANGER && payload.frame - lastCapacityAlertFrame > 30) {
+            lastCapacityAlertFrame = payload.frame;
+            addAlert('danger', 'Zone Overcrowding', `${c} subjects — ${Math.round(c / settings.capacity * 100)}%`);
+          }
+        } else if (payload.status === 'done') {
+          ws.close();
+          addAlert('info', 'Stream Complete', `${payload.total_unique ?? '?'} unique subjects archived`);
+          saveSession(file.name);
+        } else if (payload.status === 'error') {
+          ws.close();
+          addAlert('danger', 'Engine Error', payload.message || 'Unknown stream error');
+        }
+      };
+
+      ws.onerror = () => addAlert('danger', 'Stream Error', 'WebSocket connection failed');
+      ws.onclose = () => {
+        setWsConnected(false);
+        setLoading(false);
+        wsRef.current = null;
+      };
+
+    } catch (err) {
+      addAlert('danger', 'Upload Failed', err.message);
+      setLoading(false);
+    }
+  };
+
+  const terminateStream = () => {
+    wsRef.current?.close();
+    setLoading(false);
+    addAlert('warning', 'Stream Terminated', 'Operator manually terminated');
+  };
+
+  // ── Session save ──
+  const saveSession = (name) => {
+    const elapsed = sessionStartTs.current ? secStr(Date.now() - sessionStartTs.current) : '—';
+    const session = {
+      id: uid(), name, peak: peakCount,
+      avg: avgCount, alerts: alerts.length,
+      elapsed, time: new Date().toLocaleString(),
+      history: history.slice(-300),
+    };
+    setSessions(prev => {
+      const next = [session, ...prev].slice(0, 20);
+      localStorage.setItem('cp_sessions', JSON.stringify(next));
+      return next;
+    });
+  };
+
+  // ── Export ──
+  const exportReport = () => {
+    const report = {
+      generated: new Date().toISOString(),
+      file: file?.name, peakCount, avgCount,
+      alertCount: alerts.length, settings, history,
+      alerts: alerts.map(a => ({ time: a.time, type: a.type, title: a.title, msg: a.msg })),
+    };
+    const blob = new Blob([JSON.stringify(report, null, 2)], { type: 'application/json' });
+    const url  = URL.createObjectURL(blob);
+    const a    = document.createElement('a');
+    a.href = url; a.download = `civic_pulse_${Date.now()}.json`; a.click();
+    URL.revokeObjectURL(url);
+    addAlert('info', 'Report Exported', 'Analytics report downloaded');
+  };
+
+  // ── Fence SVG ──
+  const fenceSvg = viewerRef.current && fencePoints.length > 0 ? (() => {
+    const { offsetWidth: w, offsetHeight: h } = viewerRef.current;
+    return { pts: fencePoints.map(p => `${p.x * w},${p.y * h}`).join(' '), w, h };
+  })() : null;
+
+  const handleExecute  = () => fileType === 'video' ? streamVideo() : executeImageScan();
+  const toggleSetting  = (key) => setSettings(s => ({ ...s, [key]: !s[key] }));
+  const setSetting     = (key, val) => setSettings(s => ({ ...s, [key]: val }));
+  const countClass     = threat === THREAT.DANGER ? 'danger' : threat === THREAT.MODERATE ? 'moderate' : '';
+
+  // ──────────────────────────────────────────────
+  return (
+    <div className="dashboard">
+
+      {/* ════════ TOP NAVBAR ════════ */}
+      <nav className="navbar">
+        <div className="navbar-brand">
+          <div className="navbar-logo"><Shield /></div>
+          <div>
+            <div className="navbar-title">CIVIC PULSE</div>
+            <div className="navbar-subtitle">Tactical Crowd Intelligence</div>
+          </div>
+        </div>
+
+        <div className="navbar-center">
+          <div className={`threat-level ${threat.cls}`}>
+            <span className="threat-dot" />
+            THREAT: {threat.label}
+          </div>
+          {predictAlert && (
+            <div className="threat-level moderate" style={{ fontSize: '0.6rem' }}>
+              <Brain size={10} />
+              PREDICT: ~{predicted} SOON
+            </div>
+          )}
+          <div className={`ws-status ${wsConnected ? 'connected' : 'disconnected'}`}>
+            {wsConnected ? <Wifi size={12} /> : <WifiOff size={12} />}
+            {wsConnected ? 'STREAM LIVE' : 'STANDBY'}
+          </div>
+        </div>
+
+        <div className="navbar-stats">
+          <div className="nav-stat"><span className="nav-stat-label">FPS</span><span className="nav-stat-value">{fps}</span></div>
+          <div className="nav-stat"><span className="nav-stat-label">PEAK</span><span className="nav-stat-value">{peakCount}</span></div>
+          <div className="nav-stat"><span className="nav-stat-label">AVG</span><span className="nav-stat-value">{avgCount}</span></div>
+          <div className="nav-stat">
+            <span className="nav-stat-label">ALERTS</span>
+            <span className="nav-stat-value" style={{ color: alerts[0]?.type === 'danger' ? 'var(--danger)' : undefined }}>{alerts.length}</span>
+          </div>
+          <div className="nav-stat"><span className="nav-stat-label">TIME</span><span className="nav-stat-value">{clock}</span></div>
+
+          {/* ── Theme Toggle ── */}
+          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 3, marginLeft: 8 }}>
+            <span className="theme-label">{theme === 'dark' ? 'Dark' : 'Light'}</span>
+            <div
+              className="theme-toggle"
+              onClick={toggleTheme}
+              title={`Switch to ${theme === 'dark' ? 'Light' : 'Dark'} mode`}
+            >
+              <div className="theme-toggle-thumb">
+                {theme === 'dark' ? <Moon size={10} style={{ color: '#94a3b8' }} /> : <Sun size={10} style={{ color: '#fff' }} />}
+              </div>
+            </div>
+          </div>
+        </div>
+      </nav>
+
+      {/* ════════ LEFT PANEL ════════ */}
+      <aside className="left-panel panel">
+
+        {/* Upload */}
+        <div className="panel-section">
+          <div className="section-header">
+            <Upload size={16} className="section-icon" />
+            <span className="section-title">Ingest Data</span>
+          </div>
+          <div
+            className={`upload-zone ${dragActive ? 'drag-active' : ''}`}
+            onDragEnter={onDrag} onDragLeave={onDrag} onDragOver={onDrag} onDrop={onDrop}
+            onClick={() => fileInputRef.current?.click()}
+          >
+            {/* Explicit MIME types — critical for Windows file dialog */}
+            <input ref={fileInputRef} type="file"
+              accept="image/jpeg,image/png,image/gif,image/bmp,image/webp,image/tiff,video/mp4,video/avi,video/quicktime,video/x-matroska,video/webm,video/x-msvideo,video/*,image/*"
+              style={{ display: 'none' }}
+              onChange={e => e.target.files[0] && handleFile(e.target.files[0])} />
+            {/* Video preview thumbnail */}
+            {videoPreview ? (
+              <div style={{ width: '100%', marginBottom: 8 }}>
+                <video
+                  src={videoPreview}
+                  style={{ width: '100%', maxHeight: 80, borderRadius: 6, objectFit: 'cover', display: 'block' }}
+                  muted preload="metadata"
+                />
+                {/* Upload progress bar */}
+                {loading && uploadProgress < 100 && (
+                  <div style={{ marginTop: 6, background: 'var(--bg-input)', borderRadius: 4, overflow: 'hidden', height: 4 }}>
+                    <div style={{
+                      height: '100%', borderRadius: 4,
+                      background: 'linear-gradient(90deg, var(--primary), var(--blue))',
+                      width: `${uploadProgress}%`,
+                      transition: 'width 0.3s ease',
+                      boxShadow: '0 0 6px var(--primary-glow)'
+                    }} />
+                  </div>
+                )}
+              </div>
+            ) : (
+              <span className="upload-icon">🛰️</span>
+            )}
+            <div className="upload-title">
+              {file
+                ? file.name.slice(0, 22)
+                : 'Load Aerial Feed'}
+            </div>
+            <div className="upload-sub">
+              {file
+                ? `${(file.size/1024/1024).toFixed(1)} MB · ${fileType}${
+                    loading && uploadProgress > 0 && uploadProgress < 100
+                      ? ` · uploading ${uploadProgress}%` : ''}`
+                : 'Image or Video (drag & drop)'}
+            </div>
+          </div>
+        </div>
+
+        {/* Overlay Toggles */}
+        <div className="panel-section">
+          <div className="section-header">
+            <Layers size={16} className="section-icon" />
+            <span className="section-title">Overlay Layers</span>
+          </div>
+          {[
+            { key: 'heatmap',    label: 'Heatmap Density', Icon: Thermometer },
+            { key: 'clustering', label: 'AI Pod Clustering', Icon: GitBranch },
+            { key: 'showPoints', label: 'Head Points',       Icon: Crosshair },
+            { key: 'motionVecs', label: 'Motion Vectors',    Icon: Wind },      // GAP 5
+          ].map(({ key, label, Icon }) => (
+            <div key={key} className="toggle-row" onClick={() => toggleSetting(key)}>
+              <span className="toggle-label"><Icon size={13} />{label}</span>
+              <div className={`toggle-switch ${settings[key] ? 'on' : ''}`} />
+            </div>
+          ))}
+
+          {/* GAP 2: Overlay Opacity Slider */}
+          <div className="slider-group" style={{ marginTop: 10 }}>
+            <div className="slider-header">
+              <span>Overlay Opacity</span>
+              <span className="slider-value">{settings.overlayOpacity}%</span>
+            </div>
+            <input type="range" min={20} max={100} step={5}
+              value={settings.overlayOpacity}
+              onChange={e => setSetting('overlayOpacity', +e.target.value)} />
+          </div>
+        </div>
+
+        {/* Engine Mode */}
+        <div className="panel-section">
+          <div className="section-header">
+            <Cpu size={16} className="section-icon" />
+            <span className="section-title">Engine Mode</span>
+          </div>
+          <select className="mode-select" value={settings.mode}
+            onChange={e => setSetting('mode', e.target.value)}>
+            <option value="Performance">Performance (Fast)</option>
+            <option value="Balanced">Balanced</option>
+            <option value="Accuracy">Accuracy (Slow)</option>
+          </select>
+        </div>
+
+        {/* Parameters */}
+        <div className="panel-section">
+          <div className="section-header">
+            <BarChart2 size={16} className="section-icon" />
+            <span className="section-title">Parameters</span>
+          </div>
+          {[
+            { key: 'capacity',      label: 'Capacity Limit',  suffix: '',   min: 10,  max: 1000, step: 5,   isInt: true  },
+            { key: 'magnification', label: 'Magnification',   suffix: '×',  min: 1.0, max: 3.0,  step: 0.1, isInt: false },
+            { key: 'nmsRadius',     label: 'NMS Radius',      suffix: 'px', min: 3.0, max: 20.0, step: 0.5, isInt: false },
+            { key: 'frameSkip',     label: 'Frame Skip',      suffix: '',   min: 1,   max: 15,   step: 1,   isInt: true  },
+          ].map(({ key, label, suffix, min, max, step, isInt }) => (
+            <div className="slider-group" key={key} style={{ marginTop: 10 }}>
+              <div className="slider-header">
+                <span>{label}</span>
+                <span className="slider-value">
+                  {isInt
+                    ? Math.round(settings[key])
+                    : parseFloat(settings[key]).toFixed(1)}{suffix}
+                </span>
+              </div>
+              <input type="range" min={min} max={max} step={step}
+                value={settings[key]}
+                onChange={e => setSetting(key, isInt ? Math.round(+e.target.value) : parseFloat((+e.target.value).toFixed(2)))} />
+            </div>
+          ))}
+        </div>
+
+        {/* Zone Fencing */}
+        <div className="panel-section">
+          <div className="section-header">
+            <Map size={16} className="section-icon" />
+            <span className="section-title">Zone Fencing</span>
+          </div>
+          <div className="toggle-row" onClick={() => setDrawingFence(d => !d)}>
+            <span className="toggle-label"><Target size={13} />Draw Zone Polygon</span>
+            <div className={`toggle-switch ${drawingFence ? 'on' : ''}`} />
+          </div>
+          <div className="fencing-controls">
+            {fencePoints.length > 0
+              ? <div className="fencing-info">{fencePoints.length} anchor point{fencePoints.length !== 1 ? 's' : ''} — AI counts only inside zone.</div>
+              : drawingFence && <div className="fencing-info">Click on the feed to drop anchor points.</div>
+            }
+            {fencePoints.length > 0 && (
+              <button className="btn-clear-fence" onClick={() => setFencePoints([])}>Clear Zone Fence</button>
+            )}
+          </div>
+        </div>
+
+        {/* Zoom / Pan Controls (GAP 4) */}
+        <div className="panel-section">
+          <div className="section-header">
+            <Move size={16} className="section-icon" />
+            <span className="section-title">Viewport ({zoom.toFixed(1)}×)</span>
+          </div>
+          <div style={{ display: 'flex', gap: 6 }}>
+            <button className="btn-secondary" style={{ flex: 1 }}
+              onClick={() => setZoom(z => Math.min(5, +(z + 0.5).toFixed(1)))}>
+              <ZoomIn size={12} style={{ marginRight: 4, verticalAlign: 'middle' }} />Zoom In
+            </button>
+            <button className="btn-secondary" style={{ flex: 1 }}
+              onClick={() => { setZoom(z => Math.max(1, +(z - 0.5).toFixed(1))); setPan({ x: 0, y: 0 }); }}>
+              <ZoomOut size={12} style={{ marginRight: 4, verticalAlign: 'middle' }} />Zoom Out
+            </button>
+          </div>
+          {zoom > 1 && (
+            <button className="btn-secondary" style={{ marginTop: 6 }}
+              onClick={() => { setZoom(1); setPan({ x: 0, y: 0 }); }}>
+              <RotateCcw size={12} style={{ marginRight: 4, verticalAlign: 'middle' }} />Reset View
+            </button>
+          )}
+        </div>
+
+        {/* Execute & Export */}
+        <div className="panel-section" style={{ marginTop: 'auto' }}>
+          {!loading ? (
+            <>
+              <button className="btn-execute" onClick={handleExecute} disabled={!file}>
+                <Play size={14} style={{ marginRight: 6, verticalAlign: 'middle' }} />
+                {fileType === 'video' ? 'Initialize Stream' : 'Execute Scan'}
+              </button>
+              <button className="btn-secondary" onClick={exportReport} disabled={history.length === 0}>
+                <Download size={12} style={{ marginRight: 4, verticalAlign: 'middle' }} />
+                Export Report
+              </button>
+            </>
+          ) : (
+            <button className="btn-execute terminate" onClick={terminateStream}>
+              <Square size={14} style={{ marginRight: 6, verticalAlign: 'middle' }} />
+              Terminate Stream
+            </button>
+          )}
+        </div>
+      </aside>
+
+      {/* ════════ CENTER PANEL ════════ */}
+      <main
+        className="center-panel"
+        ref={viewerRef}
+        onClick={onViewerClick}
+        onMouseDown={onMouseDown}
+        onMouseMove={onMouseMove}
+        onMouseUp={onMouseUp}
+        onMouseLeave={onMouseUp}
+        style={{ cursor: zoom > 1 ? (isPanning.current ? 'grabbing' : 'grab') : drawingFence ? 'crosshair' : 'default' }}
+      >
+        <div className="scan-lines" />
+
+        {/* Topbar */}
+        <div className="panel-topbar">
+          <div className="panel-topbar-title">
+            <Eye size={14} />
+            AERIAL FEED
+            {(loading || wsConnected) && <span className="live-badge">LIVE</span>}
+            {zoom > 1 && <span style={{ fontSize: '0.6rem', color: 'var(--blue)', marginLeft: 6 }}>{zoom.toFixed(1)}×</span>}
+          </div>
+          <div className="video-overlay-controls">
+            {[
+              { key: 'heatmap',    Icon: Thermometer, title: 'Heatmap'    },
+              { key: 'clustering', Icon: GitBranch,   title: 'Clustering' },
+              { key: 'motionVecs', Icon: Wind,         title: 'Motion Vecs'},
+              { key: 'drawFence',  Icon: Target,       title: 'Draw Zone'  },
+            ].map(({ key, Icon, title }) => (
+              <div key={key}
+                className={`overlay-btn ${(key === 'drawFence' ? drawingFence : settings[key]) ? 'active' : ''}`}
+                title={title}
+                onClick={e => {
+                  e.stopPropagation();
+                  if (key === 'drawFence') setDrawingFence(d => !d);
+                  else toggleSetting(key);
+                }}>
+                <Icon size={13} />
+              </div>
+            ))}
+            <div className="overlay-btn" title="Zoom In"
+              onClick={e => { e.stopPropagation(); setZoom(z => Math.min(5, +(z + 0.5).toFixed(1))); }}>
+              <ZoomIn size={13} />
+            </div>
+            <div className="overlay-btn" title="Fullscreen"
+              onClick={e => { e.stopPropagation(); viewerRef.current?.requestFullscreen?.(); }}>
+              <Maximize2 size={13} />
+            </div>
+          </div>
+        </div>
+
+        {/* Loading state */}
+        {loading && !resultImg && (
+          <div className="loader-overlay">
+            <div className="spinner" />
+            <div className="loader-text">
+              {fileType === 'video' ? 'Initializing Telemetry...' : 'Neural Engine Processing...'}
+            </div>
+          </div>
+        )}
+
+        {/* Image / video feed with zoom+pan+opacity (GAP 2, 4) */}
+        <div style={{
+          position: 'absolute', inset: 0,
+          transform: `scale(${zoom}) translate(${pan.x / zoom}px, ${pan.y / zoom}px)`,
+          transformOrigin: 'center center',
+          transition: isPanning.current ? 'none' : 'transform 0.15s ease',
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+        }}>
+          {resultImg && (
+            <img src={resultImg} className="main-feed fade-up" alt="Analysis feed"
+              style={{ opacity: settings.overlayOpacity / 100 }}
+            />
+          )}
+          {!resultImg && preview && !loading && (
+            <img src={preview} className="main-feed" alt="Preview"
+              style={{ opacity: (settings.overlayOpacity / 100) * 0.6, filter: 'grayscale(20%)' }} />
+          )}
+        </div>
+
+        {/* Empty state */}
+        {!resultImg && !preview && !loading && (
+          <div className="empty-feed">
+            <div className="empty-feed-icon"><Radio size={36} /></div>
+            <div className="empty-feed-text">No Feed Detected</div>
+            <div className="empty-feed-sub">Upload aerial imagery or video to begin analysis</div>
+          </div>
+        )}
+
+        {/* Fencing SVG */}
+        {drawingFence && viewerRef.current && (
+          <svg className="fencing-svg-overlay"
+            width={viewerRef.current.offsetWidth}
+            height={viewerRef.current.offsetHeight}>
+            {fenceSvg && (
+              <>
+                <polygon
+                  points={fenceSvg.pts}
+                  fill="rgba(56,189,248,0.12)"
+                  stroke="#38bdf8" strokeWidth={1.5} strokeDasharray="6,4"
+                />
+                {fencePoints.map((p, i) => (
+                  <circle key={i}
+                    cx={p.x * fenceSvg.w} cy={p.y * fenceSvg.h}
+                    r={5} fill="var(--teal)"
+                    stroke="rgba(0,230,184,0.4)" strokeWidth={2}
+                  />
+                ))}
+              </>
+            )}
+          </svg>
+        )}
+
+        {/* Count overlay */}
+        {(resultImg || stats.count > 0) && (
+          <div className="count-overlay">
+            <div className="count-overlay-label">Zone Population</div>
+            <div className={`count-overlay-value ${countClass}`}>{stats.count}</div>
+          </div>
+        )}
+
+        {/* Anomaly banner */}
+        {anomalyActive && (
+          <div className="anomaly-banner">
+            <AlertTriangle size={18} />
+            ANOMALY DETECTED — CHAOS / COUNTERFLOW
+          </div>
+        )}
+
+        {/* Predictive warning overlay */}
+        {predictAlert && !anomalyActive && (
+          <div className="anomaly-banner" style={{
+            background: 'rgba(245,158,11,0.12)',
+            border: '1.5px solid var(--moderate)',
+            color: 'var(--moderate)',
+            boxShadow: '0 0 30px var(--moderate-glow)',
+          }}>
+            <Brain size={18} />
+            PREDICTIVE ALERT — CAPACITY BREACH IMMINENT (~{predicted} subjects)
+          </div>
+        )}
+      </main>
+
+      {/* ════════ RIGHT INTELLIGENCE PANEL ════════ */}
+      <aside className="right-panel panel">
+        {/* Alert Feed */}
+        <div className="right-panel-section" style={{ flex: '3 1 0' }}>
+          <div className="panel-header">
+            <div className="panel-header-title">
+              <AlertTriangle size={13} />Alert Feed
+            </div>
+            {alerts.length > 0 && <div className="panel-header-count">{alerts.length}</div>}
+          </div>
+          <div className="alert-feed">
+            {alerts.length === 0
+              ? <div className="alert-empty"><Shield size={28} /><p>All systems nominal</p></div>
+              : alerts.map(a => <AlertItem key={a.id} type={a.type} title={a.title} msg={a.msg} time={a.time} />)
+            }
+          </div>
+        </div>
+
+        {/* Session History */}
+        <div className="right-panel-section" style={{ flex: '2 1 0' }}>
+          <div className="panel-header">
+            <div className="panel-header-title"><Database size={13} />Session History</div>
+            {sessions.length > 0 && (
+              <button className="btn-export" style={{ fontSize: '0.6rem', padding: '2px 8px' }}
+                onClick={() => { setSessions([]); localStorage.removeItem('cp_sessions'); }}>
+                Clear
+              </button>
+            )}
+          </div>
+          <div className="session-list">
+            {sessions.length === 0
+              ? <div className="session-empty"><Database size={24} /><span>No sessions recorded</span></div>
+              : sessions.map(s => (
+                <div key={s.id} className="session-item"
+                  onClick={() => s.history?.length && setHistory(s.history)}>
+                  <div className="session-name">{s.name.slice(0, 28)}</div>
+                  <div className="session-meta">
+                    <span><TrendingUp size={10} />{s.peak}</span>
+                    <span><Gauge size={10} />{s.avg}</span>
+                    <span><AlertTriangle size={10} />{s.alerts}</span>
+                    <span style={{ marginLeft: 'auto' }}>{s.elapsed}</span>
+                  </div>
+                </div>
+              ))
+            }
+          </div>
+        </div>
+      </aside>
+
+      {/* ════════ BOTTOM ANALYTICS PANEL ════════ */}
+      <section className="bottom-panel panel">
+
+        {/* Metric: Zone Population */}
+        <div className="metric-card">
+          <div className="metric-label"><Users size={11} />Zone Pop.</div>
+          <div>
+            <div className={`metric-value ${countClass}`}>{stats.count}</div>
+            <div className="metric-sub">Current frame</div>
+          </div>
+        </div>
+
+        {/* Metric: Unique Subjects */}
+        <div className="metric-card">
+          <div className="metric-label"><Crosshair size={11} />Unique</div>
+          <div>
+            <div className="metric-value blue">{stats.unique}</div>
+            <div className="metric-sub">Tracked subjects</div>
+          </div>
+        </div>
+
+        {/* Metric: Avg Density (GAP 3) */}
+        <div className="metric-card">
+          <div className="metric-label"><Gauge size={11} />Density</div>
+          <div>
+            <div className={`metric-value ${density.cls}`} style={{ fontSize: '1.5rem', letterSpacing: '-0.5px' }}>
+              {density.label}
+            </div>
+            <div className="metric-sub">Avg {avgCount} · Peak {peakCount}</div>
+          </div>
+        </div>
+
+        {/* Metric: Latency / Frames */}
+        <div className="metric-card">
+          <div className="metric-label"><Activity size={11} />Latency</div>
+          <div>
+            <div className="metric-value" style={{ fontSize: '1.6rem' }}>
+              {fileType === 'video'
+                ? (stats.frames || 0)
+                : (stats.latency > 0 ? stats.latency.toFixed(2) : '—')}
+            </div>
+            <div className="metric-sub">{fileType === 'video' ? 'frames processed' : 'seconds'}</div>
+          </div>
+        </div>
+
+        {/* Chart (GAP 1: time-formatted X-axis) */}
+        <div className="chart-area">
+          <div className="chart-header">
+            <div className="chart-title">Population Dynamics Timeline</div>
+            <div className="export-actions">
+              <button className="btn-export" onClick={exportReport} disabled={history.length === 0}>
+                <Download size={11} />Report
+              </button>
+              <button className="btn-export"
+                style={{ borderColor: 'rgba(167,139,250,0.3)', color: 'var(--purple)', background: 'rgba(167,139,250,0.06)' }}
+                onClick={() => setHistory([])} disabled={history.length === 0}>
+                <RotateCcw size={11} />Reset
+              </button>
+            </div>
+          </div>
+          <div className="chart-wrapper">
+            {history.length > 0 ? (
+              <ResponsiveContainer width="100%" height="100%">
+                <AreaChart data={history} margin={{ top: 4, right: 8, left: -20, bottom: 0 }}>
+                  <defs>
+                    <linearGradient id="tealGrad" x1="0" y1="0" x2="0" y2="1">
+                      <stop offset="5%"  stopColor="var(--teal)" stopOpacity={0.25} />
+                      <stop offset="95%" stopColor="var(--teal)" stopOpacity={0}    />
+                    </linearGradient>
+                  </defs>
+                  <CartesianGrid strokeDasharray="2 4" stroke="rgba(255,255,255,0.04)" />
+                  {/* GAP 1: X-axis shows HH:MM:SS time label */}
+                  <XAxis dataKey="label"
+                    stroke="rgba(255,255,255,0.12)"
+                    tick={{ fontSize: 8, fill: 'var(--text-muted)', fontFamily: 'Orbitron' }}
+                    interval="preserveStartEnd"
+                  />
+                  <YAxis stroke="rgba(255,255,255,0.12)"
+                    tick={{ fontSize: 9, fill: 'var(--text-muted)' }} />
+                  <Tooltip content={<CTooltip />} />
+                  {settings.capacity > 0 && (
+                    <ReferenceLine y={settings.capacity}
+                      stroke="var(--danger)" strokeDasharray="4 4" strokeOpacity={0.5}
+                      label={{ value: 'LIMIT', fill: 'var(--danger)', fontSize: 9, fontFamily: 'Orbitron' }}
+                    />
+                  )}
+                  <Area type="monotone" dataKey="count"
+                    stroke="var(--teal)" strokeWidth={2.5}
+                    fill="url(#tealGrad)"
+                    dot={false}
+                    activeDot={{ r: 5, fill: 'var(--bg-base)', stroke: 'var(--teal)', strokeWidth: 2 }}
+                    isAnimationActive={false}
+                  />
+                </AreaChart>
+              </ResponsiveContainer>
+            ) : (
+              <div className="chart-empty-state">Run an image scan or video stream to populate analytics.</div>
+            )}
+          </div>
+        </div>
+      </section>
+    </div>
+  );
+}

frontend/src/index.css

@@ -0,0 +1,607 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=Orbitron:wght@400;500;600;700;800;900&display=swap');
+
+/* ============================================
+   DARK THEME (default)
+   ============================================ */
+:root,
+[data-theme="dark"] {
+  --bg-base:        #080c14;
+  --bg-surface:     #0d1117;
+  --bg-panel:       rgba(13, 20, 35, 0.88);
+  --bg-input:       rgba(255, 255, 255, 0.05);
+  --bg-hover:       rgba(255, 255, 255, 0.08);
+
+  --primary:        #00e6b8;
+  --primary-dim:    #00b891;
+  --primary-glow:   rgba(0, 230, 184, 0.28);
+  --primary-border: rgba(0, 230, 184, 0.22);
+
+  --blue:           #38bdf8;
+  --blue-glow:      rgba(56, 189, 248, 0.22);
+
+  --purple:         #a78bfa;
+  --purple-glow:    rgba(167, 139, 250, 0.22);
+
+  --safe:           #22c55e;
+  --safe-glow:      rgba(34, 197, 94,  0.30);
+  --moderate:       #f59e0b;
+  --moderate-glow:  rgba(245, 158, 11, 0.30);
+  --danger:         #ef4444;
+  --danger-glow:    rgba(239, 68,  68, 0.35);
+
+  --text-primary:   #f0f4ff;
+  --text-secondary: #8899b4;
+  --text-muted:     #4a5568;
+
+  --border-glass:   rgba(255, 255, 255, 0.07);
+  --border-active:  rgba(0, 230, 184, 0.42);
+
+  --shadow-panel:   0 8px 32px rgba(0,0,0,0.6), 0 0 0 1px rgba(255,255,255,0.04);
+
+  --scan-line:      rgba(0,0,0,0.04);
+  --upload-bg:      rgba(0, 230, 184, 0.03);
+  --chart-gradient: rgba(0, 230, 184, 0.25);
+  --chart-gradient-end: rgba(0, 230, 184, 0);
+
+  --metric-bg:      transparent;
+  --toggle-bg:      rgba(0,0,0,0.5);
+
+  --bg-ambient-1:   rgba(59, 130, 246, 0.10);
+  --bg-ambient-2:   rgba(0, 230, 184, 0.08);
+}
+
+/* ============================================
+   LIGHT THEME
+   ============================================ */
+[data-theme="light"] {
+  --bg-base:        #f1f5f9;
+  --bg-surface:     #ffffff;
+  --bg-panel:       rgba(255, 255, 255, 0.92);
+  --bg-input:       rgba(0, 0, 0, 0.04);
+  --bg-hover:       rgba(0, 0, 0, 0.06);
+
+  --primary:        #0891b2;
+  --primary-dim:    #0e7490;
+  --primary-glow:   rgba(8, 145, 178, 0.20);
+  --primary-border: rgba(8, 145, 178, 0.25);
+
+  --blue:           #2563eb;
+  --blue-glow:      rgba(37, 99, 235, 0.18);
+
+  --purple:         #7c3aed;
+  --purple-glow:    rgba(124, 58, 237, 0.18);
+
+  --safe:           #16a34a;
+  --safe-glow:      rgba(22, 163, 74, 0.20);
+  --moderate:       #d97706;
+  --moderate-glow:  rgba(217, 119, 6, 0.22);
+  --danger:         #dc2626;
+  --danger-glow:    rgba(220, 38, 38, 0.22);
+
+  --text-primary:   #0f172a;
+  --text-secondary: #475569;
+  --text-muted:     #94a3b8;
+
+  --border-glass:   rgba(0, 0, 0, 0.09);
+  --border-active:  rgba(8, 145, 178, 0.45);
+
+  --shadow-panel:   0 4px 24px rgba(0,0,0,0.08), 0 0 0 1px rgba(0,0,0,0.05);
+
+  --scan-line:      rgba(0,0,0,0.015);
+  --upload-bg:      rgba(8, 145, 178, 0.04);
+  --chart-gradient: rgba(8, 145, 178, 0.20);
+  --chart-gradient-end: rgba(8, 145, 178, 0);
+
+  --metric-bg:      rgba(248, 250, 252, 0.9);
+  --toggle-bg:      rgba(255,255,255,0.8);
+
+  --bg-ambient-1:   rgba(8, 145, 178, 0.06);
+  --bg-ambient-2:   rgba(124, 58, 237, 0.05);
+}
+
+/* ============================================
+   RESET & BASE
+   ============================================ */
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html, body, #root { height: 100%; overflow: hidden; }
+
+body {
+  font-family: 'Inter', sans-serif;
+  background: var(--bg-base);
+  color: var(--text-primary);
+  font-size: 13px;
+  line-height: 1.5;
+  background-image:
+    radial-gradient(ellipse at 15% 50%, var(--bg-ambient-1) 0%, transparent 45%),
+    radial-gradient(ellipse at 85% 20%, var(--bg-ambient-2) 0%, transparent 45%);
+  background-attachment: fixed;
+  transition: background 0.35s ease, color 0.35s ease;
+}
+
+/* ============================================
+   THEME TOGGLE BUTTON
+   ============================================ */
+.theme-toggle {
+  width: 48px;
+  height: 26px;
+  border-radius: 13px;
+  background: var(--bg-input);
+  border: 1px solid var(--border-glass);
+  cursor: pointer;
+  position: relative;
+  transition: all 0.3s ease;
+  flex-shrink: 0;
+}
+[data-theme="dark"] .theme-toggle  { background: rgba(255,255,255,0.08); }
+[data-theme="light"] .theme-toggle { background: rgba(8,145,178,0.12); border-color: var(--primary-border); }
+
+.theme-toggle-thumb {
+  position: absolute;
+  width: 20px; height: 20px;
+  border-radius: 50%;
+  top: 2px; left: 2px;
+  background: var(--text-muted);
+  transition: all 0.35s cubic-bezier(0.4, 0, 0.2, 1);
+  display: flex; align-items: center; justify-content: center;
+  font-size: 10px;
+  box-shadow: 0 1px 4px rgba(0,0,0,0.2);
+}
+[data-theme="light"] .theme-toggle-thumb {
+  transform: translateX(22px);
+  background: var(--primary);
+  box-shadow: 0 0 8px var(--primary-glow);
+}
+
+.theme-label {
+  font-size: 0.6rem;
+  font-weight: 600;
+  letter-spacing: 0.5px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+}
+
+/* ============================================
+   DASHBOARD GRID
+   ============================================ */
+.dashboard {
+  display: grid;
+  height: 100vh;
+  grid-template-rows: 56px 1fr 220px;
+  grid-template-columns: 280px 1fr 300px;
+  grid-template-areas:
+    "navbar navbar navbar"
+    "left   center right"
+    "left   bottom right";
+  overflow: hidden;
+}
+
+/* ============================================
+   TOP NAVBAR
+   ============================================ */
+.navbar {
+  grid-area: navbar;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 20px;
+  background: var(--bg-panel);
+  border-bottom: 1px solid var(--border-glass);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  z-index: 100;
+  gap: 16px;
+  transition: background 0.35s ease, border-color 0.35s ease;
+}
+
+[data-theme="light"] .navbar {
+  box-shadow: 0 1px 12px rgba(0,0,0,0.07);
+}
+
+.navbar-brand { display: flex; align-items: center; gap: 10px; flex-shrink: 0; }
+.navbar-logo {
+  width: 32px; height: 32px; border-radius: 8px;
+  background: linear-gradient(135deg, var(--primary), var(--blue));
+  display: flex; align-items: center; justify-content: center;
+  box-shadow: 0 0 16px var(--primary-glow);
+}
+.navbar-logo svg { width: 16px; height: 16px; color: #fff; }
+
+.navbar-title {
+  font-family: 'Orbitron', sans-serif;
+  font-size: 1.05rem; font-weight: 700;
+  background: linear-gradient(135deg, var(--primary), var(--blue));
+  -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+  background-clip: text; letter-spacing: 2px;
+}
+.navbar-subtitle {
+  font-size: 0.62rem; color: var(--text-muted);
+  letter-spacing: 1.5px; text-transform: uppercase; font-weight: 500;
+}
+
+.navbar-center { display: flex; align-items: center; gap: 16px; flex: 1; justify-content: center; }
+
+.threat-level {
+  display: flex; align-items: center; gap: 8px;
+  padding: 5px 14px; border-radius: 100px; border: 1px solid;
+  font-family: 'Orbitron', sans-serif;
+  font-size: 0.65rem; font-weight: 700; letter-spacing: 1.5px; text-transform: uppercase;
+  transition: all 0.4s ease;
+}
+.threat-level.safe     { background: rgba(34,197,94,0.08);  border-color: rgba(34,197,94,0.3);  color: var(--safe);     box-shadow: 0 0 16px var(--safe-glow); }
+.threat-level.moderate { background: rgba(245,158,11,0.08); border-color: rgba(245,158,11,0.3); color: var(--moderate); box-shadow: 0 0 16px var(--moderate-glow); }
+.threat-level.danger   { background: rgba(239,68,68,0.08);  border-color: rgba(239,68,68,0.3);  color: var(--danger);   box-shadow: 0 0 16px var(--danger-glow); animation: danger-pulse 1.5s infinite; }
+@keyframes danger-pulse { 0%,100%{box-shadow:0 0 16px var(--danger-glow)}50%{box-shadow:0 0 36px var(--danger-glow),0 0 60px rgba(239,68,68,0.1)} }
+
+.threat-dot { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
+.safe     .threat-dot { background: var(--safe);     animation: blink 2s infinite; }
+.moderate .threat-dot { background: var(--moderate); animation: blink 1s infinite; }
+.danger   .threat-dot { background: var(--danger);   animation: blink 0.5s infinite; }
+@keyframes blink { 0%,100%{opacity:1}50%{opacity:0.2} }
+
+.navbar-stats { display: flex; align-items: center; gap: 16px; flex-shrink: 0; }
+.nav-stat { display: flex; flex-direction: column; align-items: flex-end; gap: 1px; }
+.nav-stat-label { font-size: 0.58rem; text-transform: uppercase; letter-spacing: 1px; color: var(--text-muted); font-weight: 600; }
+.nav-stat-value { font-family: 'Orbitron', sans-serif; font-size: 0.78rem; font-weight: 600; color: var(--primary); }
+
+.ws-status {
+  display: flex; align-items: center; gap: 6px;
+  padding: 4px 10px; border-radius: 100px;
+  font-size: 0.62rem; font-weight: 600; letter-spacing: 0.5px; text-transform: uppercase;
+  background: var(--bg-input); border: 1px solid var(--border-glass); transition: all 0.3s;
+}
+.ws-status.connected    { color: var(--safe);     border-color: rgba(34,197,94,0.25); }
+.ws-status.disconnected { color: var(--text-muted); }
+
+/* ============================================
+   GLASS PANEL BASE
+   ============================================ */
+.panel {
+  background: var(--bg-panel);
+  backdrop-filter: blur(24px); -webkit-backdrop-filter: blur(24px);
+  border: 1px solid var(--border-glass);
+  overflow: hidden;
+  transition: border-color 0.3s ease, background 0.35s ease, box-shadow 0.3s ease;
+}
+.panel:hover { border-color: var(--primary-border); }
+[data-theme="light"] .panel { box-shadow: 0 2px 16px rgba(0,0,0,0.06); }
+
+/* ============================================
+   LEFT PANEL
+   ============================================ */
+.left-panel { grid-area: left; border-right: 1px solid var(--border-glass); display: flex; flex-direction: column; overflow-y: auto; }
+.left-panel::-webkit-scrollbar { width: 3px; }
+.left-panel::-webkit-scrollbar-thumb { background: var(--primary-border); border-radius: 2px; }
+
+.panel-section { padding: 14px 16px; border-bottom: 1px solid var(--border-glass); }
+.panel-section:last-child { border-bottom: none; }
+
+.section-header { display: flex; align-items: center; gap: 8px; margin-bottom: 12px; }
+.section-title { font-size: 0.63rem; font-weight: 700; text-transform: uppercase; letter-spacing: 2px; color: var(--text-muted); }
+.section-icon { width: 15px; height: 15px; color: var(--primary); flex-shrink: 0; }
+
+.toggle-row { display: flex; align-items: center; justify-content: space-between; padding: 7px 0; cursor: pointer; }
+.toggle-row:hover { opacity: 0.82; }
+.toggle-label { display: flex; align-items: center; gap: 8px; font-size: 0.8rem; font-weight: 500; color: var(--text-secondary); }
+.toggle-label svg { width: 12px; height: 12px; color: var(--primary); flex-shrink: 0; }
+
+.toggle-switch {
+  width: 36px; height: 20px; border-radius: 10px;
+  background: var(--bg-input); border: 1px solid var(--border-glass);
+  position: relative; transition: all 0.3s cubic-bezier(0.4,0,0.2,1); flex-shrink: 0; cursor: pointer;
+}
+.toggle-switch.on {
+  background: linear-gradient(135deg, var(--primary), var(--blue));
+  border-color: var(--primary); box-shadow: 0 0 10px var(--primary-glow);
+}
+.toggle-switch::after {
+  content: ''; position: absolute; width: 14px; height: 14px; border-radius: 50%;
+  background: white; top: 2px; left: 2px;
+  transition: transform 0.3s cubic-bezier(0.4,0,0.2,1); box-shadow: 0 1px 3px rgba(0,0,0,0.35);
+}
+[data-theme="light"] .toggle-switch::after { background: #f8fafc; box-shadow: 0 1px 3px rgba(0,0,0,0.18); }
+.toggle-switch.on::after { transform: translateX(16px); }
+
+.mode-select {
+  width: 100%; background: var(--bg-input); border: 1px solid var(--border-glass);
+  border-radius: 6px; color: var(--text-primary); font-family: 'Inter', sans-serif;
+  font-size: 0.8rem; font-weight: 500; padding: 8px 12px; cursor: pointer; outline: none;
+  -webkit-appearance: none; appearance: none; transition: all 0.2s;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='8' viewBox='0 0 12 8'%3E%3Cpath fill='%2394a3b8' d='M1 1l5 5 5-5'/%3E%3C/svg%3E");
+  background-repeat: no-repeat; background-position: right 10px center;
+}
+.mode-select:hover, .mode-select:focus { border-color: var(--primary-border); background-color: var(--bg-hover); }
+.mode-select option { background: var(--bg-surface); color: var(--text-primary); }
+
+.slider-group { display: flex; flex-direction: column; gap: 5px; padding: 3px 0; }
+.slider-header { display: flex; justify-content: space-between; font-size: 0.78rem; font-weight: 500; color: var(--text-secondary); }
+.slider-value { font-family: 'Orbitron', sans-serif; font-size: 0.68rem; font-weight: 600; color: var(--primary); }
+
+input[type=range] {
+  -webkit-appearance: none; appearance: none; width: 100%; height: 4px;
+  border-radius: 2px; background: var(--bg-input); outline: none; cursor: pointer;
+}
+input[type=range]::-webkit-slider-thumb {
+  -webkit-appearance: none; width: 16px; height: 16px; border-radius: 50%;
+  background: var(--primary); cursor: pointer; box-shadow: 0 0 8px var(--primary-glow);
+  transition: transform 0.15s, box-shadow 0.15s;
+}
+input[type=range]::-webkit-slider-thumb:hover { transform: scale(1.25); box-shadow: 0 0 16px var(--primary-glow); }
+input[type=range]::-webkit-slider-runnable-track { height: 4px; border-radius: 2px; }
+
+.upload-zone {
+  border: 1.5px dashed var(--primary-border); border-radius: 12px;
+  padding: 24px 16px; text-align: center; cursor: pointer;
+  transition: all 0.3s ease; background: var(--upload-bg); position: relative; overflow: hidden;
+}
+.upload-zone:hover, .upload-zone.drag-active {
+  border-color: var(--primary); transform: scale(1.01); background: var(--primary-glow);
+}
+[data-theme="light"] .upload-zone { background: rgba(8,145,178,0.03); }
+[data-theme="light"] .upload-zone:hover { background: rgba(8,145,178,0.07); }
+
+.upload-icon { font-size: 2rem; display: block; margin-bottom: 8px; animation: float 3s ease-in-out infinite; }
+.upload-title { font-weight: 600; color: var(--primary); font-size: 0.83rem; margin-bottom: 3px; }
+.upload-sub { color: var(--text-muted); font-size: 0.7rem; }
+
+.fencing-controls { display: flex; flex-direction: column; gap: 6px; margin-top: 4px; }
+.fencing-info {
+  padding: 6px 10px; background: rgba(37,99,235,0.08); border: 1px solid rgba(37,99,235,0.2);
+  border-radius: 6px; font-size: 0.7rem; color: var(--blue); line-height: 1.4;
+}
+[data-theme="light"] .fencing-info { background: rgba(37,99,235,0.06); }
+
+.btn-clear-fence {
+  background: rgba(220,38,38,0.08); border: 1px solid rgba(220,38,38,0.2);
+  border-radius: 6px; color: var(--danger); font-size: 0.72rem; font-weight: 600;
+  padding: 6px 10px; cursor: pointer; font-family: inherit; transition: all 0.2s;
+}
+.btn-clear-fence:hover { background: rgba(220,38,38,0.15); }
+
+.btn-execute {
+  width: 100%; padding: 11px; border: none; border-radius: 10px;
+  background: linear-gradient(135deg, var(--primary), var(--blue));
+  color: #fff; font-family: 'Orbitron', sans-serif;
+  font-size: 0.68rem; font-weight: 700; letter-spacing: 1.2px; text-transform: uppercase;
+  cursor: pointer; transition: all 0.3s cubic-bezier(0.4,0,0.2,1);
+  box-shadow: 0 4px 16px var(--primary-glow); position: relative; overflow: hidden;
+}
+[data-theme="dark"] .btn-execute { color: #080c14; }
+.btn-execute:hover:not(:disabled) { transform: translateY(-2px); box-shadow: 0 8px 28px var(--primary-glow); }
+.btn-execute:disabled { opacity: 0.35; cursor: not-allowed; transform: none; box-shadow: none; }
+.btn-execute.terminate {
+  background: linear-gradient(135deg, var(--danger), #f97316);
+  box-shadow: 0 4px 16px var(--danger-glow); color: #fff;
+}
+.btn-execute.terminate:hover:not(:disabled) { box-shadow: 0 8px 28px var(--danger-glow); }
+
+.btn-secondary {
+  width: 100%; padding: 7px; border: 1px solid var(--border-glass);
+  border-radius: 6px; background: var(--bg-input); color: var(--text-secondary);
+  font-family: 'Inter', sans-serif; font-size: 0.75rem; font-weight: 500;
+  cursor: pointer; transition: all 0.2s; margin-top: 6px;
+}
+.btn-secondary:hover:not(:disabled) { background: var(--bg-hover); color: var(--text-primary); border-color: var(--primary-border); }
+.btn-secondary:disabled { opacity: 0.3; cursor: not-allowed; }
+
+/* ============================================
+   CENTER MAIN PANEL
+   ============================================ */
+.center-panel {
+  grid-area: center; position: relative;
+  background: var(--bg-surface); display: flex; align-items: center; justify-content: center; overflow: hidden;
+}
+[data-theme="dark"] .center-panel { background: #000; }
+[data-theme="light"] .center-panel { background: #e2e8f0; }
+
+.scan-lines {
+  position: absolute; inset: 0; pointer-events: none; z-index: 1;
+  background: repeating-linear-gradient(to bottom, transparent 0px, transparent 2px, var(--scan-line) 2px, var(--scan-line) 4px);
+}
+
+.panel-topbar {
+  position: absolute; top: 0; left: 0; right: 0; z-index: 20;
+  padding: 10px 16px; display: flex; align-items: center; justify-content: space-between;
+  backdrop-filter: blur(8px); -webkit-backdrop-filter: blur(8px);
+}
+[data-theme="dark"] .panel-topbar { background: linear-gradient(to bottom, rgba(8,12,20,0.9), transparent); }
+[data-theme="light"] .panel-topbar { background: linear-gradient(to bottom, rgba(241,245,249,0.9), transparent); }
+
+.panel-topbar-title {
+  font-family: 'Orbitron', sans-serif; font-size: 0.62rem; font-weight: 600;
+  letter-spacing: 2px; text-transform: uppercase; color: var(--primary);
+  display: flex; align-items: center; gap: 6px;
+}
+.live-badge {
+  background: rgba(220,38,38,0.15); border: 1px solid rgba(220,38,38,0.4); color: var(--danger);
+  font-size: 0.52rem; font-weight: 800; letter-spacing: 1.5px;
+  padding: 2px 6px; border-radius: 4px; animation: blink 1s infinite;
+}
+
+.video-overlay-controls { display: flex; align-items: center; gap: 6px; }
+.overlay-btn {
+  width: 28px; height: 28px; border-radius: 6px; border: 1px solid var(--border-glass);
+  background: var(--bg-panel); color: var(--text-secondary); cursor: pointer;
+  display: flex; align-items: center; justify-content: center; transition: all 0.2s;
+  backdrop-filter: blur(8px);
+}
+.overlay-btn svg { width: 13px; height: 13px; }
+.overlay-btn:hover { border-color: var(--primary-border); color: var(--primary); }
+.overlay-btn.active { background: var(--primary-glow); border-color: var(--primary); color: var(--primary); }
+
+.main-feed { width: 100%; height: 100%; object-fit: contain; display: block; }
+
+.empty-feed { display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100%; width: 100%; gap: 12px; pointer-events: none; }
+.empty-feed-icon { width: 72px; height: 72px; border-radius: 50%; border: 2px dashed var(--primary-border); display: flex; align-items: center; justify-content: center; color: var(--primary); animation: spin-slow 8s linear infinite; }
+.empty-feed-icon svg { opacity: 0.5; width: 32px; height: 32px; }
+@keyframes spin-slow { to { transform: rotate(360deg); } }
+.empty-feed-text { color: var(--text-secondary); font-size: 0.85rem; font-weight: 500; }
+.empty-feed-sub { color: var(--text-muted); font-size: 0.72rem; }
+
+.fencing-svg-overlay { position: absolute; inset: 0; z-index: 15; cursor: crosshair; }
+
+.count-overlay {
+  position: absolute; bottom: 16px; left: 16px; z-index: 25;
+  background: var(--bg-panel); backdrop-filter: blur(12px); -webkit-backdrop-filter: blur(12px);
+  border: 1px solid var(--primary-border); border-radius: 12px; padding: 10px 16px;
+}
+.count-overlay-label { font-size: 0.58rem; text-transform: uppercase; letter-spacing: 1.5px; color: var(--text-muted); font-weight: 600; }
+.count-overlay-value { font-family: 'Orbitron', sans-serif; font-size: 1.8rem; font-weight: 900; color: var(--primary); line-height: 1; text-shadow: 0 0 16px var(--primary-glow); transition: color 0.3s; }
+.count-overlay-value.danger   { color: var(--danger);   text-shadow: 0 0 16px var(--danger-glow); }
+.count-overlay-value.moderate { color: var(--moderate); text-shadow: 0 0 16px var(--moderate-glow); }
+
+.anomaly-banner {
+  position: absolute; top: 52px; left: 50%; transform: translateX(-50%); z-index: 30;
+  background: rgba(220,38,38,0.1); border: 1.5px solid var(--danger); backdrop-filter: blur(12px);
+  border-radius: 10px; padding: 10px 22px; display: flex; align-items: center; gap: 10px;
+  white-space: nowrap; color: var(--danger); font-weight: 700; font-size: 0.82rem;
+  box-shadow: 0 0 30px var(--danger-glow); animation: anomaly-in 0.4s ease;
+}
+.anomaly-banner svg { width: 17px; height: 17px; flex-shrink: 0; animation: blink 0.6s infinite; }
+@keyframes anomaly-in { from{opacity:0;transform:translateX(-50%) translateY(-20px)}to{opacity:1;transform:translateX(-50%) translateY(0)} }
+
+.loader-overlay { position: absolute; inset: 0; z-index: 40; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 20px; background: rgba(8,12,20,0.55); backdrop-filter: blur(6px); }
+[data-theme="light"] .loader-overlay { background: rgba(241,245,249,0.7); }
+
+.spinner { width: 56px; height: 56px; position: relative; }
+.spinner::before, .spinner::after { content: ''; position: absolute; border-radius: 50%; border: 3px solid transparent; }
+.spinner::before { inset: 0; border-top-color: var(--primary); animation: rotation 1.2s linear infinite; }
+.spinner::after  { inset: 8px; border-top-color: var(--blue); animation: rotation 0.8s linear infinite reverse; }
+@keyframes rotation { to { transform: rotate(360deg); } }
+
+.loader-text { font-family: 'Orbitron', sans-serif; font-size: 0.68rem; font-weight: 600; color: var(--primary); letter-spacing: 2px; text-transform: uppercase; animation: blink 1.5s infinite; }
+
+/* ============================================
+   RIGHT PANEL
+   ============================================ */
+.right-panel { grid-area: right; border-left: 1px solid var(--border-glass); display: flex; flex-direction: column; overflow: hidden; }
+.right-panel-section { display: flex; flex-direction: column; overflow: hidden; }
+.right-panel-section + .right-panel-section { border-top: 1px solid var(--border-glass); }
+
+.panel-header { padding: 11px 16px; border-bottom: 1px solid var(--border-glass); display: flex; align-items: center; justify-content: space-between; flex-shrink: 0; }
+.panel-header-title { font-size: 0.62rem; font-weight: 700; text-transform: uppercase; letter-spacing: 2px; color: var(--text-muted); display: flex; align-items: center; gap: 6px; }
+.panel-header-title svg { width: 12px; height: 12px; color: var(--primary); }
+.panel-header-count { font-family: 'Orbitron', sans-serif; font-size: 0.68rem; font-weight: 600; background: var(--primary-glow); border: 1px solid var(--primary-border); color: var(--primary); padding: 2px 8px; border-radius: 100px; }
+
+.alert-feed { flex: 1; overflow-y: auto; padding: 8px; display: flex; flex-direction: column; gap: 5px; }
+.alert-feed::-webkit-scrollbar { width: 3px; }
+.alert-feed::-webkit-scrollbar-thumb { background: var(--border-glass); border-radius: 2px; }
+
+.alert-item { display: flex; gap: 9px; padding: 9px 11px; border-radius: 8px; border: 1px solid; transition: all 0.2s; animation: slide-in 0.35s ease; }
+@keyframes slide-in { from{opacity:0;transform:translateX(16px)}to{opacity:1;transform:translateX(0)} }
+
+.alert-item.info    { background: rgba(37,99,235,0.06);    border-color: rgba(37,99,235,0.18); }
+.alert-item.warning { background: rgba(217,119,6,0.06);    border-color: rgba(217,119,6,0.2);  }
+.alert-item.danger  { background: rgba(220,38,38,0.07);    border-color: rgba(220,38,38,0.22); animation: slide-in 0.35s, alert-danger 2s 0.35s infinite; }
+@keyframes alert-danger { 0%,100%{box-shadow:none}50%{box-shadow:0 0 10px var(--danger-glow)} }
+
+.alert-icon { width: 28px; height: 28px; border-radius: 6px; display: flex; align-items: center; justify-content: center; flex-shrink: 0; }
+.alert-icon svg { width: 13px; height: 13px; }
+.alert-item.info    .alert-icon { background: rgba(37,99,235,0.1);  color: var(--blue); }
+.alert-item.warning .alert-icon { background: rgba(217,119,6,0.1);  color: var(--moderate); }
+.alert-item.danger  .alert-icon { background: rgba(220,38,38,0.12); color: var(--danger); }
+
+.alert-body { flex: 1; min-width: 0; }
+.alert-title { font-weight: 600; font-size: 0.76rem; margin-bottom: 2px; }
+.alert-item.info    .alert-title { color: var(--blue); }
+.alert-item.warning .alert-title { color: var(--moderate); }
+.alert-item.danger  .alert-title { color: var(--danger); }
+.alert-msg  { font-size: 0.68rem; color: var(--text-muted); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.alert-time { font-size: 0.62rem; color: var(--text-muted); margin-top: 3px; font-family: 'Orbitron', sans-serif; }
+
+.alert-empty { flex: 1; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; color: var(--text-muted); }
+.alert-empty svg { opacity: 0.25; width: 28px; height: 28px; }
+.alert-empty p { font-size: 0.75rem; }
+
+.session-list { flex: 1; overflow-y: auto; padding: 8px; display: flex; flex-direction: column; gap: 4px; }
+.session-list::-webkit-scrollbar { width: 3px; }
+
+.session-item { padding: 8px 10px; border-radius: 8px; border: 1px solid var(--border-glass); background: var(--bg-input); cursor: pointer; transition: all 0.2s; }
+.session-item:hover { border-color: var(--primary-border); background: var(--bg-hover); }
+.session-name { font-size: 0.74rem; font-weight: 600; color: var(--text-secondary); }
+.session-meta { font-size: 0.63rem; color: var(--text-muted); margin-top: 3px; display: flex; gap: 8px; align-items: center; }
+.session-meta svg { width: 9px; height: 9px; }
+.session-empty { flex: 1; display: flex; align-items: center; justify-content: center; flex-direction: column; color: var(--text-muted); font-size: 0.74rem; gap: 8px; }
+.session-empty svg { opacity: 0.2; width: 22px; height: 22px; }
+
+/* ============================================
+   BOTTOM ANALYTICS PANEL
+   ============================================ */
+.bottom-panel {
+  grid-area: bottom; border-top: 1px solid var(--border-glass);
+  display: grid; grid-template-columns: 1fr 1fr 1fr 1fr 2fr; overflow: hidden;
+}
+
+.metric-card {
+  padding: 16px 18px; border-right: 1px solid var(--border-glass);
+  display: flex; flex-direction: column; justify-content: space-between;
+  background: var(--metric-bg); position: relative; overflow: hidden;
+  transition: background 0.35s;
+}
+.metric-card::after {
+  content: ''; position: absolute; bottom: 0; left: 0; right: 0; height: 2px;
+  background: linear-gradient(90deg, transparent, var(--primary), transparent);
+  opacity: 0; transition: opacity 0.3s;
+}
+.metric-card:hover::after { opacity: 1; }
+
+.metric-label { font-size: 0.6rem; text-transform: uppercase; letter-spacing: 1.5px; font-weight: 700; color: var(--text-muted); display: flex; align-items: center; gap: 5px; }
+.metric-label svg { width: 11px; height: 11px; color: var(--primary); }
+.metric-value { font-family: 'Orbitron', sans-serif; font-size: 2.2rem; font-weight: 900; color: var(--primary); line-height: 1; text-shadow: 0 0 20px var(--primary-glow); transition: all 0.4s; }
+.metric-value.danger   { color: var(--danger);   text-shadow: 0 0 20px var(--danger-glow);   animation: heartbeat 0.8s infinite; }
+.metric-value.moderate { color: var(--moderate); text-shadow: 0 0 20px var(--moderate-glow); }
+.metric-value.blue     { color: var(--blue);     text-shadow: 0 0 20px var(--blue-glow);     }
+.metric-value.purple   { color: var(--purple);   text-shadow: 0 0 20px var(--purple-glow);   }
+@keyframes heartbeat { 0%,100%{transform:scale(1)}50%{transform:scale(1.06)} }
+
+.metric-sub { font-size: 0.63rem; color: var(--text-muted); margin-top: 4px; }
+
+.chart-area { padding: 12px 16px; display: flex; flex-direction: column; overflow: hidden; }
+.chart-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 8px; flex-shrink: 0; }
+.chart-title { font-size: 0.62rem; text-transform: uppercase; letter-spacing: 2px; font-weight: 700; color: var(--text-muted); }
+.chart-wrapper { flex: 1; min-height: 0; height: 160px; }
+.chart-empty-state {
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  padding: 16px;
+  color: var(--text-muted);
+  font-size: 0.78rem;
+  border: 1px dashed var(--border-glass);
+  border-radius: 10px;
+  background: rgba(148, 163, 184, 0.04);
+}
+
+.export-actions { display: flex; gap: 5px; }
+.btn-export {
+  padding: 4px 10px; border: 1px solid var(--primary-border); border-radius: 6px;
+  background: var(--primary-glow); color: var(--primary);
+  font-size: 0.63rem; font-weight: 600; cursor: pointer; font-family: inherit;
+  display: flex; align-items: center; gap: 4px; transition: all 0.2s;
+}
+.btn-export svg { width: 11px; height: 11px; }
+.btn-export:hover { background: var(--bg-hover); }
+.btn-export:disabled { opacity: 0.3; cursor: not-allowed; }
+
+/* ============================================
+   ANIMATIONS
+   ============================================ */
+@keyframes float { 0%,100%{transform:translateY(0)}50%{transform:translateY(-8px)} }
+@keyframes fade-up { from{opacity:0;transform:translateY(12px)}to{opacity:1;transform:translateY(0)} }
+.fade-up { animation: fade-up 0.4s ease forwards; }
+
+/* ============================================
+   RECHARTS CUSTOM TOOLTIP
+   ============================================ */
+.custom-tooltip {
+  background: var(--bg-panel); border: 1px solid var(--primary-border);
+  border-radius: 8px; padding: 8px 12px; backdrop-filter: blur(12px);
+}
+.custom-tooltip-label { font-size: 0.63rem; color: var(--text-muted); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 4px; }
+.custom-tooltip-value { font-family: 'Orbitron', sans-serif; font-size: 0.9rem; font-weight: 700; color: var(--primary); }
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 4px; height: 4px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: var(--border-glass); border-radius: 2px; }

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/vercel.json

@@ -0,0 +1,6 @@
+{
+  "buildCommand": "npm run build",
+  "outputDirectory": "dist",
+  "framework": "vite",
+  "rewrites": [{ "source": "/(.*)", "destination": "/index.html" }]
+}

frontend/vite.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  base: './',   // relative paths → works on Vercel, Netlify, and sub-path servers
+})

label_tool.py

@@ -0,0 +1,99 @@
+import json
+import os
+
+import streamlit as st
+from PIL import Image, ImageDraw
+
+try:
+    from streamlit_image_coordinates import streamlit_image_coordinates
+except Exception:
+    streamlit_image_coordinates = None
+
+
+st.set_page_config(page_title="Point Annotation Tool", layout="wide")
+st.title("Point Annotation Tool")
+
+image_dir = st.sidebar.text_input("Image folder", value=".")
+output_json = st.sidebar.text_input("Output JSON", value="annotations.json")
+
+if "index" not in st.session_state:
+    st.session_state.index = 0
+if "annotations" not in st.session_state:
+    st.session_state.annotations = {}
+
+
+def list_images(folder):
+    if not os.path.isdir(folder):
+        return []
+    exts = {".jpg", ".jpeg", ".png", ".bmp", ".webp"}
+    return sorted([name for name in os.listdir(folder) if os.path.splitext(name.lower())[1] in exts])
+
+
+def annotated_image(image, points):
+    preview = image.copy()
+    draw = ImageDraw.Draw(preview)
+    for x, y in points:
+        r = 5
+        draw.ellipse((x - r, y - r, x + r, y + r), fill="red", outline="white")
+    return preview
+
+
+images = list_images(image_dir)
+if not images:
+    st.warning("No images found.")
+    st.stop()
+
+st.session_state.index = max(0, min(st.session_state.index, len(images) - 1))
+image_name = images[st.session_state.index]
+image_path = os.path.join(image_dir, image_name)
+image = Image.open(image_path).convert("RGB")
+points = st.session_state.annotations.setdefault(image_name, [])
+
+nav1, nav2, nav3, nav4 = st.columns(4)
+if nav1.button("Prev"):
+    st.session_state.index = max(0, st.session_state.index - 1)
+    st.rerun()
+if nav2.button("Next"):
+    st.session_state.index = min(len(images) - 1, st.session_state.index + 1)
+    st.rerun()
+if nav3.button("Delete Last") and points:
+    points.pop()
+    st.rerun()
+if nav4.button("Clear"):
+    st.session_state.annotations[image_name] = []
+    st.rerun()
+
+st.write(f"{st.session_state.index + 1}/{len(images)} | {image_name} | Count: {len(points)}")
+preview = annotated_image(image, points)
+
+if streamlit_image_coordinates is not None:
+    clicked = streamlit_image_coordinates(preview, key=f"img_{image_name}_{len(points)}")
+    if clicked is not None and "x" in clicked and "y" in clicked:
+        points.append([int(clicked["x"]), int(clicked["y"])])
+        st.rerun()
+else:
+    st.image(preview, caption="Install streamlit-image-coordinates for direct click annotation.", use_container_width=True)
+    c1, c2, c3 = st.columns(3)
+    x = c1.number_input("x", min_value=0, max_value=image.width, value=0, step=1)
+    y = c2.number_input("y", min_value=0, max_value=image.height, value=0, step=1)
+    if c3.button("Add Point"):
+        points.append([int(x), int(y)])
+        st.rerun()
+
+export_data = [
+    {"image": name, "points": pts, "count": len(pts)}
+    for name, pts in sorted(st.session_state.annotations.items())
+]
+json_text = json.dumps(export_data, indent=2)
+
+if st.sidebar.button("Save JSON"):
+    with open(output_json, "w", encoding="utf-8") as f:
+        f.write(json_text)
+    st.sidebar.success(output_json)
+
+st.sidebar.download_button(
+    "Download JSON",
+    data=json_text.encode("utf-8"),
+    file_name=os.path.basename(output_json),
+    mime="application/json",
+)

models/__init__.py

@@ -0,0 +1,6 @@
+from .p2pnet import build
+
+# build the P2PNet model
+# set training to 'True' during training
+def build_model(args, training=False):
+    return build(args, training)

models/backbone.py

@@ -0,0 +1,68 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Backbone modules.
+"""
+from collections import OrderedDict
+
+import torch
+import torch.nn.functional as F
+import torchvision
+from torch import nn
+
+import models.vgg_ as models
+
+class BackboneBase_VGG(nn.Module):
+    def __init__(self, backbone: nn.Module, num_channels: int, name: str, return_interm_layers: bool):
+        super().__init__()
+        features = list(backbone.features.children())
+        if return_interm_layers:
+            if name == 'vgg16_bn':
+                self.body1 = nn.Sequential(*features[:13])
+                self.body2 = nn.Sequential(*features[13:23])
+                self.body3 = nn.Sequential(*features[23:33])
+                self.body4 = nn.Sequential(*features[33:43])
+            else:
+                self.body1 = nn.Sequential(*features[:9])
+                self.body2 = nn.Sequential(*features[9:16])
+                self.body3 = nn.Sequential(*features[16:23])
+                self.body4 = nn.Sequential(*features[23:30])
+        else:
+            if name == 'vgg16_bn':
+                self.body = nn.Sequential(*features[:44])  # 16x down-sample
+            elif name == 'vgg16':
+                self.body = nn.Sequential(*features[:30])  # 16x down-sample
+        self.num_channels = num_channels
+        self.return_interm_layers = return_interm_layers
+
+    def forward(self, tensor_list):
+        out = []
+
+        if self.return_interm_layers:
+            xs = tensor_list
+            for _, layer in enumerate([self.body1, self.body2, self.body3, self.body4]):
+                xs = layer(xs)
+                out.append(xs)
+
+        else:
+            xs = self.body(tensor_list)
+            out.append(xs)
+        return out
+
+
+class Backbone_VGG(BackboneBase_VGG):
+    """ResNet backbone with frozen BatchNorm."""
+    def __init__(self, name: str, return_interm_layers: bool):
+        if name == 'vgg16_bn':
+            backbone = models.vgg16_bn(pretrained=True)
+        elif name == 'vgg16':
+            backbone = models.vgg16(pretrained=True)
+        num_channels = 256
+        super().__init__(backbone, num_channels, name, return_interm_layers)
+
+
+def build_backbone(args):
+    backbone = Backbone_VGG(args.backbone, True)
+    return backbone
+
+if __name__ == '__main__':
+    Backbone_VGG('vgg16', True)

models/matcher.py

@@ -0,0 +1,83 @@
+
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Mostly copy-paste from DETR (https://github.com/facebookresearch/detr).
+"""
+import torch
+from scipy.optimize import linear_sum_assignment
+from torch import nn
+
+
+class HungarianMatcher_Crowd(nn.Module):
+    """This class computes an assignment between the targets and the predictions of the network
+
+    For efficiency reasons, the targets don't include the no_object. Because of this, in general,
+    there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
+    while the others are un-matched (and thus treated as non-objects).
+    """
+
+    def __init__(self, cost_class: float = 1, cost_point: float = 1):
+        """Creates the matcher
+
+        Params:
+            cost_class: This is the relative weight of the foreground object
+            cost_point: This is the relative weight of the L1 error of the points coordinates in the matching cost
+        """
+        super().__init__()
+        self.cost_class = cost_class
+        self.cost_point = cost_point
+        assert cost_class != 0 or cost_point != 0, "all costs cant be 0"
+
+    @torch.no_grad()
+    def forward(self, outputs, targets):
+        """ Performs the matching
+
+        Params:
+            outputs: This is a dict that contains at least these entries:
+                 "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
+                 "points": Tensor of dim [batch_size, num_queries, 2] with the predicted point coordinates
+
+            targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
+                 "labels": Tensor of dim [num_target_points] (where num_target_points is the number of ground-truth
+                           objects in the target) containing the class labels
+                 "points": Tensor of dim [num_target_points, 2] containing the target point coordinates
+
+        Returns:
+            A list of size batch_size, containing tuples of (index_i, index_j) where:
+                - index_i is the indices of the selected predictions (in order)
+                - index_j is the indices of the corresponding selected targets (in order)
+            For each batch element, it holds:
+                len(index_i) = len(index_j) = min(num_queries, num_target_points)
+        """
+        bs, num_queries = outputs["pred_logits"].shape[:2]
+
+        # We flatten to compute the cost matrices in a batch
+        out_prob = outputs["pred_logits"].flatten(0, 1).softmax(-1)  # [batch_size * num_queries, num_classes]
+        out_points = outputs["pred_points"].flatten(0, 1)  # [batch_size * num_queries, 2]
+
+        # Also concat the target labels and points
+        # tgt_ids = torch.cat([v["labels"] for v in targets])
+        tgt_ids = torch.cat([v["labels"] for v in targets])
+        tgt_points = torch.cat([v["point"] for v in targets])
+
+        # Compute the classification cost. Contrary to the loss, we don't use the NLL,
+        # but approximate it in 1 - proba[target class].
+        # The 1 is a constant that doesn't change the matching, it can be ommitted.
+        cost_class = -out_prob[:, tgt_ids]
+
+        # Compute the L2 cost between point
+        cost_point = torch.cdist(out_points, tgt_points, p=2)
+
+        # Compute the giou cost between point
+
+        # Final cost matrix
+        C = self.cost_point * cost_point + self.cost_class * cost_class
+        C = C.view(bs, num_queries, -1).cpu()
+
+        sizes = [len(v["point"]) for v in targets]
+        indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C.split(sizes, -1))]
+        return [(torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) for i, j in indices]
+
+
+def build_matcher_crowd(args):
+    return HungarianMatcher_Crowd(cost_class=args.set_cost_class, cost_point=args.set_cost_point)

models/p2pnet.py

@@ -0,0 +1,342 @@
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from util.misc import (NestedTensor, nested_tensor_from_tensor_list,
+                       accuracy, get_world_size, interpolate,
+                       is_dist_avail_and_initialized)
+
+from .backbone import build_backbone
+from .matcher import build_matcher_crowd
+
+import numpy as np
+import time
+
+# the network frmawork of the regression branch
+class RegressionModel(nn.Module):
+    def __init__(self, num_features_in, num_anchor_points=4, feature_size=256):
+        super(RegressionModel, self).__init__()
+
+        self.conv1 = nn.Conv2d(num_features_in, feature_size, kernel_size=3, padding=1)
+        self.act1 = nn.ReLU()
+
+        self.conv2 = nn.Conv2d(feature_size, feature_size, kernel_size=3, padding=1)
+        self.act2 = nn.ReLU()
+
+        self.conv3 = nn.Conv2d(feature_size, feature_size, kernel_size=3, padding=1)
+        self.act3 = nn.ReLU()
+
+        self.conv4 = nn.Conv2d(feature_size, feature_size, kernel_size=3, padding=1)
+        self.act4 = nn.ReLU()
+
+        self.output = nn.Conv2d(feature_size, num_anchor_points * 2, kernel_size=3, padding=1)
+    # sub-branch forward
+    def forward(self, x):
+        out = self.conv1(x)
+        out = self.act1(out)
+
+        out = self.conv2(out)
+        out = self.act2(out)
+
+        out = self.output(out)
+
+        out = out.permute(0, 2, 3, 1)
+
+        return out.contiguous().view(out.shape[0], -1, 2)
+
+# the network frmawork of the classification branch
+class ClassificationModel(nn.Module):
+    def __init__(self, num_features_in, num_anchor_points=4, num_classes=80, prior=0.01, feature_size=256):
+        super(ClassificationModel, self).__init__()
+
+        self.num_classes = num_classes
+        self.num_anchor_points = num_anchor_points
+
+        self.conv1 = nn.Conv2d(num_features_in, feature_size, kernel_size=3, padding=1)
+        self.act1 = nn.ReLU()
+
+        self.conv2 = nn.Conv2d(feature_size, feature_size, kernel_size=3, padding=1)
+        self.act2 = nn.ReLU()
+
+        self.conv3 = nn.Conv2d(feature_size, feature_size, kernel_size=3, padding=1)
+        self.act3 = nn.ReLU()
+
+        self.conv4 = nn.Conv2d(feature_size, feature_size, kernel_size=3, padding=1)
+        self.act4 = nn.ReLU()
+
+        self.output = nn.Conv2d(feature_size, num_anchor_points * num_classes, kernel_size=3, padding=1)
+        self.output_act = nn.Sigmoid()
+    # sub-branch forward
+    def forward(self, x):
+        out = self.conv1(x)
+        out = self.act1(out)
+
+        out = self.conv2(out)
+        out = self.act2(out)
+
+        out = self.output(out)
+
+        out1 = out.permute(0, 2, 3, 1)
+
+        batch_size, width, height, _ = out1.shape
+
+        out2 = out1.view(batch_size, width, height, self.num_anchor_points, self.num_classes)
+
+        return out2.contiguous().view(x.shape[0], -1, self.num_classes)
+
+# generate the reference points in grid layout
+def generate_anchor_points(stride=16, row=3, line=3):
+    row_step = stride / row
+    line_step = stride / line
+
+    shift_x = (np.arange(1, line + 1) - 0.5) * line_step - stride / 2
+    shift_y = (np.arange(1, row + 1) - 0.5) * row_step - stride / 2
+
+    shift_x, shift_y = np.meshgrid(shift_x, shift_y)
+
+    anchor_points = np.vstack((
+        shift_x.ravel(), shift_y.ravel()
+    )).transpose()
+
+    return anchor_points
+# shift the meta-anchor to get an acnhor points
+def shift(shape, stride, anchor_points):
+    shift_x = (np.arange(0, shape[1]) + 0.5) * stride
+    shift_y = (np.arange(0, shape[0]) + 0.5) * stride
+
+    shift_x, shift_y = np.meshgrid(shift_x, shift_y)
+
+    shifts = np.vstack((
+        shift_x.ravel(), shift_y.ravel()
+    )).transpose()
+
+    A = anchor_points.shape[0]
+    K = shifts.shape[0]
+    all_anchor_points = (anchor_points.reshape((1, A, 2)) + shifts.reshape((1, K, 2)).transpose((1, 0, 2)))
+    all_anchor_points = all_anchor_points.reshape((K * A, 2))
+
+    return all_anchor_points
+
+# this class generate all reference points on all pyramid levels
+class AnchorPoints(nn.Module):
+    def __init__(self, pyramid_levels=None, strides=None, row=3, line=3):
+        super(AnchorPoints, self).__init__()
+
+        if pyramid_levels is None:
+            self.pyramid_levels = [3, 4, 5, 6, 7]
+        else:
+            self.pyramid_levels = pyramid_levels
+
+        if strides is None:
+            self.strides = [2 ** x for x in self.pyramid_levels]
+
+        self.row = row
+        self.line = line
+
+    def forward(self, image):
+        image_shape = image.shape[2:]
+        image_shape = np.array(image_shape)
+        image_shapes = [(image_shape + 2 ** x - 1) // (2 ** x) for x in self.pyramid_levels]
+
+        all_anchor_points = np.zeros((0, 2)).astype(np.float32)
+        # get reference points for each level
+        for idx, p in enumerate(self.pyramid_levels):
+            anchor_points = generate_anchor_points(2**p, row=self.row, line=self.line)
+            shifted_anchor_points = shift(image_shapes[idx], self.strides[idx], anchor_points)
+            all_anchor_points = np.append(all_anchor_points, shifted_anchor_points, axis=0)
+
+        all_anchor_points = np.expand_dims(all_anchor_points, axis=0)
+        # send reference points to device
+        if torch.cuda.is_available():
+            return torch.from_numpy(all_anchor_points.astype(np.float32)).cuda()
+        else:
+            return torch.from_numpy(all_anchor_points.astype(np.float32))
+
+class Decoder(nn.Module):
+    def __init__(self, C3_size, C4_size, C5_size, feature_size=256):
+        super(Decoder, self).__init__()
+
+        # upsample C5 to get P5 from the FPN paper
+        self.P5_1 = nn.Conv2d(C5_size, feature_size, kernel_size=1, stride=1, padding=0)
+        self.P5_upsampled = nn.Upsample(scale_factor=2, mode='nearest')
+        self.P5_2 = nn.Conv2d(feature_size, feature_size, kernel_size=3, stride=1, padding=1)
+
+        # add P5 elementwise to C4
+        self.P4_1 = nn.Conv2d(C4_size, feature_size, kernel_size=1, stride=1, padding=0)
+        self.P4_upsampled = nn.Upsample(scale_factor=2, mode='nearest')
+        self.P4_2 = nn.Conv2d(feature_size, feature_size, kernel_size=3, stride=1, padding=1)
+
+        # add P4 elementwise to C3
+        self.P3_1 = nn.Conv2d(C3_size, feature_size, kernel_size=1, stride=1, padding=0)
+        self.P3_upsampled = nn.Upsample(scale_factor=2, mode='nearest')
+        self.P3_2 = nn.Conv2d(feature_size, feature_size, kernel_size=3, stride=1, padding=1)
+
+
+    def forward(self, inputs):
+        C3, C4, C5 = inputs
+
+        P5_x = self.P5_1(C5)
+        P5_upsampled_x = self.P5_upsampled(P5_x)
+        P5_x = self.P5_2(P5_x)
+
+        P4_x = self.P4_1(C4)
+        P4_x = P5_upsampled_x + P4_x
+        P4_upsampled_x = self.P4_upsampled(P4_x)
+        P4_x = self.P4_2(P4_x)
+
+        P3_x = self.P3_1(C3)
+        P3_x = P3_x + P4_upsampled_x
+        P3_x = self.P3_2(P3_x)
+
+        return [P3_x, P4_x, P5_x]
+
+# the defenition of the P2PNet model
+class P2PNet(nn.Module):
+    def __init__(self, backbone, row=2, line=2):
+        super().__init__()
+        self.backbone = backbone
+        self.num_classes = 2
+        # the number of all anchor points
+        num_anchor_points = row * line
+
+        self.regression = RegressionModel(num_features_in=256, num_anchor_points=num_anchor_points)
+        self.classification = ClassificationModel(num_features_in=256, \
+                                            num_classes=self.num_classes, \
+                                            num_anchor_points=num_anchor_points)
+
+        self.anchor_points = AnchorPoints(pyramid_levels=[3,], row=row, line=line)
+
+        self.fpn = Decoder(256, 512, 512)
+
+    def forward(self, samples: NestedTensor):
+        # get the backbone features
+        features = self.backbone(samples)
+        # forward the feature pyramid
+        features_fpn = self.fpn([features[1], features[2], features[3]])
+
+        batch_size = features[0].shape[0]
+        # run the regression and classification branch
+        regression = self.regression(features_fpn[1]) * 100 # 8x
+        classification = self.classification(features_fpn[1])
+        anchor_points = self.anchor_points(samples).repeat(batch_size, 1, 1)
+        # decode the points as prediction
+        output_coord = regression + anchor_points
+        output_class = classification
+        out = {'pred_logits': output_class, 'pred_points': output_coord}
+       
+        return out
+
+class SetCriterion_Crowd(nn.Module):
+
+    def __init__(self, num_classes, matcher, weight_dict, eos_coef, losses):
+        """ Create the criterion.
+        Parameters:
+            num_classes: number of object categories, omitting the special no-object category
+            matcher: module able to compute a matching between targets and proposals
+            weight_dict: dict containing as key the names of the losses and as values their relative weight.
+            eos_coef: relative classification weight applied to the no-object category
+            losses: list of all the losses to be applied. See get_loss for list of available losses.
+        """
+        super().__init__()
+        self.num_classes = num_classes
+        self.matcher = matcher
+        self.weight_dict = weight_dict
+        self.eos_coef = eos_coef
+        self.losses = losses
+        empty_weight = torch.ones(self.num_classes + 1)
+        empty_weight[0] = self.eos_coef
+        self.register_buffer('empty_weight', empty_weight)
+
+    def loss_labels(self, outputs, targets, indices, num_points):
+        """Classification loss (NLL)
+        targets dicts must contain the key "labels" containing a tensor of dim [nb_target_boxes]
+        """
+        assert 'pred_logits' in outputs
+        src_logits = outputs['pred_logits']
+
+        idx = self._get_src_permutation_idx(indices)
+        target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)])
+        target_classes = torch.full(src_logits.shape[:2], 0,
+                                    dtype=torch.int64, device=src_logits.device)
+        target_classes[idx] = target_classes_o
+
+        loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight)
+        losses = {'loss_ce': loss_ce}
+
+        return losses
+
+    def loss_points(self, outputs, targets, indices, num_points):
+
+        assert 'pred_points' in outputs
+        idx = self._get_src_permutation_idx(indices)
+        src_points = outputs['pred_points'][idx]
+        target_points = torch.cat([t['point'][i] for t, (_, i) in zip(targets, indices)], dim=0)
+
+        loss_bbox = F.mse_loss(src_points, target_points, reduction='none')
+
+        losses = {}
+        losses['loss_point'] = loss_bbox.sum() / num_points
+
+        return losses
+
+    def _get_src_permutation_idx(self, indices):
+        # permute predictions following indices
+        batch_idx = torch.cat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)])
+        src_idx = torch.cat([src for (src, _) in indices])
+        return batch_idx, src_idx
+
+    def _get_tgt_permutation_idx(self, indices):
+        # permute targets following indices
+        batch_idx = torch.cat([torch.full_like(tgt, i) for i, (_, tgt) in enumerate(indices)])
+        tgt_idx = torch.cat([tgt for (_, tgt) in indices])
+        return batch_idx, tgt_idx
+
+    def get_loss(self, loss, outputs, targets, indices, num_points, **kwargs):
+        loss_map = {
+            'labels': self.loss_labels,
+            'points': self.loss_points,
+        }
+        assert loss in loss_map, f'do you really want to compute {loss} loss?'
+        return loss_map[loss](outputs, targets, indices, num_points, **kwargs)
+
+    def forward(self, outputs, targets):
+        """ This performs the loss computation.
+        Parameters:
+             outputs: dict of tensors, see the output specification of the model for the format
+             targets: list of dicts, such that len(targets) == batch_size.
+                      The expected keys in each dict depends on the losses applied, see each loss' doc
+        """
+        output1 = {'pred_logits': outputs['pred_logits'], 'pred_points': outputs['pred_points']}
+
+        indices1 = self.matcher(output1, targets)
+
+        num_points = sum(len(t["labels"]) for t in targets)
+        num_points = torch.as_tensor([num_points], dtype=torch.float, device=next(iter(output1.values())).device)
+        if is_dist_avail_and_initialized():
+            torch.distributed.all_reduce(num_points)
+        num_boxes = torch.clamp(num_points / get_world_size(), min=1).item()
+
+        losses = {}
+        for loss in self.losses:
+            losses.update(self.get_loss(loss, output1, targets, indices1, num_boxes))
+
+        return losses
+
+# create the P2PNet model
+def build(args, training):
+    # treats persons as a single class
+    num_classes = 1
+
+    backbone = build_backbone(args)
+    model = P2PNet(backbone, args.row, args.line)
+    if not training: 
+        return model
+
+    weight_dict = {'loss_ce': 1, 'loss_points': args.point_loss_coef}
+    losses = ['labels', 'points']
+    matcher = build_matcher_crowd(args)
+    criterion = SetCriterion_Crowd(num_classes, \
+                                matcher=matcher, weight_dict=weight_dict, \
+                                eos_coef=args.eos_coef, losses=losses)
+
+    return model, criterion

models/vgg_.py

@@ -0,0 +1,197 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Mostly copy-paste from torchvision references.
+"""
+import torch
+import torch.nn as nn
+
+
+__all__ = [
+    'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
+    'vgg19_bn', 'vgg19',
+]
+
+
+model_urls = {
+    'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
+    'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
+    'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
+    'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
+    'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
+    'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
+    'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
+    'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
+}
+
+
+model_paths = {
+    'vgg16_bn': '/apdcephfs/private_changanwang/checkpoints/vgg16_bn-6c64b313.pth',
+    'vgg16': '/apdcephfs/private_changanwang/checkpoints/vgg16-397923af.pth',
+
+}
+
+
+class VGG(nn.Module):
+
+    def __init__(self, features, num_classes=1000, init_weights=True):
+        super(VGG, self).__init__()
+        self.features = features
+        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
+        self.classifier = nn.Sequential(
+            nn.Linear(512 * 7 * 7, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, num_classes),
+        )
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+
+
+def make_layers(cfg, batch_norm=False, sync=False):
+    layers = []
+    in_channels = 3
+    for v in cfg:
+        if v == 'M':
+            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
+            if batch_norm:
+                if sync:
+                    print('use sync backbone')
+                    layers += [conv2d, nn.SyncBatchNorm(v), nn.ReLU(inplace=True)]
+                else:
+                    layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
+            else:
+                layers += [conv2d, nn.ReLU(inplace=True)]
+            in_channels = v
+    return nn.Sequential(*layers)
+
+
+cfgs = {
+    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
+    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
+}
+
+
+def _vgg(arch, cfg, batch_norm, pretrained, progress, sync=False, **kwargs):
+    if pretrained:
+        kwargs['init_weights'] = False
+    model = VGG(make_layers(cfgs[cfg], batch_norm=batch_norm, sync=sync), **kwargs)
+    if pretrained:
+        from torch.hub import load_state_dict_from_url
+        state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def vgg11(pretrained=False, progress=True, **kwargs):
+    r"""VGG 11-layer model (configuration "A") from
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg11', 'A', False, pretrained, progress, **kwargs)
+
+
+def vgg11_bn(pretrained=False, progress=True, **kwargs):
+    r"""VGG 11-layer model (configuration "A") with batch normalization
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg11_bn', 'A', True, pretrained, progress, **kwargs)
+
+
+def vgg13(pretrained=False, progress=True, **kwargs):
+    r"""VGG 13-layer model (configuration "B")
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg13', 'B', False, pretrained, progress, **kwargs)
+
+
+def vgg13_bn(pretrained=False, progress=True, **kwargs):
+    r"""VGG 13-layer model (configuration "B") with batch normalization
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg13_bn', 'B', True, pretrained, progress, **kwargs)
+
+
+def vgg16(pretrained=False, progress=True, **kwargs):
+    r"""VGG 16-layer model (configuration "D")
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg16', 'D', False, pretrained, progress, **kwargs)
+
+
+def vgg16_bn(pretrained=False, progress=True, sync=False, **kwargs):
+    r"""VGG 16-layer model (configuration "D") with batch normalization
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg16_bn', 'D', True, pretrained, progress, sync=sync, **kwargs)
+
+
+def vgg19(pretrained=False, progress=True, **kwargs):
+    r"""VGG 19-layer model (configuration "E")
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg19', 'E', False, pretrained, progress, **kwargs)
+
+
+def vgg19_bn(pretrained=False, progress=True, **kwargs):
+    r"""VGG 19-layer model (configuration 'E') with batch normalization
+    `"Very Deep Convolutional Networks For Large-Scale Image Recognition" <https://arxiv.org/pdf/1409.1556.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vgg('vgg19_bn', 'E', True, pretrained, progress, **kwargs)

motion_estimator.py

@@ -0,0 +1,35 @@
+import cv2
+import numpy as np
+
+class GlobalMotionEstimator:
+    def __init__(self):
+        self.prev_gray = None
+        self.prev_pts = None
+        
+    def update(self, current_frame):
+        # Expects a BGR or RGB frame (function works identically long as it's 3-channel)
+        curr_gray = cv2.cvtColor(current_frame, cv2.COLOR_BGR2GRAY)
+        
+        transform = np.eye(2, 3, dtype=np.float32)
+        
+        if self.prev_gray is None:
+            self.prev_gray = curr_gray
+            self.prev_pts = cv2.goodFeaturesToTrack(curr_gray, maxCorners=200, qualityLevel=0.01, minDistance=30, blockSize=3)
+            return transform
+            
+        if self.prev_pts is not None and len(self.prev_pts) > 0:
+            curr_pts, status, err = cv2.calcOpticalFlowPyrLK(self.prev_gray, curr_gray, self.prev_pts, None, winSize=(21, 21), maxLevel=3)
+            
+            good_prev = self.prev_pts[status == 1]
+            good_curr = curr_pts[status == 1]
+            
+            if len(good_prev) >= 4 and len(good_curr) >= 4:
+                # Estimate affine transform (translation + rotation + scale) 
+                transform, inliers = cv2.estimateAffinePartial2D(good_prev, good_curr)
+                if transform is None: # Safety fallback
+                    transform = np.eye(2, 3, dtype=np.float32)
+        
+        self.prev_gray = curr_gray
+        self.prev_pts = cv2.goodFeaturesToTrack(curr_gray, maxCorners=200, qualityLevel=0.01, minDistance=30, blockSize=3)
+        
+        return transform

optimization_notes.md

@@ -0,0 +1,81 @@
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+def extract_patch(job):
+    x, y, img_padded, patch_size, transform = job
+    patch = img_padded.crop((x, y, x + patch_size, y + patch_size))
+    return x, y, transform(patch)
+
+jobs = [(x, y, img_padded, patch_size, transform) for x, y in coords]
+with ThreadPoolExecutor(max_workers=8) as executor:
+    patch_tensors = list(executor.map(extract_patch, jobs))
+```
+
+```python
+def grid_merge_points(points, radius=8.0):
+    if not points:
+        return []
+    cell_size = radius
+    cells = {}
+    merged = []
+    for point in points:
+        x, y = point
+        key = (int(x // cell_size), int(y // cell_size))
+        duplicate = False
+        for nx in range(key[0] - 1, key[0] + 2):
+            for ny in range(key[1] - 1, key[1] + 2):
+                for existing in cells.get((nx, ny), []):
+                    if ((x - existing[0]) ** 2 + (y - existing[1]) ** 2) ** 0.5 <= radius:
+                        duplicate = True
+                        break
+                if duplicate:
+                    break
+            if duplicate:
+                break
+        if not duplicate:
+            merged.append(point)
+            cells.setdefault(key, []).append(point)
+    return merged
+```
+
+```python
+import cv2
+import numpy as np
+
+class ORBHomographyMotionEstimator:
+    def __init__(self, max_features=500):
+        self.prev_gray = None
+        self.orb = cv2.ORB_create(max_features)
+        self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
+
+    def update(self, frame_bgr):
+        gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
+        if self.prev_gray is None:
+            self.prev_gray = gray
+            return np.eye(3, dtype=np.float32)
+        kp1, des1 = self.orb.detectAndCompute(self.prev_gray, None)
+        kp2, des2 = self.orb.detectAndCompute(gray, None)
+        H = np.eye(3, dtype=np.float32)
+        if des1 is not None and des2 is not None and len(kp1) >= 8 and len(kp2) >= 8:
+            matches = sorted(self.matcher.match(des1, des2), key=lambda m: m.distance)[:100]
+            if len(matches) >= 8:
+                src = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
+                dst = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
+                H_found, _ = cv2.findHomography(src, dst, cv2.RANSAC, 5.0)
+                if H_found is not None:
+                    H = H_found.astype(np.float32)
+        self.prev_gray = gray
+        return H
+```
+
+```python
+from PIL import Image
+
+def batch_infer_frames(frames_rgb, process_frame_fn, model, device, transform, **kwargs):
+    results = []
+    for frame_rgb in frames_rgb:
+        image = Image.fromarray(frame_rgb)
+        _, count, points = process_frame_fn(image, model, device, transform, **kwargs)
+        results.append({"count": count, "points": points})
+    return results
+```

report_generator.py

@@ -0,0 +1,28 @@
+import pandas as pd
+import json
+
+class ReportGenerator:
+    def __init__(self):
+        self.data = []
+        
+    def add_frame_data(self, frame_num, timestamp_sec, frame_count, cumulative_count):
+        self.data.append({
+            "frame_number": frame_num,
+            "timestamp_sec": round(timestamp_sec, 2),
+            "frame_count": frame_count,
+            "total_unique_count": cumulative_count
+        })
+        
+    def get_csv(self):
+        if not self.data: return ""
+        df = pd.DataFrame(self.data)
+        return df.to_csv(index=False).encode('utf-8')
+        
+    def get_json(self):
+        return json.dumps({
+            "metadata": {
+                "generated_by": "Civic Pulse Engine",
+                "total_frames_analyzed": len(self.data)
+            },
+            "timeline": self.data
+        }, indent=2).encode('utf-8')

requirements.txt

@@ -0,0 +1,28 @@
+# ── Core API framework ──────────────────────────────────────────
+fastapi
+uvicorn[standard]
+python-multipart
+
+# ── PyTorch CPU-only build (~200 MB vs ~800 MB for CUDA) ────────
+# This is essential for fitting in free-tier Docker containers
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch
+torchvision
+
+# ── Image / Video processing ────────────────────────────────────
+Pillow
+opencv-python-headless
+
+# ── Scientific computing ─────────────────────────────────────────
+numpy
+scipy
+scikit-learn
+
+# ── Database ORM ─────────────────────────────────────────────────
+sqlmodel
+
+# ── Misc utilities ───────────────────────────────────────────────
+easydict
+
+# ── HuggingFace Hub (for auto-downloading model weights) ─────────
+huggingface_hub

run_test.py

@@ -0,0 +1,103 @@
+import argparse
+import datetime
+import random
+import time
+from pathlib import Path
+
+import torch
+import torchvision.transforms as standard_transforms
+import numpy as np
+
+from PIL import Image
+import cv2
+from crowd_datasets import build_dataset
+from engine import *
+from models import build_model
+import os
+import warnings
+warnings.filterwarnings('ignore')
+
+def get_args_parser():
+    parser = argparse.ArgumentParser('Set parameters for P2PNet evaluation', add_help=False)
+    
+    # * Backbone
+    parser.add_argument('--backbone', default='vgg16_bn', type=str,
+                        help="name of the convolutional backbone to use")
+
+    parser.add_argument('--row', default=2, type=int,
+                        help="row number of anchor points")
+    parser.add_argument('--line', default=2, type=int,
+                        help="line number of anchor points")
+
+    parser.add_argument('--output_dir', default='',
+                        help='path where to save')
+    parser.add_argument('--weight_path', default='',
+                        help='path where the trained weights saved')
+
+    parser.add_argument('--gpu_id', default=0, type=int, help='the gpu used for evaluation')
+
+    return parser
+
+def main(args, debug=False):
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = '{}'.format(args.gpu_id)
+
+    print(args)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    # get the P2PNet
+    model = build_model(args)
+    # move to the selected device
+    model.to(device)
+    # load trained model
+    if args.weight_path is not None:
+        checkpoint = torch.load(args.weight_path, map_location='cpu')
+        model.load_state_dict(checkpoint['model'])
+    # convert to eval mode
+    model.eval()
+    # create the pre-processing transform
+    transform = standard_transforms.Compose([
+        standard_transforms.ToTensor(), 
+        standard_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+    # set your image path here
+    img_path = "./vis/demo1.jpg"
+    # load the images
+    img_raw = Image.open(img_path).convert('RGB')
+    # round the size
+    width, height = img_raw.size
+    new_width = width // 128 * 128
+    new_height = height // 128 * 128
+    resample_filter = getattr(Image, "Resampling", Image).LANCZOS if hasattr(Image, "Resampling") else getattr(Image, "ANTIALIAS", 1)
+    img_raw = img_raw.resize((new_width, new_height), resample_filter)
+    # pre-proccessing
+    img = transform(img_raw)
+
+    samples = torch.Tensor(img).unsqueeze(0)
+    samples = samples.to(device)
+    # run inference
+    outputs = model(samples)
+    outputs_scores = torch.nn.functional.softmax(outputs['pred_logits'], -1)[:, :, 1][0]
+
+    outputs_points = outputs['pred_points'][0]
+
+    threshold = 0.5
+    # filter the predictions
+    points = outputs_points[outputs_scores > threshold].detach().cpu().numpy().tolist()
+    predict_cnt = int((outputs_scores > threshold).sum())
+
+    outputs_scores = torch.nn.functional.softmax(outputs['pred_logits'], -1)[:, :, 1][0]
+
+    outputs_points = outputs['pred_points'][0]
+    # draw the predictions
+    size = 2
+    img_to_draw = cv2.cvtColor(np.array(img_raw), cv2.COLOR_RGB2BGR)
+    for p in points:
+        img_to_draw = cv2.circle(img_to_draw, (int(p[0]), int(p[1])), size, (0, 0, 255), -1)
+    # save the visualized image
+    cv2.imwrite(os.path.join(args.output_dir, 'pred{}.jpg'.format(predict_cnt)), img_to_draw)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser('P2PNet evaluation script', parents=[get_args_parser()])
+    args = parser.parse_args()
+    main(args)

test_system.py

@@ -0,0 +1,114 @@
+import json
+
+import cv2
+import numpy as np
+import torch
+
+from motion_estimator import GlobalMotionEstimator
+from report_generator import ReportGenerator
+from tracker import Tracker
+
+
+GREEN = "\033[92m"
+RED = "\033[91m"
+RESET = "\033[0m"
+
+
+def run_test(name, fn):
+    try:
+        fn()
+        print(f"{GREEN}PASS{RESET} {name}")
+        return True
+    except Exception as exc:
+        print(f"{RED}FAIL{RESET} {name}: {exc}")
+        return False
+
+
+def test_model_loading():
+    from models import build_model
+
+    class Args:
+        backbone = "vgg16_bn"
+        row = 2
+        line = 2
+
+    model = build_model(Args())
+    assert model is not None
+
+
+def test_dummy_inference():
+    from models import build_model
+
+    class Args:
+        backbone = "vgg16_bn"
+        row = 2
+        line = 2
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = build_model(Args()).to(device).eval()
+    x = torch.zeros((1, 3, 512, 512), dtype=torch.float32, device=device)
+    with torch.inference_mode():
+        out = model(x)
+    assert "pred_logits" in out and "pred_points" in out
+    assert out["pred_logits"].shape[0] == 1
+
+
+def test_tracker_persistence():
+    tracker = Tracker(max_distance=20, max_age=3)
+    frame = np.zeros((128, 128, 3), dtype=np.uint8)
+    first_id = None
+    for i in range(30):
+        tracks, total, anomaly = tracker.update(frame, [[50 + i * 0.2, 50 + i * 0.1]])
+        assert tracks
+        if first_id is None:
+            first_id = tracks[0].id
+        assert tracks[0].id == first_id
+        assert anomaly is False
+    assert total == 1
+
+
+def test_motion_compensation():
+    estimator = GlobalMotionEstimator()
+    img1 = np.zeros((200, 200, 3), dtype=np.uint8)
+    cv2.circle(img1, (80, 80), 10, (255, 255, 255), -1)
+    cv2.rectangle(img1, (120, 120), (150, 150), (255, 255, 255), -1)
+    img2 = np.roll(img1, shift=5, axis=1)
+    t1 = estimator.update(img1)
+    t2 = estimator.update(img2)
+    assert t1.shape == (2, 3)
+    assert t2.shape == (2, 3)
+
+
+def test_alert_thresholds():
+    for current, threshold in [(50, 100), (75, 100), (90, 100), (100, 100)]:
+        ratio = current / threshold
+        assert ratio >= 0
+
+
+def test_report_exports():
+    report = ReportGenerator()
+    report.add_frame_data(1, 0.03, 10, 11)
+    csv_data = report.get_csv()
+    json_data = report.get_json()
+    assert b"frame_number" in csv_data
+    parsed = json.loads(json_data.decode("utf-8"))
+    assert parsed["timeline"][0]["frame_count"] == 10
+
+
+def main():
+    tests = [
+        ("model loading", test_model_loading),
+        ("dummy image inference", test_dummy_inference),
+        ("tracker ID persistence across 30 frames", test_tracker_persistence),
+        ("motion compensation transform", test_motion_compensation),
+        ("alert thresholds at 50/75/90/100%", test_alert_thresholds),
+        ("CSV/JSON export", test_report_exports),
+    ]
+    results = [run_test(name, fn) for name, fn in tests]
+    passed = sum(results)
+    print(f"{passed}/{len(results)} tests passed")
+    raise SystemExit(0 if passed == len(results) else 1)
+
+
+if __name__ == "__main__":
+    main()

tracker.py

@@ -0,0 +1,96 @@
+import numpy as np
+import cv2
+from scipy.optimize import linear_sum_assignment
+from motion_estimator import GlobalMotionEstimator
+
+class PointTrack:
+    def __init__(self, pt, track_id):
+        self.id = track_id
+        self.pt = np.array(pt, dtype=np.float32)
+        self.velocity = 0.0
+        self.time_since_update = 0
+
+
+class Tracker:
+    def __init__(self, max_distance=50.0, max_age=5):
+        self.max_distance = max_distance
+        self.max_age = max_age
+        self.tracks = []
+        self.next_id = 1
+        self.motion_estimator = GlobalMotionEstimator()
+        
+    def apply_motion_compensation(self, transform):
+        if transform is None or len(self.tracks) == 0:
+            return
+        # transform: 2x3 matrix
+        pts = np.array([t.pt for t in self.tracks], dtype=np.float32).reshape(-1, 1, 2)
+        pts_transformed = cv2.transform(pts, transform).reshape(-1, 2)
+        for i, t in enumerate(self.tracks):
+            t.pt = pts_transformed[i]
+
+    def update(self, frame_bgr, detected_points):
+        """
+        Updates standard tracking variables and detects chaos.
+
+        Returns:
+            tuple[list[PointTrack], int, bool]: active tracks, cumulative unique count, and anomaly flag.
+        """
+        # 1. Global motion compensation via Drone drift
+        transform = self.motion_estimator.update(frame_bgr)
+        self.apply_motion_compensation(transform)
+        
+        # 2. Increment age for all
+        for t in self.tracks:
+            t.time_since_update += 1
+            
+        detected_points = np.array(detected_points, dtype=np.float32)
+        
+        if len(self.tracks) == 0:
+            # First initialization
+            for pt in detected_points:
+                self.tracks.append(PointTrack(pt, self.next_id))
+                self.next_id += 1
+            return self.tracks.copy(), self.next_id - 1, False
+            
+        if len(detected_points) == 0:
+            # No points detected, clear out old ones based on constraint
+            self.tracks = [t for t in self.tracks if t.time_since_update <= self.max_age]
+            return self.tracks.copy(), self.next_id - 1, False
+            
+        # 3. Hungarian matching assignment optimally pairing tracked to current
+        track_pts = np.array([t.pt for t in self.tracks], dtype=np.float32)
+        
+        # Cost matrix: NxM distance mapping
+        diff = track_pts[:, np.newaxis, :] - detected_points[np.newaxis, :, :]
+        dist_matrix = np.sqrt(np.sum(diff**2, axis=2))
+        
+        # Optimization resolution
+        row_ind, col_ind = linear_sum_assignment(dist_matrix)
+        
+        assigned_tracks = set()
+        assigned_detections = set()
+        
+        for r, c in zip(row_ind, col_ind):
+            if dist_matrix[r, c] <= self.max_distance:
+                # Update velocity (distance from last position)
+                self.tracks[r].velocity = dist_matrix[r, c]
+                self.tracks[r].pt = detected_points[c]
+                self.tracks[r].time_since_update = 0
+                assigned_tracks.add(r)
+                assigned_detections.add(c)
+
+                
+        # 4. Handle unassigned fresh detections
+        for i, pt in enumerate(detected_points):
+            if i not in assigned_detections:
+                self.tracks.append(PointTrack(pt, self.next_id))
+                self.next_id += 1
+                
+        # 5. Remove permanently lost/dead tracks
+        self.tracks = [t for t in self.tracks if t.time_since_update <= self.max_age]
+        
+        # 6. Chaos detection criteria: if > 5 tracks are moving anomalously rapidly
+        chaotic_count = sum(1 for t in self.tracks if t.velocity > self.max_distance * 0.7 and t.time_since_update == 0)
+        anomaly = chaotic_count >= 5
+        
+        return self.tracks.copy(), self.next_id - 1, anomaly

train.py

@@ -0,0 +1,229 @@
+import argparse
+import datetime
+import random
+import time
+from pathlib import Path
+
+import torch
+from torch.utils.data import DataLoader, DistributedSampler
+
+from crowd_datasets import build_dataset
+from engine import *
+from models import build_model
+import os
+from tensorboardX import SummaryWriter
+import warnings
+warnings.filterwarnings('ignore')
+
+def get_args_parser():
+    parser = argparse.ArgumentParser('Set parameters for training P2PNet', add_help=False)
+    parser.add_argument('--lr', default=1e-4, type=float)
+    parser.add_argument('--lr_backbone', default=1e-5, type=float)
+    parser.add_argument('--batch_size', default=8, type=int)
+    parser.add_argument('--weight_decay', default=1e-4, type=float)
+    parser.add_argument('--epochs', default=3500, type=int)
+    parser.add_argument('--lr_drop', default=3500, type=int)
+    parser.add_argument('--clip_max_norm', default=0.1, type=float,
+                        help='gradient clipping max norm')
+
+    # Model parameters
+    parser.add_argument('--frozen_weights', type=str, default=None,
+                        help="Path to the pretrained model. If set, only the mask head will be trained")
+
+    # * Backbone
+    parser.add_argument('--backbone', default='vgg16_bn', type=str,
+                        help="Name of the convolutional backbone to use")
+
+    # * Matcher
+    parser.add_argument('--set_cost_class', default=1, type=float,
+                        help="Class coefficient in the matching cost")
+
+    parser.add_argument('--set_cost_point', default=0.05, type=float,
+                        help="L1 point coefficient in the matching cost")
+
+    # * Loss coefficients
+    parser.add_argument('--point_loss_coef', default=0.0002, type=float)
+
+    parser.add_argument('--eos_coef', default=0.5, type=float,
+                        help="Relative classification weight of the no-object class")
+    parser.add_argument('--row', default=2, type=int,
+                        help="row number of anchor points")
+    parser.add_argument('--line', default=2, type=int,
+                        help="line number of anchor points")
+
+    # dataset parameters
+    parser.add_argument('--dataset_file', default='SHHA',
+                        help='Dataset loader to use: SHHA')
+    parser.add_argument('--data_root', default='./new_public_density_data',
+                        help='path where the dataset is')
+    
+    parser.add_argument('--output_dir', default='./log',
+                        help='path where to save, empty for no saving')
+    parser.add_argument('--checkpoints_dir', default='./ckpt',
+                        help='path where to save checkpoints, empty for no saving')
+    parser.add_argument('--tensorboard_dir', default='./runs',
+                        help='path where to save, empty for no saving')
+
+    parser.add_argument('--seed', default=42, type=int)
+    parser.add_argument('--resume', default='', help='resume from checkpoint')
+    parser.add_argument('--start_epoch', default=0, type=int, metavar='N',
+                        help='start epoch')
+    parser.add_argument('--eval', action='store_true')
+    parser.add_argument('--num_workers', default=8, type=int)
+    parser.add_argument('--eval_freq', default=5, type=int,
+                        help='frequency of evaluation, default setting is evaluating in every 5 epoch')
+    parser.add_argument('--gpu_id', default=0, type=int, help='the gpu used for training')
+
+    return parser
+
+def main(args):
+    os.environ["CUDA_VISIBLE_DEVICES"] = '{}'.format(args.gpu_id)
+    if args.output_dir:
+        os.makedirs(args.output_dir, exist_ok=True)
+    if args.checkpoints_dir:
+        os.makedirs(args.checkpoints_dir, exist_ok=True)
+    if args.tensorboard_dir:
+        os.makedirs(args.tensorboard_dir, exist_ok=True)
+    # create the logging file
+    run_log_name = os.path.join(args.output_dir, 'run_log.txt')
+    with open(run_log_name, "w") as log_file:
+        log_file.write('Eval Log %s\n' % time.strftime("%c"))
+
+    if args.frozen_weights is not None:
+        assert args.masks, "Frozen training is meant for segmentation only"
+    # backup the arguments
+    print(args)
+    with open(run_log_name, "a") as log_file:
+        log_file.write("{}".format(args))
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    # fix the seed for reproducibility
+    seed = args.seed + utils.get_rank()
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    # get the P2PNet model
+    model, criterion = build_model(args, training=True)
+    # move to the selected device
+    model.to(device)
+    criterion.to(device)
+
+    model_without_ddp = model
+
+    n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print('number of params:', n_parameters)
+    # use different optimation params for different parts of the model
+    param_dicts = [
+        {"params": [p for n, p in model_without_ddp.named_parameters() if "backbone" not in n and p.requires_grad]},
+        {
+            "params": [p for n, p in model_without_ddp.named_parameters() if "backbone" in n and p.requires_grad],
+            "lr": args.lr_backbone,
+        },
+    ]
+    # Adam is used by default
+    optimizer = torch.optim.Adam(param_dicts, lr=args.lr)
+    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, args.lr_drop)
+    # create the dataset
+    loading_data = build_dataset(args=args)
+    # create the training and valiation set
+    train_set, val_set = loading_data(args.data_root)
+    # create the sampler used during training
+    sampler_train = torch.utils.data.RandomSampler(train_set)
+    sampler_val = torch.utils.data.SequentialSampler(val_set)
+
+    batch_sampler_train = torch.utils.data.BatchSampler(
+        sampler_train, args.batch_size, drop_last=True)
+    # the dataloader for training
+    data_loader_train = DataLoader(train_set, batch_sampler=batch_sampler_train,
+                                   collate_fn=utils.collate_fn_crowd, num_workers=args.num_workers)
+
+    data_loader_val = DataLoader(val_set, 1, sampler=sampler_val,
+                                    drop_last=False, collate_fn=utils.collate_fn_crowd, num_workers=args.num_workers)
+
+    if args.frozen_weights is not None:
+        checkpoint = torch.load(args.frozen_weights, map_location='cpu')
+        model_without_ddp.detr.load_state_dict(checkpoint['model'])
+    # resume the weights and training state if exists
+    if args.resume:
+        checkpoint = torch.load(args.resume, map_location='cpu')
+        model_without_ddp.load_state_dict(checkpoint['model'])
+        if not args.eval and 'optimizer' in checkpoint and 'lr_scheduler' in checkpoint and 'epoch' in checkpoint:
+            optimizer.load_state_dict(checkpoint['optimizer'])
+            lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+            args.start_epoch = checkpoint['epoch'] + 1
+
+    print("Start training")
+    start_time = time.time()
+    # save the performance during the training
+    mae = []
+    mse = []
+    # the logger writer
+    writer = SummaryWriter(args.tensorboard_dir)
+    
+    step = 0
+    # training starts here
+    for epoch in range(args.start_epoch, args.epochs):
+        t1 = time.time()
+        stat = train_one_epoch(
+            model, criterion, data_loader_train, optimizer, device, epoch,
+            args.clip_max_norm)
+
+        # record the training states after every epoch
+        if writer is not None:
+            with open(run_log_name, "a") as log_file:
+                log_file.write("loss/loss@{}: {}".format(epoch, stat['loss']))
+                log_file.write("loss/loss_ce@{}: {}".format(epoch, stat['loss_ce']))
+                
+            writer.add_scalar('loss/loss', stat['loss'], epoch)
+            writer.add_scalar('loss/loss_ce', stat['loss_ce'], epoch)
+
+        t2 = time.time()
+        print('[ep %d][lr %.7f][%.2fs]' % \
+              (epoch, optimizer.param_groups[0]['lr'], t2 - t1))
+        with open(run_log_name, "a") as log_file:
+            log_file.write('[ep %d][lr %.7f][%.2fs]' % (epoch, optimizer.param_groups[0]['lr'], t2 - t1))
+        # change lr according to the scheduler
+        lr_scheduler.step()
+        # save latest weights every epoch
+        checkpoint_latest_path = os.path.join(args.checkpoints_dir, 'latest.pth')
+        torch.save({
+            'model': model_without_ddp.state_dict(),
+        }, checkpoint_latest_path)
+        # run evaluation
+        if epoch % args.eval_freq == 0 and epoch != 0:
+            t1 = time.time()
+            result = evaluate_crowd_no_overlap(model, data_loader_val, device)
+            t2 = time.time()
+
+            mae.append(result[0])
+            mse.append(result[1])
+            # print the evaluation results
+            print('=======================================test=======================================')
+            print("mae:", result[0], "mse:", result[1], "time:", t2 - t1, "best mae:", np.min(mae), )
+            with open(run_log_name, "a") as log_file:
+                log_file.write("mae:{}, mse:{}, time:{}, best mae:{}".format(result[0], 
+                                result[1], t2 - t1, np.min(mae)))
+            print('=======================================test=======================================')
+            # recored the evaluation results
+            if writer is not None:
+                with open(run_log_name, "a") as log_file:
+                    log_file.write("metric/mae@{}: {}".format(step, result[0]))
+                    log_file.write("metric/mse@{}: {}".format(step, result[1]))
+                writer.add_scalar('metric/mae', result[0], step)
+                writer.add_scalar('metric/mse', result[1], step)
+                step += 1
+
+            # save the best model since begining
+            if abs(np.min(mae) - result[0]) < 0.01:
+                checkpoint_best_path = os.path.join(args.checkpoints_dir, 'best_mae.pth')
+                torch.save({
+                    'model': model_without_ddp.state_dict(),
+                }, checkpoint_best_path)
+    # total time for training
+    total_time = time.time() - start_time
+    total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+    print('Training time {}'.format(total_time_str))
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser('P2PNet training and evaluation script', parents=[get_args_parser()])
+    args = parser.parse_args()
+    main(args)

util/misc.py

@@ -0,0 +1,506 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Misc functions, including distributed helpers.
+
+Mostly copy-paste from torchvision references.
+"""
+import os
+import subprocess
+import time
+from collections import defaultdict, deque
+import datetime
+import pickle
+from typing import Optional, List
+
+import torch
+import torch.distributed as dist
+from torch import Tensor
+
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+import torchvision
+
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not is_dist_avail_and_initialized():
+            return
+        t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
+        dist.barrier()
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value)
+
+
+def all_gather(data):
+    """
+    Run all_gather on arbitrary picklable data (not necessarily tensors)
+    Args:
+        data: any picklable object
+    Returns:
+        list[data]: list of data gathered from each rank
+    """
+    world_size = get_world_size()
+    if world_size == 1:
+        return [data]
+
+    # serialized to a Tensor
+    buffer = pickle.dumps(data)
+    storage = torch.ByteStorage.from_buffer(buffer)
+    tensor = torch.ByteTensor(storage).to("cuda")
+
+    # obtain Tensor size of each rank
+    local_size = torch.tensor([tensor.numel()], device="cuda")
+    size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)]
+    dist.all_gather(size_list, local_size)
+    size_list = [int(size.item()) for size in size_list]
+    max_size = max(size_list)
+
+    # receiving Tensor from all ranks
+    # we pad the tensor because torch all_gather does not support
+    # gathering tensors of different shapes
+    tensor_list = []
+    for _ in size_list:
+        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda"))
+    if local_size != max_size:
+        padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda")
+        tensor = torch.cat((tensor, padding), dim=0)
+    dist.all_gather(tensor_list, tensor)
+
+    data_list = []
+    for size, tensor in zip(size_list, tensor_list):
+        buffer = tensor.cpu().numpy().tobytes()[:size]
+        data_list.append(pickle.loads(buffer))
+
+    return data_list
+
+
+def reduce_dict(input_dict, average=True):
+    """
+    Args:
+        input_dict (dict): all the values will be reduced
+        average (bool): whether to do average or sum
+    Reduce the values in the dictionary from all processes so that all processes
+    have the averaged results. Returns a dict with the same fields as
+    input_dict, after reduction.
+    """
+    world_size = get_world_size()
+    if world_size < 2:
+        return input_dict
+    with torch.no_grad():
+        names = []
+        values = []
+        # sort the keys so that they are consistent across processes
+        for k in sorted(input_dict.keys()):
+            names.append(k)
+            values.append(input_dict[k])
+        values = torch.stack(values, dim=0)
+        dist.all_reduce(values)
+        if average:
+            values /= world_size
+        reduced_dict = {k: v for k, v in zip(names, values)}
+    return reduced_dict
+
+
+class MetricLogger(object):
+    def __init__(self, delimiter="\t"):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError("'{}' object has no attribute '{}'".format(
+            type(self).__name__, attr))
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {}".format(name, str(meter))
+            )
+        return self.delimiter.join(loss_str)
+
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes()
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ''
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt='{avg:.4f}')
+        data_time = SmoothedValue(fmt='{avg:.4f}')
+        space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
+        if torch.cuda.is_available():
+            log_msg = self.delimiter.join([
+                header,
+                '[{0' + space_fmt + '}/{1}]',
+                'eta: {eta}',
+                '{meters}',
+                'time: {time}',
+                'data: {data}',
+                'max mem: {memory:.0f}'
+            ])
+        else:
+            log_msg = self.delimiter.join([
+                header,
+                '[{0' + space_fmt + '}/{1}]',
+                'eta: {eta}',
+                '{meters}',
+                'time: {time}',
+                'data: {data}'
+            ])
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0 or i == len(iterable) - 1:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time),
+                        memory=torch.cuda.max_memory_allocated() / MB))
+                else:
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time)))
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print('{} Total time: {} ({:.4f} s / it)'.format(
+            header, total_time_str, total_time / len(iterable)))
+
+
+def get_sha():
+    cwd = os.path.dirname(os.path.abspath(__file__))
+
+    def _run(command):
+        return subprocess.check_output(command, cwd=cwd).decode('ascii').strip()
+    sha = 'N/A'
+    diff = "clean"
+    branch = 'N/A'
+    try:
+        sha = _run(['git', 'rev-parse', 'HEAD'])
+        subprocess.check_output(['git', 'diff'], cwd=cwd)
+        diff = _run(['git', 'diff-index', 'HEAD'])
+        diff = "has uncommited changes" if diff else "clean"
+        branch = _run(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
+    except Exception:
+        pass
+    message = f"sha: {sha}, status: {diff}, branch: {branch}"
+    return message
+
+
+def collate_fn(batch):
+    batch = list(zip(*batch))
+    batch[0] = nested_tensor_from_tensor_list(batch[0])
+    return tuple(batch)
+
+def collate_fn_crowd(batch):
+    # re-organize the batch
+    batch_new = []
+    for b in batch:
+        imgs, points = b
+        if imgs.ndim == 3:
+            imgs = imgs.unsqueeze(0)
+        for i in range(len(imgs)):
+            batch_new.append((imgs[i, :, :, :], points[i]))
+    batch = batch_new
+    batch = list(zip(*batch))
+    batch[0] = nested_tensor_from_tensor_list(batch[0])
+    return tuple(batch)
+
+
+def _max_by_axis(the_list):
+    # type: (List[List[int]]) -> List[int]
+    maxes = the_list[0]
+    for sublist in the_list[1:]:
+        for index, item in enumerate(sublist):
+            maxes[index] = max(maxes[index], item)
+    return maxes
+
+def _max_by_axis_pad(the_list):
+    # type: (List[List[int]]) -> List[int]
+    maxes = the_list[0]
+    for sublist in the_list[1:]:
+        for index, item in enumerate(sublist):
+            maxes[index] = max(maxes[index], item)
+
+    block = 128
+
+    for i in range(2):
+        maxes[i+1] = ((maxes[i+1] - 1) // block + 1) * block
+    return maxes
+
+
+def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
+    # TODO make this more general
+    if tensor_list[0].ndim == 3:
+
+        # TODO make it support different-sized images
+        max_size = _max_by_axis_pad([list(img.shape) for img in tensor_list])
+        # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
+        batch_shape = [len(tensor_list)] + max_size
+        b, c, h, w = batch_shape
+        dtype = tensor_list[0].dtype
+        device = tensor_list[0].device
+        tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
+        for img, pad_img in zip(tensor_list, tensor):
+            pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
+    else:
+        raise ValueError('not supported')
+    return tensor
+
+class NestedTensor(object):
+    def __init__(self, tensors, mask: Optional[Tensor]):
+        self.tensors = tensors
+        self.mask = mask
+
+    def to(self, device):
+        # type: (Device) -> NestedTensor # noqa
+        cast_tensor = self.tensors.to(device)
+        mask = self.mask
+        if mask is not None:
+            assert mask is not None
+            cast_mask = mask.to(device)
+        else:
+            cast_mask = None
+        return NestedTensor(cast_tensor, cast_mask)
+
+    def decompose(self):
+        return self.tensors, self.mask
+
+    def __repr__(self):
+        return str(self.tensors)
+
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop('force', False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+    if is_main_process():
+        torch.save(*args, **kwargs)
+
+
+def init_distributed_mode(args):
+    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
+        args.rank = int(os.environ["RANK"])
+        args.world_size = int(os.environ['WORLD_SIZE'])
+        args.gpu = int(os.environ['LOCAL_RANK'])
+    elif 'SLURM_PROCID' in os.environ:
+        args.rank = int(os.environ['SLURM_PROCID'])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print('Not using distributed mode')
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = 'nccl'
+    print('| distributed init (rank {}): {}'.format(
+        args.rank, args.dist_url), flush=True)
+    torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+                                         world_size=args.world_size, rank=args.rank)
+    torch.distributed.barrier()
+    setup_for_distributed(args.rank == 0)
+
+
+@torch.no_grad()
+def accuracy(output, target, topk=(1,)):
+    """Computes the precision@k for the specified values of k"""
+    if target.numel() == 0:
+        return [torch.zeros([], device=output.device)]
+    maxk = max(topk)
+    batch_size = target.size(0)
+
+    _, pred = output.topk(maxk, 1, True, True)
+    pred = pred.t()
+    correct = pred.eq(target.view(1, -1).expand_as(pred))
+
+    res = []
+    for k in topk:
+        correct_k = correct[:k].view(-1).float().sum(0)
+        res.append(correct_k.mul_(100.0 / batch_size))
+    return res
+
+
+def interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None):
+    # type: (Tensor, Optional[List[int]], Optional[float], str, Optional[bool]) -> Tensor
+    """
+    Equivalent to nn.functional.interpolate, but with support for empty batch sizes.
+    This will eventually be supported natively by PyTorch, and this
+    class can go away.
+    """
+    return torch.nn.functional.interpolate(
+        input, size, scale_factor, mode, align_corners
+    )
+
+
+class FocalLoss(nn.Module):
+    r"""
+        This criterion is a implemenation of Focal Loss, which is proposed in
+        Focal Loss for Dense Object Detection.
+
+            Loss(x, class) = - \alpha (1-softmax(x)[class])^gamma \log(softmax(x)[class])
+
+        The losses are averaged across observations for each minibatch.
+
+        Args:
+            alpha(1D Tensor, Variable) : the scalar factor for this criterion
+            gamma(float, double) : gamma > 0; reduces the relative loss for well-classified examples (p > .5),
+                                   putting more focus on hard, misclassified examples
+            size_average(bool): By default, the losses are averaged over observations for each minibatch.
+                                However, if the field size_average is set to False, the losses are
+                                instead summed for each minibatch.
+
+
+    """
+    def __init__(self, class_num, alpha=None, gamma=2, size_average=True):
+        super(FocalLoss, self).__init__()
+        if alpha is None:
+            self.alpha = Variable(torch.ones(class_num, 1))
+        else:
+            if isinstance(alpha, Variable):
+                self.alpha = alpha
+            else:
+                self.alpha = Variable(alpha)
+        self.gamma = gamma
+        self.class_num = class_num
+        self.size_average = size_average
+
+    def forward(self, inputs, targets):
+        N = inputs.size(0)
+        C = inputs.size(1)
+        P = F.softmax(inputs)
+
+        class_mask = inputs.data.new(N, C).fill_(0)
+        class_mask = Variable(class_mask)
+        ids = targets.view(-1, 1)
+        class_mask.scatter_(1, ids.data, 1.)
+
+        if inputs.is_cuda and not self.alpha.is_cuda:
+            self.alpha = self.alpha.cuda()
+        alpha = self.alpha[ids.data.view(-1)]
+
+        probs = (P*class_mask).sum(1).view(-1,1)
+
+        log_p = probs.log()
+        batch_loss = -alpha*(torch.pow((1-probs), self.gamma))*log_p
+
+        if self.size_average:
+            loss = batch_loss.mean()
+        else:
+            loss = batch_loss.sum()
+        return loss